sync/internal_api/syncapi_server_connection_manager.cc

   1 // Copyright (c) 2012 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/internal_api/syncapi_server_connection_manager.h"
   6
   7 #include "net/base/net_errors.h"
   8 #include "net/http/http_status_code.h"
   9 #include "sync/internal_api/public/http_post_provider_factory.h"
  10 #include "sync/internal_api/public/http_post_provider_interface.h"
  11
  12 namespace syncer {
  13
  14 SyncAPIBridgedConnection::SyncAPIBridgedConnection(
  15     ServerConnectionManager* scm,
  16     HttpPostProviderFactory* factory)
  17     : Connection(scm), factory_(factory) {
  18   post_provider_ = factory_->Create();
  19 }
  20
  21 SyncAPIBridgedConnection::~SyncAPIBridgedConnection() {
  22   DCHECK(post_provider_);
  23   factory_->Destroy(post_provider_);
  24   post_provider_ = NULL;
  25 }
  26
  27 bool SyncAPIBridgedConnection::Init(const char* path,
  28                                     const std::string& auth_token,
  29                                     const std::string& payload,
  30                                     HttpResponse* response) {
  31   std::string sync_server;
  32   int sync_server_port = 0;
  33   bool use_ssl = false;
  34   GetServerParams(&sync_server, &sync_server_port, &use_ssl);
  35   std::string connection_url = MakeConnectionURL(sync_server, path, use_ssl);
  36
  37   HttpPostProviderInterface* http = post_provider_;
  38   http->SetURL(connection_url.c_str(), sync_server_port);
  39
  40   if (!auth_token.empty()) {
  41     const std::string& headers =
  42         "Authorization: GoogleLogin auth=" + auth_token;
  43     http->SetExtraRequestHeaders(headers.c_str());
  44   }
  45
  46   // Must be octet-stream, or the payload may be parsed for a cookie.
  47   http->SetPostPayload("application/octet-stream", payload.length(),
  48                        payload.data());
  49
  50   // Issue the POST, blocking until it finishes.
  51   int error_code = 0;
  52   int response_code = 0;
  53   if (!http->MakeSynchronousPost(&error_code, &response_code)) {
  54     DVLOG(1) << "Http POST failed, error returns: " << error_code;
  55     response->server_status = error_code == net::ERR_ABORTED ?
  56         HttpResponse::CONNECTION_UNAVAILABLE : HttpResponse::IO_ERROR;
  57     return false;
  58   }
  59
  60   // We got a server response, copy over response codes and content.
  61   response->response_code = response_code;
  62   response->content_length =
  63       static_cast<int64>(http->GetResponseContentLength());
  64   response->payload_length =
  65       static_cast<int64>(http->GetResponseContentLength());
  66   if (response->response_code < 400)
  67     response->server_status = HttpResponse::SERVER_CONNECTION_OK;
  68   else if (response->response_code == net::HTTP_UNAUTHORIZED)
  69     response->server_status = HttpResponse::SYNC_AUTH_ERROR;
  70   else
  71     response->server_status = HttpResponse::SYNC_SERVER_ERROR;
  72
  73   response->update_client_auth_header =
  74       http->GetResponseHeaderValue("Update-Client-Auth");
  75
  76   // Write the content into our buffer.
  77   buffer_.assign(http->GetResponseContent(), http->GetResponseContentLength());
  78   return true;
  79 }
  80
  81 void SyncAPIBridgedConnection::Abort() {
  82   DCHECK(post_provider_);
  83   post_provider_->Abort();
  84 }
  85
  86 SyncAPIServerConnectionManager::SyncAPIServerConnectionManager(
  87     const std::string& server,
  88     int port,
  89     bool use_ssl,
  90     HttpPostProviderFactory* factory)
  91     : ServerConnectionManager(server, port, use_ssl),
  92       post_provider_factory_(factory) {
  93   DCHECK(post_provider_factory_.get());
  94 }
  95
  96 SyncAPIServerConnectionManager::~SyncAPIServerConnectionManager() {}
  97
  98 ServerConnectionManager::Connection*
  99 SyncAPIServerConnectionManager::MakeConnection() {
 100   return new SyncAPIBridgedConnection(this, post_provider_factory_.get());
 101 }
 102
 103 }  // namespace syncer