Remove syncproto.h

sync/engine/build_commit_command.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/build_commit_command.h"
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
+#include "sync/protocol/sync.pb.h"
 #include "sync/sessions/ordered_commit_set.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_changes_version.h"
+#include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/time.h"
 
 using std::set;
 using std::string;
 using std::vector;
 
 namespace syncer {
 
 using sessions::SyncSession;
@@ skipping 17 matching lines @@
   return std::numeric_limits<int64>::max();
 }
 
 // static
 int64 BuildCommitCommand::GetGap() {
   return 1LL << 20;
 }
 
 BuildCommitCommand::BuildCommitCommand(
     const sessions::OrderedCommitSet& batch_commit_set,
-    ClientToServerMessage* commit_message)
+    sync_pb::ClientToServerMessage* commit_message)
   : batch_commit_set_(batch_commit_set), commit_message_(commit_message) {
 }
 
 BuildCommitCommand::~BuildCommitCommand() {}
 
 void BuildCommitCommand::AddExtensionsActivityToMessage(
-    SyncSession* session, CommitMessage* message) {
+    SyncSession* session, sync_pb::CommitMessage* message) {
   // We only send ExtensionsActivity to the server if bookmarks are being
   // committed.
   ExtensionsActivityMonitor* monitor = session->context()->extensions_monitor();
   if (batch_commit_set_.HasBookmarkCommitId()) {
     // This isn't perfect, since the set of extensions activity may not
     // correlate exactly with the items being committed.  That's OK as
     // long as we're looking for a rough estimate of extensions activity,
     // not an precise mapping of which commits were triggered by which
     // extension.
     //
@@ skipping 10 matching lines @@
       sync_pb::ChromiumExtensionsActivity* activity_message =
           message->add_extensions_activity();
       activity_message->set_extension_id(it->second.extension_id);
       activity_message->set_bookmark_writes_since_last_commit(
           it->second.bookmark_write_count);
     }
   }
 }
 
 namespace {
-void SetEntrySpecifics(MutableEntry* meta_entry, SyncEntity* sync_entry) {
+void SetEntrySpecifics(MutableEntry* meta_entry,
+                       sync_pb::SyncEntity* sync_entry) {
   // Add the new style extension and the folder bit.
   sync_entry->mutable_specifics()->CopyFrom(meta_entry->Get(SPECIFICS));
   sync_entry->set_folder(meta_entry->Get(syncable::IS_DIR));
 
-  DCHECK(meta_entry->GetModelType() == sync_entry->GetModelType());
+  DCHECK_EQ(meta_entry->GetModelType(), GetModelType(*sync_entry));
 }
 }  // namespace
 
 SyncerError BuildCommitCommand::ExecuteImpl(SyncSession* session) {
   commit_message_->set_share(session->context()->account_name());
-  commit_message_->set_message_contents(ClientToServerMessage::COMMIT);
+  commit_message_->set_message_contents(sync_pb::ClientToServerMessage::COMMIT);
 
-  CommitMessage* commit_message = commit_message_->mutable_commit();
+  sync_pb::CommitMessage* commit_message = commit_message_->mutable_commit();
   commit_message->set_cache_guid(
       session->write_transaction()->directory()->cache_guid());
   AddExtensionsActivityToMessage(session, commit_message);
+  SyncerProtoUtil::SetProtocolVersion(commit_message_);
   SyncerProtoUtil::AddRequestBirthday(
       session->write_transaction()->directory(), commit_message_);
 
   // Cache previously computed position values.  Because |commit_ids|
   // is already in sibling order, we should always hit this map after
   // the first sibling in a consecutive run of commit items.  The
   // entries in this map are (low, high) values describing the
   // space of positions that are immediate successors of the item
   // whose ID is the map's key.
   std::map<Id, std::pair<int64, int64> > position_map;
 
   for (size_t i = 0; i < batch_commit_set_.Size(); i++) {
     Id id = batch_commit_set_.GetCommitIdAt(i);
-    SyncEntity* sync_entry =
-        static_cast<SyncEntity*>(commit_message->add_entries());
-    sync_entry->set_id(id);
+    sync_pb::SyncEntity* sync_entry = commit_message->add_entries();
+    sync_entry->set_id_string(SyncableIdToProto(id));
     MutableEntry meta_entry(session->write_transaction(),
                             syncable::GET_BY_ID, id);
     CHECK(meta_entry.good());
 
     DCHECK(0 != session->routing_info().count(meta_entry.GetModelType()))
         << "Committing change to datatype that's not actively enabled.";
 
     string name = meta_entry.Get(syncable::NON_UNIQUE_NAME);
     CHECK(!name.empty());  // Make sure this isn't an update.
     TruncateUTF8ToByteSize(name, 255, &name);
@@ skipping 12 matching lines @@
 
     // Deleted items with server-unknown parent ids can be a problem so we set
     // the parent to 0. (TODO(sync): Still true in protocol?).
     Id new_parent_id;
     if (meta_entry.Get(syncable::IS_DEL) &&
         !meta_entry.Get(syncable::PARENT_ID).ServerKnows()) {
       new_parent_id = session->write_transaction()->root_id();
     } else {
       new_parent_id = meta_entry.Get(syncable::PARENT_ID);
     }
-    sync_entry->set_parent_id(new_parent_id);
+    sync_entry->set_parent_id_string(
+        SyncableIdToProto(new_parent_id));

[akalin, 2012/07/11 23:10:40]

doesn't fit on prev line?

[rlarocque, 2012/07/11 23:45:36]

Fixed.

 
     // If our parent has changed, send up the old one so the server
     // can correctly deal with multiple parents.
     // TODO(nick): With the server keeping track of the primary sync parent,
     // it should not be necessary to provide the old_parent_id: the version
     // number should suffice.
     if (new_parent_id != meta_entry.Get(syncable::SERVER_PARENT_ID) &&
         0 != meta_entry.Get(syncable::BASE_VERSION) &&
         syncable::CHANGES_VERSION != meta_entry.Get(syncable::BASE_VERSION)) {
-      sync_entry->set_old_parent_id(meta_entry.Get(syncable::SERVER_PARENT_ID));
+      sync_entry->set_old_parent_id(
+          SyncableIdToProto(meta_entry.Get(syncable::SERVER_PARENT_ID)));
     }
 
     int64 version = meta_entry.Get(syncable::BASE_VERSION);
     if (syncable::CHANGES_VERSION == version || 0 == version) {
       // Undeletions are only supported for items that have a client tag.
       DCHECK(!id.ServerKnows() ||
              !meta_entry.Get(syncable::UNIQUE_CLIENT_TAG).empty())
           << meta_entry;
 
       // Version 0 means to create or undelete an object.
@@ skipping 74 matching lines @@
   if (delta <= static_cast<uint64>(GetGap()*2))
     return lo + (static_cast<int64>(delta) + 7) / 8;  // Interpolate.
   else if (lo == GetFirstPosition())
     return hi - GetGap();  // Extend range just before successor.
   else
     return lo + GetGap();  // Use or extend range just after predecessor.
 }
 
 
 }  // namespace syncer