Remove syncproto.h

sync/engine/syncer_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_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
-#include "sync/engine/syncproto.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_util.h"
 #include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_changes_version.h"
+#include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/time.h"
 
 namespace syncer {
 
 using syncable::BASE_VERSION;
 using syncable::CHANGES_VERSION;
 using syncable::CREATE_NEW_UPDATE_ITEM;
@@ skipping 25 matching lines @@
 using syncable::SERVER_SPECIFICS;
 using syncable::SERVER_VERSION;
 using syncable::UNIQUE_CLIENT_TAG;
 using syncable::UNIQUE_SERVER_TAG;
 using syncable::SPECIFICS;
 using syncable::SYNCER;
 using syncable::WriteTransaction;
 
 syncable::Id FindLocalIdToUpdate(
     syncable::BaseTransaction* trans,
-    const SyncEntity& update) {
+    const sync_pb::SyncEntity& update) {
   // Expected entry points of this function:
   // SyncEntity has NOT been applied to SERVER fields.
   // SyncEntity has NOT been applied to LOCAL fields.
   // DB has not yet been modified, no entries created for this update.
 
   const std::string& client_id = trans->directory()->cache_guid();
+  syncable::Id update_id = SyncableIdFromProto(update.id_string());
 
   if (update.has_client_defined_unique_tag() &&
       !update.client_defined_unique_tag().empty()) {
     // When a server sends down a client tag, the following cases can occur:
     // 1) Client has entry for tag already, ID is server style, matches
     // 2) Client has entry for tag already, ID is server, doesn't match.
     // 3) Client has entry for tag already, ID is local, (never matches)
     // 4) Client has no entry for tag
 
     // Case 1, we don't have to do anything since the update will
     // work just fine. Update will end up in the proper entry, via ID lookup.
     // Case 2 - Happens very rarely due to lax enforcement of client tags
     // on the server, if two clients commit the same tag at the same time.
     // When this happens, we pick the lexically-least ID and ignore all other
     // items.
     // Case 3 - We need to replace the local ID with the server ID so that
     // this update gets targeted at the correct local entry; we expect conflict
     // resolution to occur.
     // Case 4 - Perfect. Same as case 1.
 
     syncable::Entry local_entry(trans, syncable::GET_BY_CLIENT_TAG,
                                 update.client_defined_unique_tag());
 
     // The SyncAPI equivalent of this function will return !good if IS_DEL.
     // The syncable version will return good even if IS_DEL.
     // TODO(chron): Unit test the case with IS_DEL and make sure.
     if (local_entry.good()) {
       if (local_entry.Get(ID).ServerKnows()) {
-        if (local_entry.Get(ID) != update.id()) {
+        if (local_entry.Get(ID) != update_id) {
           // Case 2.
           LOG(WARNING) << "Duplicated client tag.";
-          if (local_entry.Get(ID) < update.id()) {
+          if (local_entry.Get(ID) < update_id) {
             // Signal an error; drop this update on the floor.  Note that
             // we don't server delete the item, because we don't allow it to
             // exist locally at all.  So the item will remain orphaned on
             // the server, and we won't pay attention to it.
             return syncable::GetNullId();
           }
         }
         // Target this change to the existing local entry; later,
-        // we'll change the ID of the local entry to update.id()
+        // we'll change the ID of the local entry to update_id
         // if needed.
         return local_entry.Get(ID);
       } else {
         // Case 3: We have a local entry with the same client tag.
         // We should change the ID of the local entry to the server entry.
         // This will result in an server ID with base version == 0, but that's
         // a legal state for an item with a client tag.  By changing the ID,
         // update will now be applied to local_entry.
         DCHECK(0 == local_entry.Get(BASE_VERSION) ||
                CHANGES_VERSION == local_entry.Get(BASE_VERSION));
@@ skipping 33 matching lines @@
       DCHECK_LE(old_version, 0);
       DCHECK_GT(new_version, 0);
       // Otherwise setting the base version could cause a consistency failure.
       // An entry should never be version 0 and SYNCED.
       DCHECK(local_entry.Get(IS_UNSYNCED));
 
       // Just a quick sanity check.
       DCHECK(!local_entry.Get(ID).ServerKnows());
 
       DVLOG(1) << "Reuniting lost commit response IDs. server id: "
-               << update.id() << " local id: " << local_entry.Get(ID)
+               << update_id << " local id: " << local_entry.Get(ID)
                << " new version: " << new_version;
 
       return local_entry.Get(ID);
     }
   }
   // Fallback: target an entry having the server ID, creating one if needed.
-  return update.id();
+  return update_id;
 }
 
 UpdateAttemptResponse AttemptToUpdateEntry(
     syncable::WriteTransaction* const trans,
     syncable::MutableEntry* const entry,
     ConflictResolver* resolver,
     Cryptographer* cryptographer) {
   CHECK(entry->good());
   if (!entry->Get(IS_UNAPPLIED_UPDATE))
     return SUCCESS;  // No work to do.
@@ skipping 141 matching lines @@
   if (!favicon_bytes.empty())
     bookmark->set_favicon(favicon_bytes);
   local_entry->Put(SERVER_SPECIFICS, pb);
 }
 
 }  // namespace
 
 // Pass in name and checksum because of UTF8 conversion.
 void UpdateServerFieldsFromUpdate(
     MutableEntry* target,
-    const SyncEntity& update,
+    const sync_pb::SyncEntity& update,
     const std::string& name) {
   if (update.deleted()) {
     if (target->Get(SERVER_IS_DEL)) {
       // If we already think the item is server-deleted, we're done.
       // Skipping these cases prevents our committed deletions from coming
       // back and overriding subsequent undeletions.  For non-deleted items,
       // the version number check has a similar effect.
       return;
     }
     // The server returns very lightweight replies for deletions, so we don't
     // clobber a bunch of fields on delete.
     target->Put(SERVER_IS_DEL, true);
     if (!target->Get(UNIQUE_CLIENT_TAG).empty()) {
       // Items identified by the client unique tag are undeletable; when
       // they're deleted, they go back to version 0.
       target->Put(SERVER_VERSION, 0);
     } else {
       // Otherwise, fake a server version by bumping the local number.
       target->Put(SERVER_VERSION,
           std::max(target->Get(SERVER_VERSION),
                    target->Get(BASE_VERSION)) + 1);
     }
     target->Put(IS_UNAPPLIED_UPDATE, true);
     return;
   }
 
-  DCHECK(target->Get(ID) == update.id())
+  DCHECK(target->Get(ID) == SyncableIdFromProto(update.id_string()))

[akalin, 2012/07/11 01:42:22]

DCHECK_EQ?

       << "ID Changing not supported here";
-  target->Put(SERVER_PARENT_ID, update.parent_id());
+  target->Put(SERVER_PARENT_ID, SyncableIdFromProto(update.parent_id_string()));
   target->Put(SERVER_NON_UNIQUE_NAME, name);
   target->Put(SERVER_VERSION, update.version());
   target->Put(SERVER_CTIME, ProtoTimeToTime(update.ctime()));
   target->Put(SERVER_MTIME, ProtoTimeToTime(update.mtime()));
-  target->Put(SERVER_IS_DIR, update.IsFolder());
+  target->Put(SERVER_IS_DIR, IsFolder(update));
   if (update.has_server_defined_unique_tag()) {
     const std::string& tag = update.server_defined_unique_tag();
     target->Put(UNIQUE_SERVER_TAG, tag);
   }
   if (update.has_client_defined_unique_tag()) {
     const std::string& tag = update.client_defined_unique_tag();
     target->Put(UNIQUE_CLIENT_TAG, tag);
   }
   // Store the datatype-specific part as a protobuf.
   if (update.has_specifics()) {
-    DCHECK(update.GetModelType() != syncer::UNSPECIFIED)
+    DCHECK(GetModelType(update) != UNSPECIFIED)

[akalin, 2012/07/11 01:42:22]

DCHECK_NE?

         << "Storing unrecognized datatype in sync database.";
     target->Put(SERVER_SPECIFICS, update.specifics());
   } else if (update.has_bookmarkdata()) {
     // Legacy protocol response for bookmark data.
-    const SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
+    const sync_pb::SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
     UpdateBookmarkSpecifics(update.server_defined_unique_tag(),
                             bookmark.bookmark_url(),
                             bookmark.bookmark_favicon(),
                             target);
   }
   if (update.has_position_in_parent())
     target->Put(SERVER_POSITION_IN_PARENT, update.position_in_parent());
 
   target->Put(SERVER_IS_DEL, update.deleted());
   // We only mark the entry as unapplied if its version is greater than the
@@ skipping 160 matching lines @@
       }
       Entry parent(&trans, GET_BY_ID, id);
       if (!parent.good() || !parent.Get(IS_DEL))
         break;
       id = parent.Get(PARENT_ID);
     }
   }
 }
 
 VerifyResult VerifyNewEntry(
-    const SyncEntity& update,
+    const sync_pb::SyncEntity& update,
     syncable::Entry* target,
     const bool deleted) {
   if (target->good()) {
     // Not a new update.
     return VERIFY_UNDECIDED;
   }
   if (deleted) {
     // Deletion of an item we've never seen can be ignored.
     return VERIFY_SKIP;
   }
 
   return VERIFY_SUCCESS;
 }
 
 // Assumes we have an existing entry; check here for updates that break
 // consistency rules.
 VerifyResult VerifyUpdateConsistency(
     syncable::WriteTransaction* trans,
-    const SyncEntity& update,
+    const sync_pb::SyncEntity& update,
     syncable::MutableEntry* target,
     const bool deleted,
     const bool is_directory,
     syncer::ModelType model_type) {
 
   CHECK(target->good());
+  syncable::Id update_id = SyncableIdFromProto(update.id_string());
 
   // If the update is a delete, we don't really need to worry at this stage.
   if (deleted)
     return VERIFY_SUCCESS;
 
   if (model_type == syncer::UNSPECIFIED) {
     // This update is to an item of a datatype we don't recognize. The server
     // shouldn't have sent it to us.  Throw it on the ground.
     return VERIFY_SKIP;
   }
 
   if (target->Get(SERVER_VERSION) > 0) {
     // Then we've had an update for this entry before.
     if (is_directory != target->Get(SERVER_IS_DIR) ||
         model_type != target->GetServerModelType()) {
       if (target->Get(IS_DEL)) {  // If we've deleted the item, we don't care.
         return VERIFY_SKIP;
       } else {
         LOG(ERROR) << "Server update doesn't agree with previous updates. ";
         LOG(ERROR) << " Entry: " << *target;
         LOG(ERROR) << " Update: "
                    << SyncerProtoUtil::SyncEntityDebugString(update);
         return VERIFY_FAIL;
       }
     }
 
-    if (!deleted && (target->Get(ID) == update.id()) &&
+    if (!deleted && (target->Get(ID) == update_id) &&
         (target->Get(SERVER_IS_DEL) ||
          (!target->Get(IS_UNSYNCED) && target->Get(IS_DEL) &&
           target->Get(BASE_VERSION) > 0))) {
       // An undelete. The latter case in the above condition is for
       // when the server does not give us an update following the
       // commit of a delete, before undeleting.
       // Undeletion is common for items that reuse the client-unique tag.
       VerifyResult result = VerifyUndelete(trans, update, target);
       if (VERIFY_UNDECIDED != result)
         return result;
     }
   }
   if (target->Get(BASE_VERSION) > 0) {
     // We've committed this update in the past.
     if (is_directory != target->Get(IS_DIR) ||
         model_type != target->GetModelType()) {
       LOG(ERROR) << "Server update doesn't agree with committed item. ";
       LOG(ERROR) << " Entry: " << *target;
       LOG(ERROR) << " Update: "
                  << SyncerProtoUtil::SyncEntityDebugString(update);
       return VERIFY_FAIL;
     }
-    if (target->Get(ID) == update.id()) {
+    if (target->Get(ID) == update_id) {
       if (target->Get(SERVER_VERSION) > update.version()) {
         LOG(WARNING) << "We've already seen a more recent version.";
         LOG(WARNING) << " Entry: " << *target;
         LOG(WARNING) << " Update: "
                      << SyncerProtoUtil::SyncEntityDebugString(update);
         return VERIFY_SKIP;
       }
     }
   }
   return VERIFY_SUCCESS;
 }
 
 // Assumes we have an existing entry; verify an update that seems to be
 // expressing an 'undelete'
 VerifyResult VerifyUndelete(syncable::WriteTransaction* trans,
-                            const SyncEntity& update,
+                            const sync_pb::SyncEntity& update,
                             syncable::MutableEntry* target) {
   // TODO(nick): We hit this path for items deleted items that the server
   // tells us to re-create; only deleted items with positive base versions
   // will hit this path.  However, it's not clear how such an undeletion
   // would actually succeed on the server; in the protocol, a base
   // version of 0 is required to undelete an object.  This codepath
   // should be deprecated in favor of client-tag style undeletion
   // (where items go to version 0 when they're deleted), or else
   // removed entirely (if this type of undeletion is indeed impossible).
   CHECK(target->good());
@@ skipping 13 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace syncer