1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "sync/test/fake_server/fake_server_http_post_provider.h"
6
7#include <string>
8
9#include "base/bind.h"
10#include "base/location.h"
11#include "base/memory/ref_counted.h"
12#include "base/sequenced_task_runner.h"
13#include "base/synchronization/waitable_event.h"
14#include "sync/test/fake_server/fake_server.h"
15
16using syncer::HttpPostProviderInterface;
17
18namespace fake_server {
19
20FakeServerHttpPostProviderFactory::FakeServerHttpPostProviderFactory(
21    FakeServer* fake_server,
22    scoped_refptr<base::SequencedTaskRunner> task_runner)
23        : fake_server_(fake_server), task_runner_(task_runner) { }
24
25FakeServerHttpPostProviderFactory::~FakeServerHttpPostProviderFactory() { }
26
27void FakeServerHttpPostProviderFactory::Init(const std::string& user_agent) { }
28
29HttpPostProviderInterface* FakeServerHttpPostProviderFactory::Create() {
30  FakeServerHttpPostProvider* http =
31      new FakeServerHttpPostProvider(fake_server_, task_runner_);
32  http->AddRef();
33  return http;
34}
35
36void FakeServerHttpPostProviderFactory::Destroy(
37    HttpPostProviderInterface* http) {
38  static_cast<FakeServerHttpPostProvider*>(http)->Release();
39}
40
41FakeServerHttpPostProvider::FakeServerHttpPostProvider(
42    FakeServer* fake_server,
43    scoped_refptr<base::SequencedTaskRunner> task_runner)
44        : fake_server_(fake_server),
45          task_runner_(task_runner),
46          post_complete_(false, false) { }
47
48FakeServerHttpPostProvider::~FakeServerHttpPostProvider() { }
49
50void FakeServerHttpPostProvider::SetExtraRequestHeaders(const char* headers) {
51  // TODO(pvalenzuela): Add assertions on this value.
52  extra_request_headers_.assign(headers);
53}
54
55void FakeServerHttpPostProvider::SetURL(const char* url, int port) {
56  // TODO(pvalenzuela): Add assertions on these values.
57  request_url_.assign(url);
58  request_port_ = port;
59}
60
61void FakeServerHttpPostProvider::SetPostPayload(const char* content_type,
62                                                int content_length,
63                                                const char* content) {
64  request_content_type_.assign(content_type);
65  request_content_.assign(content, content_length);
66}
67
68void FakeServerHttpPostProvider::OnPostComplete(int error_code,
69                                                int response_code,
70                                                const std::string& response) {
71  post_error_code_ = error_code;
72  post_response_code_ = response_code;
73  response_ = response;
74  post_complete_.Signal();
75}
76
77bool FakeServerHttpPostProvider::MakeSynchronousPost(int* error_code,
78                                                     int* response_code) {
79  // It is assumed that a POST is being made to /command.
80  FakeServer::HandleCommandCallback callback = base::Bind(
81      &FakeServerHttpPostProvider::OnPostComplete, base::Unretained(this));
82  task_runner_->PostNonNestableTask(FROM_HERE,
83                                    base::Bind(&FakeServer::HandleCommand,
84                                               base::Unretained(fake_server_),
85                                               base::ConstRef(request_content_),
86                                               base::ConstRef(callback)));
87  post_complete_.Wait();
88  *error_code = post_error_code_;
89  *response_code = post_response_code_;
90  return *error_code == 0;
91}
92
93int FakeServerHttpPostProvider::GetResponseContentLength() const {
94  return response_.length();
95}
96
97const char* FakeServerHttpPostProvider::GetResponseContent() const {
98  return response_.c_str();
99}
100
101const std::string FakeServerHttpPostProvider::GetResponseHeaderValue(
102    const std::string& name) const {
103  return std::string();
104}
105
106void FakeServerHttpPostProvider::Abort() {
107}
108
109}  // namespace fake_server
110