[Sync] Rename csync namespace to syncer

sync/engine/syncer_proto_util.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/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/engine/traffic_logger.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/sync_enums.pb.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/util/time.h"
 
-using csync::SyncProtocolErrorType;
+using syncer::SyncProtocolErrorType;
 using std::string;
 using std::stringstream;
 using syncable::BASE_VERSION;
 using syncable::CTIME;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
 using syncable::MTIME;
 using syncable::PARENT_ID;
 
-namespace csync {
+namespace syncer {
 using sessions::SyncSession;
 
 namespace {
 
 // Time to backoff syncing after receiving a throttled response.
 const int kSyncDelayAfterThrottled = 2 * 60 * 60;  // 2 hours
 
 void LogResponseProfilingData(const ClientToServerResponse& response) {
   if (response.has_profiling_data()) {
     stringstream response_trace;
@@ skipping 163 matching lines @@
     }
   }
   return throttle_delay;
 }
 
 void SyncerProtoUtil::HandleThrottleError(
     const SyncProtocolError& error,
     const base::TimeTicks& throttled_until,
     ThrottledDataTypeTracker* tracker,
     sessions::SyncSession::Delegate* delegate) {
-  DCHECK_EQ(error.error_type, csync::THROTTLED);
+  DCHECK_EQ(error.error_type, syncer::THROTTLED);
   if (error.error_data_types.Empty()) {
     // No datatypes indicates the client should be completely throttled.
     delegate->OnSilencedUntil(throttled_until);
   } else {
     tracker->SetUnthrottleTime(error.error_data_types, throttled_until);
   }
 }
 
 namespace {
 
 // Helper function for an assertion in PostClientToServerMessage.
 bool IsVeryFirstGetUpdates(const ClientToServerMessage& message) {
   if (!message.has_get_updates())
     return false;
   DCHECK_LT(0, message.get_updates().from_progress_marker_size());
   for (int i = 0; i < message.get_updates().from_progress_marker_size(); ++i) {
     if (!message.get_updates().from_progress_marker(i).token().empty())
       return false;
   }
   return true;
 }
 
 SyncProtocolErrorType ConvertSyncProtocolErrorTypePBToLocalType(
     const sync_pb::SyncEnums::ErrorType& error_type) {
   switch (error_type) {
     case sync_pb::SyncEnums::SUCCESS:
-      return csync::SYNC_SUCCESS;
+      return syncer::SYNC_SUCCESS;
     case sync_pb::SyncEnums::NOT_MY_BIRTHDAY:
-      return csync::NOT_MY_BIRTHDAY;
+      return syncer::NOT_MY_BIRTHDAY;
     case sync_pb::SyncEnums::THROTTLED:
-      return csync::THROTTLED;
+      return syncer::THROTTLED;
     case sync_pb::SyncEnums::CLEAR_PENDING:
-      return csync::CLEAR_PENDING;
+      return syncer::CLEAR_PENDING;
     case sync_pb::SyncEnums::TRANSIENT_ERROR:
-      return csync::TRANSIENT_ERROR;
+      return syncer::TRANSIENT_ERROR;
     case sync_pb::SyncEnums::MIGRATION_DONE:
-      return csync::MIGRATION_DONE;
+      return syncer::MIGRATION_DONE;
     case sync_pb::SyncEnums::UNKNOWN:
-      return csync::UNKNOWN_ERROR;
+      return syncer::UNKNOWN_ERROR;
     case sync_pb::SyncEnums::USER_NOT_ACTIVATED:
     case sync_pb::SyncEnums::AUTH_INVALID:
     case sync_pb::SyncEnums::ACCESS_DENIED:
-      return csync::INVALID_CREDENTIAL;
+      return syncer::INVALID_CREDENTIAL;
     default:
       NOTREACHED();
-      return csync::UNKNOWN_ERROR;
+      return syncer::UNKNOWN_ERROR;
   }
 }
 
-csync::ClientAction ConvertClientActionPBToLocalClientAction(
+syncer::ClientAction ConvertClientActionPBToLocalClientAction(
     const sync_pb::SyncEnums::Action& action) {
   switch (action) {
     case sync_pb::SyncEnums::UPGRADE_CLIENT:
-      return csync::UPGRADE_CLIENT;
+      return syncer::UPGRADE_CLIENT;
     case sync_pb::SyncEnums::CLEAR_USER_DATA_AND_RESYNC:
-      return csync::CLEAR_USER_DATA_AND_RESYNC;
+      return syncer::CLEAR_USER_DATA_AND_RESYNC;
     case sync_pb::SyncEnums::ENABLE_SYNC_ON_ACCOUNT:
-      return csync::ENABLE_SYNC_ON_ACCOUNT;
+      return syncer::ENABLE_SYNC_ON_ACCOUNT;
     case sync_pb::SyncEnums::STOP_AND_RESTART_SYNC:
-      return csync::STOP_AND_RESTART_SYNC;
+      return syncer::STOP_AND_RESTART_SYNC;
     case sync_pb::SyncEnums::DISABLE_SYNC_ON_CLIENT:
-      return csync::DISABLE_SYNC_ON_CLIENT;
+      return syncer::DISABLE_SYNC_ON_CLIENT;
     case sync_pb::SyncEnums::UNKNOWN_ACTION:
-      return csync::UNKNOWN_ACTION;
+      return syncer::UNKNOWN_ACTION;
     default:
       NOTREACHED();
-      return csync::UNKNOWN_ACTION;
+      return syncer::UNKNOWN_ACTION;
   }
 }
 
-csync::SyncProtocolError ConvertErrorPBToLocalType(
+syncer::SyncProtocolError ConvertErrorPBToLocalType(
     const sync_pb::ClientToServerResponse::Error& error) {
-  csync::SyncProtocolError sync_protocol_error;
+  syncer::SyncProtocolError sync_protocol_error;
   sync_protocol_error.error_type = ConvertSyncProtocolErrorTypePBToLocalType(
       error.error_type());
   sync_protocol_error.error_description = error.error_description();
   sync_protocol_error.url = error.url();
   sync_protocol_error.action = ConvertClientActionPBToLocalClientAction(
       error.action());
 
   if (error.error_data_type_ids_size() > 0) {
     // THROTTLED is currently the only error code that uses |error_data_types|.
     DCHECK_EQ(error.error_type(), sync_pb::SyncEnums::THROTTLED);
     for (int i = 0; i < error.error_data_type_ids_size(); ++i) {
       sync_protocol_error.error_data_types.Put(
           syncable::GetModelTypeFromSpecificsFieldNumber(
               error.error_data_type_ids(i)));
     }
   }
 
   return sync_protocol_error;
 }
 
 // TODO(lipalani) : Rename these function names as per the CR for issue 7740067.
-csync::SyncProtocolError ConvertLegacyErrorCodeToNewError(
+syncer::SyncProtocolError ConvertLegacyErrorCodeToNewError(
     const sync_pb::SyncEnums::ErrorType& error_type) {
-  csync::SyncProtocolError error;
+  syncer::SyncProtocolError error;
   error.error_type = ConvertSyncProtocolErrorTypePBToLocalType(error_type);
   if (error_type == sync_pb::SyncEnums::CLEAR_PENDING ||
       error_type == sync_pb::SyncEnums::NOT_MY_BIRTHDAY) {
-      error.action = csync::DISABLE_SYNC_ON_CLIENT;
+      error.action = syncer::DISABLE_SYNC_ON_CLIENT;
   }  // There is no other action we can compute for legacy server.
   return error;
 }
 
 }  // namespace
 
 // static
 SyncerError SyncerProtoUtil::PostClientToServerMessage(
     const ClientToServerMessage& msg,
     ClientToServerResponse* response,
     SyncSession* session) {
 
   CHECK(response);
   DCHECK(!msg.get_updates().has_from_timestamp());  // Deprecated.
   DCHECK(!msg.get_updates().has_requested_types());  // Deprecated.
   DCHECK(msg.has_store_birthday() || IsVeryFirstGetUpdates(msg))
       << "Must call AddRequestBirthday to set birthday.";
 
   syncable::Directory* dir = session->context()->directory();
 
   LogClientToServerMessage(msg);
   session->context()->traffic_recorder()->RecordClientToServerMessage(msg);
   if (!PostAndProcessHeaders(session->context()->connection_manager(), session,
                              msg, response)) {
     // There was an error establishing communication with the server.
     // We can not proceed beyond this point.
-    const csync::HttpResponse::ServerConnectionCode server_status =
+    const syncer::HttpResponse::ServerConnectionCode server_status =
         session->context()->connection_manager()->server_status();
 
-    DCHECK_NE(server_status, csync::HttpResponse::NONE);
-    DCHECK_NE(server_status, csync::HttpResponse::SERVER_CONNECTION_OK);
+    DCHECK_NE(server_status, syncer::HttpResponse::NONE);
+    DCHECK_NE(server_status, syncer::HttpResponse::SERVER_CONNECTION_OK);
 
     return ServerConnectionErrorAsSyncerError(server_status);
   }
 
   LogClientToServerResponse(*response);
   session->context()->traffic_recorder()->RecordClientToServerResponse(
       *response);
 
-  csync::SyncProtocolError sync_protocol_error;
+  syncer::SyncProtocolError sync_protocol_error;
 
   // Birthday mismatch overrides any error that is sent by the server.
   if (!VerifyResponseBirthday(dir, response)) {
-    sync_protocol_error.error_type = csync::NOT_MY_BIRTHDAY;
+    sync_protocol_error.error_type = syncer::NOT_MY_BIRTHDAY;
      sync_protocol_error.action =
-         csync::DISABLE_SYNC_ON_CLIENT;
+         syncer::DISABLE_SYNC_ON_CLIENT;
   } else if (response->has_error()) {
     // This is a new server. Just get the error from the protocol.
     sync_protocol_error = ConvertErrorPBToLocalType(response->error());
   } else {
     // Legacy server implementation. Compute the error based on |error_code|.
     sync_protocol_error = ConvertLegacyErrorCodeToNewError(
         response->error_code());
   }
 
   // Now set the error into the status so the layers above us could read it.
   sessions::StatusController* status = session->mutable_status_controller();
   status->set_sync_protocol_error(sync_protocol_error);
 
   // Inform the delegate of the error we got.
   session->delegate()->OnSyncProtocolError(session->TakeSnapshot());
 
   // Now do any special handling for the error type and decide on the return
   // value.
   switch (sync_protocol_error.error_type) {
-    case csync::UNKNOWN_ERROR:
+    case syncer::UNKNOWN_ERROR:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
       return SERVER_RETURN_UNKNOWN_ERROR;
-    case csync::SYNC_SUCCESS:
+    case syncer::SYNC_SUCCESS:
       LogResponseProfilingData(*response);
       return SYNCER_OK;
-    case csync::THROTTLED:
+    case syncer::THROTTLED:
       LOG(WARNING) << "Client silenced by server.";
       HandleThrottleError(sync_protocol_error,
                           base::TimeTicks::Now() + GetThrottleDelay(*response),
                           session->context()->throttled_data_type_tracker(),
                           session->delegate());
       return SERVER_RETURN_THROTTLED;
-    case csync::TRANSIENT_ERROR:
+    case syncer::TRANSIENT_ERROR:
       return SERVER_RETURN_TRANSIENT_ERROR;
-    case csync::MIGRATION_DONE:
+    case syncer::MIGRATION_DONE:
       HandleMigrationDoneResponse(response, session);
       return SERVER_RETURN_MIGRATION_DONE;
-    case csync::CLEAR_PENDING:
+    case syncer::CLEAR_PENDING:
       return SERVER_RETURN_CLEAR_PENDING;
-    case csync::NOT_MY_BIRTHDAY:
+    case syncer::NOT_MY_BIRTHDAY:
       return SERVER_RETURN_NOT_MY_BIRTHDAY;
     default:
       NOTREACHED();
       return UNSET;
   }
 }
 
 // static
 bool SyncerProtoUtil::Compare(const syncable::Entry& local_entry,
                               const SyncEntity& server_entry) {
@@ skipping 116 matching lines @@
 
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     const sync_pb::ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates())
     output.append(GetUpdatesResponseString(response.get_updates()));
   return output;
 }
 
-}  // namespace csync
+}  // namespace syncer