sync/test/fake_server/fake_server_http_post_provider.cc

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "sync/test/fake_server/fake_server_http_post_provider.h"

#include <string>

#include "base/bind.h"
#include "base/location.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/sequenced_task_runner.h"
#include "base/synchronization/waitable_event.h"
#include "sync/test/fake_server/fake_server.h"

using syncer::HttpPostProviderInterface;

namespace fake_server {

FakeServerHttpPostProviderFactory::FakeServerHttpPostProviderFactory(
    const base::WeakPtr<FakeServer>& fake_server,
    scoped_refptr<base::SequencedTaskRunner> fake_server_task_runner)
        : fake_server_(fake_server),
          fake_server_task_runner_(fake_server_task_runner) { }

FakeServerHttpPostProviderFactory::~FakeServerHttpPostProviderFactory() { }

void FakeServerHttpPostProviderFactory::Init(
    const std::string& user_agent,
    const syncer::BindToTrackerCallback& bind_to_tracker_callback) {}

HttpPostProviderInterface* FakeServerHttpPostProviderFactory::Create() {
  FakeServerHttpPostProvider* http =
      new FakeServerHttpPostProvider(fake_server_, fake_server_task_runner_);
  http->AddRef();
  return http;
}

void FakeServerHttpPostProviderFactory::Destroy(
    HttpPostProviderInterface* http) {
  static_cast<FakeServerHttpPostProvider*>(http)->Release();
}

FakeServerHttpPostProvider::FakeServerHttpPostProvider(
    const base::WeakPtr<FakeServer>& fake_server,
    scoped_refptr<base::SequencedTaskRunner> fake_server_task_runner)
        : fake_server_(fake_server),
          fake_server_task_runner_(fake_server_task_runner) { }

FakeServerHttpPostProvider::~FakeServerHttpPostProvider() { }

void FakeServerHttpPostProvider::SetExtraRequestHeaders(const char* headers) {
  // TODO(pvalenzuela): Add assertions on this value.
  extra_request_headers_.assign(headers);
}

void FakeServerHttpPostProvider::SetURL(const char* url, int port) {
  // TODO(pvalenzuela): Add assertions on these values.
  request_url_.assign(url);
  request_port_ = port;
}

void FakeServerHttpPostProvider::SetPostPayload(const char* content_type,
                                                int content_length,
                                                const char* content) {
  request_content_type_.assign(content_type);
  request_content_.assign(content, content_length);
}

bool FakeServerHttpPostProvider::MakeSynchronousPost(int* error_code,
                                                     int* response_code) {
  // It is assumed that a POST is being made to /command.
  int post_error_code = -1;
  int post_response_code = -1;
  std::string post_response;

  base::WaitableEvent post_complete(false, false);
  base::Closure signal_closure = base::Bind(&base::WaitableEvent::Signal,
                                            base::Unretained(&post_complete));

  bool result = fake_server_task_runner_->PostTask(
      FROM_HERE,
      base::Bind(&FakeServer::HandleCommand,
                 fake_server_,
                 base::ConstRef(request_content_),
                 base::ConstRef(signal_closure),
                 &post_error_code,
                 &post_response_code,
                 &post_response));

  if (!result)
    return false;

  post_complete.Wait();
  post_error_code_ = post_error_code;
  post_response_code_ = post_response_code;
  response_ = post_response;

  *error_code = post_error_code_;
  *response_code = post_response_code_;
  return *error_code == 0;
}

int FakeServerHttpPostProvider::GetResponseContentLength() const {
  return response_.length();
}

const char* FakeServerHttpPostProvider::GetResponseContent() const {
  return response_.c_str();
}

const std::string FakeServerHttpPostProvider::GetResponseHeaderValue(
    const std::string& name) const {
  return std::string();
}

void FakeServerHttpPostProvider::Abort() {
}

}  // namespace fake_server