[Sync] //components/sync internal changes [DO NOT SUBMIT]

components/sync/engine_impl/net/server_connection_manager.cc

 // Copyright (c) 2012 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/engine/net/server_connection_manager.h"
+#include "components/sync/engine_impl/net/server_connection_manager.h"
 
 #include <errno.h>
 #include <stdint.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
+#include "components/sync/base/cancelation_signal.h"
+#include "components/sync/engine_impl/net/url_translator.h"
+#include "components/sync/engine_impl/syncer.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/syncable/directory.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
-#include "sync/engine/net/url_translator.h"
-#include "sync/engine/syncer.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/syncable/directory.h"
 #include "url/gurl.h"
 
 namespace syncer {
 
 using std::ostream;
 using std::string;
 using std::vector;
 
 static const char kSyncServerSyncPath[] = "/command/";
 
 HttpResponse::HttpResponse()
     : response_code(kUnsetResponseCode),
       content_length(kUnsetContentLength),
       payload_length(kUnsetPayloadLength),
       server_status(NONE) {}
 
-#define ENUM_CASE(x) case x: return #x; break
+#define ENUM_CASE(x) \
+  case x:            \
+    return #x;       \
+    break
 
 const char* HttpResponse::GetServerConnectionCodeString(
     ServerConnectionCode code) {
   switch (code) {
     ENUM_CASE(NONE);
     ENUM_CASE(CONNECTION_UNAVAILABLE);
     ENUM_CASE(IO_ERROR);
     ENUM_CASE(SYNC_SERVER_ERROR);
     ENUM_CASE(SYNC_AUTH_ERROR);
     ENUM_CASE(SERVER_CONNECTION_OK);
     ENUM_CASE(RETRY);
   }
   NOTREACHED();
   return "";
 }
 
 #undef ENUM_CASE
 
-ServerConnectionManager::Connection::Connection(
-    ServerConnectionManager* scm) : scm_(scm) {
-}
+ServerConnectionManager::Connection::Connection(ServerConnectionManager* scm)
+    : scm_(scm) {}
 
-ServerConnectionManager::Connection::~Connection() {
-}
+ServerConnectionManager::Connection::~Connection() {}
 
 bool ServerConnectionManager::Connection::ReadBufferResponse(
     string* buffer_out,
     HttpResponse* response,
     bool require_response) {
   if (net::HTTP_OK != response->response_code) {
     response->server_status = HttpResponse::SYNC_SERVER_ERROR;
     return false;
   }
 
   if (require_response && (1 > response->content_length))
     return false;
 
   const int64_t bytes_read =
       ReadResponse(buffer_out, static_cast<int>(response->content_length));
   if (bytes_read != response->content_length) {
     response->server_status = HttpResponse::IO_ERROR;
     return false;
   }
   return true;
 }
 
 bool ServerConnectionManager::Connection::ReadDownloadResponse(
     HttpResponse* response,
     string* buffer_out) {
   const int64_t bytes_read =
       ReadResponse(buffer_out, static_cast<int>(response->content_length));
 
   if (bytes_read != response->content_length) {
-    LOG(ERROR) << "Mismatched content lengths, server claimed " <<
-        response->content_length << ", but sent " << bytes_read;
+    LOG(ERROR) << "Mismatched content lengths, server claimed "
+               << response->content_length << ", but sent " << bytes_read;
     response->server_status = HttpResponse::IO_ERROR;
     return false;
   }
   return true;
 }
 
 ServerConnectionManager::ScopedConnectionHelper::ScopedConnectionHelper(
-    ServerConnectionManager* manager, Connection* connection)
+    ServerConnectionManager* manager,
+    Connection* connection)
     : manager_(manager), connection_(connection) {}
 
 ServerConnectionManager::ScopedConnectionHelper::~ScopedConnectionHelper() {
   if (connection_)
     manager_->OnConnectionDestroyed(connection_.get());
   connection_.reset();
 }
 
 ServerConnectionManager::Connection*
 ServerConnectionManager::ScopedConnectionHelper::get() {
@@ skipping 120 matching lines @@
   if (server_status != HttpResponse::SYNC_AUTH_ERROR &&
       server_status_ == server_status) {
     return;
   }
   server_status_ = server_status;
   NotifyStatusChanged();
 }
 
 void ServerConnectionManager::NotifyStatusChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FOR_EACH_OBSERVER(ServerConnectionEventListener, listeners_,
-     OnServerConnectionEvent(
-         ServerConnectionEvent(server_status_)));
+  FOR_EACH_OBSERVER(
+      ServerConnectionEventListener, listeners_,
+      OnServerConnectionEvent(ServerConnectionEvent(server_status_)));
 }
 
 bool ServerConnectionManager::PostBufferWithCachedAuth(
     PostBufferParams* params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   string path =
       MakeSyncServerPath(proto_sync_path(), MakeSyncQueryString(client_id_));
   bool result = PostBufferToPath(params, path, auth_token());
   SetServerStatus(params->response.server_status);
   return result;
@@ skipping 18 matching lines @@
   // When our connection object falls out of scope, it clears itself from
   // active_connection_.
   ScopedConnectionHelper post(this, MakeActiveConnection());
   if (!post.get()) {
     params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
     return false;
   }
 
   // Note that |post| may be aborted by now, which will just cause Init to fail
   // with CONNECTION_UNAVAILABLE.
-  bool ok = post.get()->Init(
-      path.c_str(), auth_token, params->buffer_in, &params->response);
+  bool ok = post.get()->Init(path.c_str(), auth_token, params->buffer_in,
+                             &params->response);
 
   if (params->response.server_status == HttpResponse::SYNC_AUTH_ERROR) {
     InvalidateAndClearAuthToken();
   }
 
   if (!ok || net::HTTP_OK != params->response.response_code)
     return false;
 
-  if (post.get()->ReadBufferResponse(
-      &params->buffer_out, &params->response, true)) {
+  if (post.get()->ReadBufferResponse(&params->buffer_out, &params->response,
+                                     true)) {
     params->response.server_status = HttpResponse::SERVER_CONNECTION_OK;
     return true;
   }
   return false;
 }
 
 void ServerConnectionManager::AddListener(
     ServerConnectionEventListener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.AddObserver(listener);
@@ skipping 13 matching lines @@
   base::AutoLock lock(terminate_connection_lock_);
   terminated_ = true;
   if (active_connection_)
     active_connection_->Abort();
 
   // Sever our ties to this connection object. Note that it still may exist,
   // since we don't own it, but it has been neutered.
   active_connection_ = NULL;
 }
 
-std::ostream& operator << (std::ostream& s, const struct HttpResponse& hr) {
+std::ostream& operator<<(std::ostream& s, const struct HttpResponse& hr) {
   s << " Response Code (bogus on error): " << hr.response_code;
   s << " Content-Length (bogus on error): " << hr.content_length;
   s << " Server Status: "
     << HttpResponse::GetServerConnectionCodeString(hr.server_status);
   return s;
 }
 
 }  // namespace syncer