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

components/sync/engine_impl/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 "components/sync/engine_impl/syncer_proto_util.h"
 
 #include <map>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/base/time.h"
+#include "components/sync/engine_impl/net/server_connection_manager.h"
+#include "components/sync/engine_impl/syncer.h"
+#include "components/sync/engine_impl/syncer_types.h"
+#include "components/sync/engine_impl/traffic_logger.h"
+#include "components/sync/protocol/sync_enums.pb.h"
+#include "components/sync/protocol/sync_protocol_error.h"
+#include "components/sync/sessions_impl/sync_session.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/syncable-inl.h"
+#include "components/sync/syncable/syncable_proto_util.h"
 #include "google_apis/google_api_keys.h"
-#include "sync/engine/net/server_connection_manager.h"
-#include "sync/engine/syncer.h"
-#include "sync/engine/syncer_types.h"
-#include "sync/engine/traffic_logger.h"
-#include "sync/internal_api/public/base/model_type.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/syncable/syncable_proto_util.h"
-#include "sync/util/time.h"
 
 using std::string;
 using std::stringstream;
 using sync_pb::ClientToServerMessage;
 using sync_pb::ClientToServerResponse;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using syncable::BASE_VERSION;
@@ skipping 184 matching lines @@
   sync_protocol_error.error_description = error.error_description();
   sync_protocol_error.url = error.url();
   sync_protocol_error.action = PBActionToClientAction(error.action());
 
   if (error.error_data_type_ids_size() > 0) {
     // THROTTLED and PARTIAL_FAILURE are currently the only error codes
     // that uses |error_data_types|.
     // In both cases, |error_data_types| are throttled.
     for (int i = 0; i < error.error_data_type_ids_size(); ++i) {
       int field_number = error.error_data_type_ids(i);
-      ModelType model_type =
-          GetModelTypeFromSpecificsFieldNumber(field_number);
+      ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
       if (!IsRealDataType(model_type)) {
         DLOG(WARNING) << "Unknown field number " << field_number;
         continue;
       }
       sync_protocol_error.error_data_types.Put(model_type);
     }
   }
 
   return sync_protocol_error;
 }
 
 // static
 bool SyncerProtoUtil::VerifyResponseBirthday(
     const ClientToServerResponse& response,
     syncable::Directory* dir) {
-
   std::string local_birthday = dir->store_birthday();
 
   if (local_birthday.empty()) {
     if (!response.has_store_birthday()) {
       LOG(WARNING) << "Expected a birthday on first sync.";
       return false;
     }
 
     DVLOG(1) << "New store birthday: " << response.store_birthday();
     dir->set_store_birthday(response.store_birthday());
@@ skipping 105 matching lines @@
   return throttle_delay;
 }
 
 // static
 SyncerError SyncerProtoUtil::PostClientToServerMessage(
     ClientToServerMessage* msg,
     ClientToServerResponse* response,
     SyncSession* session,
     ModelTypeSet* partial_failure_data_types) {
   CHECK(response);
-  DCHECK(!msg->get_updates().has_from_timestamp());  // Deprecated.
+  DCHECK(!msg->get_updates().has_from_timestamp());   // Deprecated.
   DCHECK(!msg->get_updates().has_requested_types());  // Deprecated.
 
   // Add must-have fields.
   SetProtocolVersion(msg);
   AddRequestBirthday(session->context()->directory(), msg);
   DCHECK(msg->has_store_birthday() || !IsBirthdayRequired(*msg));
   AddBagOfChips(session->context()->directory(), msg);
   msg->set_api_key(google_apis::GetAPIKey());
   msg->mutable_client_status()->CopyFrom(session->context()->client_status());
   msg->set_invalidator_client_id(session->context()->invalidator_client_id());
@@ skipping 86 matching lines @@
     case SYNC_SUCCESS:
       LogResponseProfilingData(*response);
       return SYNCER_OK;
     case THROTTLED:
       if (sync_protocol_error.error_data_types.Empty()) {
         DLOG(WARNING) << "Client fully throttled by syncer.";
         session->delegate()->OnThrottled(GetThrottleDelay(*response));
       } else {
         DLOG(WARNING) << "Some types throttled by syncer.";
         session->delegate()->OnTypesThrottled(
-            sync_protocol_error.error_data_types,
-            GetThrottleDelay(*response));
+            sync_protocol_error.error_data_types, GetThrottleDelay(*response));
       }
       return SERVER_RETURN_THROTTLED;
     case TRANSIENT_ERROR:
       return SERVER_RETURN_TRANSIENT_ERROR;
     case MIGRATION_DONE:
       LOG_IF(ERROR, 0 >= response->migrated_data_type_id_size())
           << "MIGRATION_DONE but no types specified.";
       session->delegate()->OnReceivedMigrationRequest(
           GetTypesToMigrate(*response));
       return SERVER_RETURN_MIGRATION_DONE;
@@ skipping 20 matching lines @@
       NOTREACHED();
       return UNSET;
   }
 }
 
 // static
 bool SyncerProtoUtil::ShouldMaintainPosition(
     const sync_pb::SyncEntity& sync_entity) {
   // Maintain positions for bookmarks that are not server-defined top-level
   // folders.
-  return GetModelType(sync_entity) == BOOKMARKS
-      && !(sync_entity.folder() &&
+  return GetModelType(sync_entity) == BOOKMARKS &&
+         !(sync_entity.folder() &&
            !sync_entity.server_defined_unique_tag().empty());
 }
 
 // static
 bool SyncerProtoUtil::ShouldMaintainHierarchy(
     const sync_pb::SyncEntity& sync_entity) {
   // Maintain hierarchy for bookmarks or top-level items.
   return GetModelType(sync_entity) == BOOKMARKS ||
          sync_entity.parent_id_string() == "0";
 }
 
 // static
 const std::string& SyncerProtoUtil::NameFromSyncEntity(
     const sync_pb::SyncEntity& entry) {
   if (entry.has_non_unique_name())
     return entry.non_unique_name();
   return entry.name();
 }
 
 // static
 const std::string& SyncerProtoUtil::NameFromCommitEntryResponse(
     const sync_pb::CommitResponse_EntryResponse& entry) {
   if (entry.has_non_unique_name())
     return entry.non_unique_name();
   return entry.name();
 }
 
 // static
-void SyncerProtoUtil::PersistBagOfChips(syncable::Directory* dir,
+void SyncerProtoUtil::PersistBagOfChips(
+    syncable::Directory* dir,
     const sync_pb::ClientToServerResponse& response) {
   if (!response.has_new_bag_of_chips())
     return;
   std::string bag_of_chips;
   if (response.new_bag_of_chips().SerializeToString(&bag_of_chips))
     dir->set_bag_of_chips(bag_of_chips);
 }
 
 std::string SyncerProtoUtil::SyncEntityDebugString(
     const sync_pb::SyncEntity& entry) {
   const std::string& mtime_str =
       GetTimeDebugString(ProtoTimeToTime(entry.mtime()));
   const std::string& ctime_str =
       GetTimeDebugString(ProtoTimeToTime(entry.ctime()));
   return base::StringPrintf(
       "id: %s, parent_id: %s, "
-      "version: %" PRId64"d, "
-      "mtime: %" PRId64"d (%s), "
-      "ctime: %" PRId64"d (%s), "
-      "name: %s, sync_timestamp: %" PRId64"d, "
+      "version: %" PRId64
+      "d, "
+      "mtime: %" PRId64
+      "d (%s), "
+      "ctime: %" PRId64
+      "d (%s), "
+      "name: %s, sync_timestamp: %" PRId64
+      "d, "
       "%s ",
-      entry.id_string().c_str(),
-      entry.parent_id_string().c_str(),
-      entry.version(),
-      entry.mtime(), mtime_str.c_str(),
-      entry.ctime(), ctime_str.c_str(),
-      entry.name().c_str(), entry.sync_timestamp(),
-      entry.deleted() ? "deleted, ":"");
+      entry.id_string().c_str(), entry.parent_id_string().c_str(),
+      entry.version(), entry.mtime(), mtime_str.c_str(), entry.ctime(),
+      ctime_str.c_str(), entry.name().c_str(), entry.sync_timestamp(),
+      entry.deleted() ? "deleted, " : "");
 }
 
 namespace {
 std::string GetUpdatesResponseString(
     const sync_pb::GetUpdatesResponse& response) {
   std::string output;
   output.append("GetUpdatesResponse:\n");
   for (int i = 0; i < response.entries_size(); i++) {
     output.append(SyncerProtoUtil::SyncEntityDebugString(response.entries(i)));
     output.append("\n");
   }
   return output;
 }
 }  // namespace
 
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     const ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates())
     output.append(GetUpdatesResponseString(response.get_updates()));
   return output;
 }
 
 }  // namespace syncer