sync/test/fake_server/fake_server_http_post_provider.cc

   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/memory/weak_ptr.h"
  13 #include "base/sequenced_task_runner.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "sync/test/fake_server/fake_server.h"
  16
  17 using syncer::HttpPostProviderInterface;
  18
  19 namespace fake_server {
  20
  21 FakeServerHttpPostProviderFactory::FakeServerHttpPostProviderFactory(
  22     const base::WeakPtr<FakeServer>& fake_server,
  23     scoped_refptr<base::SequencedTaskRunner> fake_server_task_runner)
  24         : fake_server_(fake_server),
  25           fake_server_task_runner_(fake_server_task_runner) { }
  26
  27 FakeServerHttpPostProviderFactory::~FakeServerHttpPostProviderFactory() { }
  28
  29 void FakeServerHttpPostProviderFactory::Init(
  30     const std::string& user_agent,
  31     const syncer::BindToTrackerCallback& bind_to_tracker_callback) {}
  32
  33 HttpPostProviderInterface* FakeServerHttpPostProviderFactory::Create() {
  34   FakeServerHttpPostProvider* http =
  35       new FakeServerHttpPostProvider(fake_server_, fake_server_task_runner_);
  36   http->AddRef();
  37   return http;
  38 }
  39
  40 void FakeServerHttpPostProviderFactory::Destroy(
  41     HttpPostProviderInterface* http) {
  42   static_cast<FakeServerHttpPostProvider*>(http)->Release();
  43 }
  44
  45 FakeServerHttpPostProvider::FakeServerHttpPostProvider(
  46     const base::WeakPtr<FakeServer>& fake_server,
  47     scoped_refptr<base::SequencedTaskRunner> fake_server_task_runner)
  48         : fake_server_(fake_server),
  49           fake_server_task_runner_(fake_server_task_runner) { }
  50
  51 FakeServerHttpPostProvider::~FakeServerHttpPostProvider() { }
  52
  53 void FakeServerHttpPostProvider::SetExtraRequestHeaders(const char* headers) {
  54   // TODO(pvalenzuela): Add assertions on this value.
  55   extra_request_headers_.assign(headers);
  56 }
  57
  58 void FakeServerHttpPostProvider::SetURL(const char* url, int port) {
  59   // TODO(pvalenzuela): Add assertions on these values.
  60   request_url_.assign(url);
  61   request_port_ = port;
  62 }
  63
  64 void FakeServerHttpPostProvider::SetPostPayload(const char* content_type,
  65                                                 int content_length,
  66                                                 const char* content) {
  67   request_content_type_.assign(content_type);
  68   request_content_.assign(content, content_length);
  69 }
  70
  71 bool FakeServerHttpPostProvider::MakeSynchronousPost(int* error_code,
  72                                                      int* response_code) {
  73   // It is assumed that a POST is being made to /command.
  74   int post_error_code = -1;
  75   int post_response_code = -1;
  76   std::string post_response;
  77
  78   base::WaitableEvent post_complete(false, false);
  79   base::Closure signal_closure = base::Bind(&base::WaitableEvent::Signal,
  80                                             base::Unretained(&post_complete));
  81
  82   bool result = fake_server_task_runner_->PostTask(
  83       FROM_HERE,
  84       base::Bind(&FakeServer::HandleCommand,
  85                  fake_server_,
  86                  base::ConstRef(request_content_),
  87                  base::ConstRef(signal_closure),
  88                  &post_error_code,
  89                  &post_response_code,
  90                  &post_response));
  91
  92   if (!result)
  93     return false;
  94
  95   post_complete.Wait();
  96   post_error_code_ = post_error_code;
  97   post_response_code_ = post_response_code;
  98   response_ = post_response;
  99
 100   *error_code = post_error_code_;
 101   *response_code = post_response_code_;
 102   return *error_code == 0;
 103 }
 104
 105 int FakeServerHttpPostProvider::GetResponseContentLength() const {
 106   return response_.length();
 107 }
 108
 109 const char* FakeServerHttpPostProvider::GetResponseContent() const {
 110   return response_.c_str();
 111 }
 112
 113 const std::string FakeServerHttpPostProvider::GetResponseHeaderValue(
 114     const std::string& name) const {
 115   return std::string();
 116 }
 117
 118 void FakeServerHttpPostProvider::Abort() {
 119 }
 120
 121 }  // namespace fake_server