Remove syncproto.h

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/base/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/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;
 using syncable::CTIME;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
@@ skipping 64 matching lines @@
     default:
       NOTREACHED();
       return UNSET;
   }
 }
 
 }  // namespace
 
 // static
 void SyncerProtoUtil::HandleMigrationDoneResponse(
-  const sync_pb::ClientToServerResponse* response,
+  const ClientToServerResponse* response,
   sessions::SyncSession* session) {
   LOG_IF(ERROR, 0 >= response->migrated_data_type_id_size())
       << "MIGRATION_DONE but no types specified.";
   syncer::ModelTypeSet to_migrate;
   for (int i = 0; i < response->migrated_data_type_id_size(); i++) {
     to_migrate.Put(syncer::GetModelTypeFromSpecificsFieldNumber(
         response->migrated_data_type_id(i)));
   }
   // TODO(akalin): This should be a set union.
   session->mutable_status_controller()->
@@ skipping 32 matching lines @@
 }
 
 // static
 void SyncerProtoUtil::AddRequestBirthday(syncable::Directory* dir,
                                          ClientToServerMessage* msg) {
   if (!dir->store_birthday().empty())
     msg->set_store_birthday(dir->store_birthday());
 }
 
 // static
+void SyncerProtoUtil::SetProtocolVersion(ClientToServerMessage* msg) {
+  const int current_version =
+      ClientToServerMessage::default_instance().protocol_version();
+  msg->set_protocol_version(current_version);
+}
+
+// static
 bool SyncerProtoUtil::PostAndProcessHeaders(ServerConnectionManager* scm,
                                             sessions::SyncSession* session,
                                             const ClientToServerMessage& msg,
                                             ClientToServerResponse* response) {
   ServerConnectionManager::PostBufferParams params;
+  DCHECK(msg.has_protocol_version());
+  DCHECK_EQ(msg.protocol_version(),
+            ClientToServerMessage::default_instance().protocol_version());
   msg.SerializeToString(&params.buffer_in);
 
   ScopedServerStatusWatcher server_status_watcher(scm, &params.response);
   // Fills in params.buffer_out and params.response.
   if (!scm->PostBufferWithCachedAuth(&params, &server_status_watcher)) {
     LOG(WARNING) << "Error posting from syncer:" << params.response;
     return false;
   }
 
   std::string new_token = params.response.update_client_auth_header;
@@ skipping 14 matching lines @@
         return false;
       default:
         return true;
     }
   }
 
   return false;
 }
 
 base::TimeDelta SyncerProtoUtil::GetThrottleDelay(
-    const sync_pb::ClientToServerResponse& response) {
+    const ClientToServerResponse& response) {
   base::TimeDelta throttle_delay =
       base::TimeDelta::FromSeconds(kSyncDelayAfterThrottled);
   if (response.has_client_command()) {
     const sync_pb::ClientCommand& command = response.client_command();
     if (command.has_throttle_delay_seconds()) {
       throttle_delay =
           base::TimeDelta::FromSeconds(command.throttle_delay_seconds());
     }
   }
   return throttle_delay;
@@ skipping 69 matching lines @@
       return syncer::DISABLE_SYNC_ON_CLIENT;
     case sync_pb::SyncEnums::UNKNOWN_ACTION:
       return syncer::UNKNOWN_ACTION;
     default:
       NOTREACHED();
       return syncer::UNKNOWN_ACTION;
   }
 }
 
 syncer::SyncProtocolError ConvertErrorPBToLocalType(
-    const sync_pb::ClientToServerResponse::Error& error) {
+    const ClientToServerResponse::Error& 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|.
@@ skipping 105 matching lines @@
     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) {
+                              const sync_pb::SyncEntity& server_entry) {
   const std::string name = NameFromSyncEntity(server_entry);
 
-  CHECK(local_entry.Get(ID) == server_entry.id()) <<
-      " SyncerProtoUtil::Compare precondition not met.";
-  CHECK(server_entry.version() == local_entry.Get(BASE_VERSION)) <<
-      " SyncerProtoUtil::Compare precondition not met.";
-  CHECK(!local_entry.Get(IS_UNSYNCED)) <<
-      " SyncerProtoUtil::Compare precondition not met.";
+  CHECK_EQ(local_entry.Get(ID), SyncableIdFromProto(server_entry.id_string()));
+  CHECK_EQ(server_entry.version(), local_entry.Get(BASE_VERSION));
+  CHECK(!local_entry.Get(IS_UNSYNCED));
 
   if (local_entry.Get(IS_DEL) && server_entry.deleted())
     return true;
   if (local_entry.Get(CTIME) != ProtoTimeToTime(server_entry.ctime())) {
     LOG(WARNING) << "ctime mismatch";
     return false;
   }
 
   // These checks are somewhat prolix, but they're easier to debug than a big
   // boolean statement.
   string client_name = local_entry.Get(syncable::NON_UNIQUE_NAME);
   if (client_name != name) {
     LOG(WARNING) << "Client name mismatch";
     return false;
   }
-  if (local_entry.Get(PARENT_ID) != server_entry.parent_id()) {
+  if (local_entry.Get(PARENT_ID) !=
+      SyncableIdFromProto(server_entry.parent_id_string())) {
     LOG(WARNING) << "Parent ID mismatch";
     return false;
   }
-  if (local_entry.Get(IS_DIR) != server_entry.IsFolder()) {
+  if (local_entry.Get(IS_DIR) != IsFolder(server_entry)) {
     LOG(WARNING) << "Dir field mismatch";
     return false;
   }
   if (local_entry.Get(IS_DEL) != server_entry.deleted()) {
     LOG(WARNING) << "Deletion mismatch";
     return false;
   }
   if (!local_entry.Get(IS_DIR) &&
       (local_entry.Get(MTIME) != ProtoTimeToTime(server_entry.mtime()))) {
     LOG(WARNING) << "mtime mismatch";
@@ skipping 28 matching lines @@
 // 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 CommitResponse_EntryResponse& entry) {
+    const sync_pb::CommitResponse_EntryResponse& entry) {
   if (entry.has_non_unique_name())
     return entry.non_unique_name();
   return entry.name();
 }
 
 std::string SyncerProtoUtil::SyncEntityDebugString(
     const sync_pb::SyncEntity& entry) {
   const std::string& mtime_str =
       GetTimeDebugString(ProtoTimeToTime(entry.mtime()));
   const std::string& ctime_str =
@@ skipping 21 matching lines @@
   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 sync_pb::ClientToServerResponse& response) {
+    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