Remove syncproto.h

sync/engine/process_updates_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/process_updates_command.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_util.h"
-#include "sync/engine/syncproto.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.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"
 
 using std::vector;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::StatusController;
@@ skipping 37 matching lines @@
     }
   }
 
   StatusController* status = session->mutable_status_controller();
   status->mutable_update_progress()->ClearVerifiedUpdates();
   return SYNCER_OK;
 }
 
 namespace {
 // Returns true if the entry is still ok to process.
-bool ReverifyEntry(syncable::WriteTransaction* trans, const SyncEntity& entry,
+bool ReverifyEntry(syncable::WriteTransaction* trans,
+                   const sync_pb::SyncEntity& entry,
                    syncable::MutableEntry* same_id) {
 
   const bool deleted = entry.has_deleted() && entry.deleted();
-  const bool is_directory = entry.IsFolder();
-  const syncer::ModelType model_type = entry.GetModelType();
+  const bool is_directory = IsFolder(entry);
+  const syncer::ModelType model_type = GetModelType(entry);
 
   return VERIFY_SUCCESS == VerifyUpdateConsistency(trans,
                                                    entry,
                                                    same_id,
                                                    deleted,
                                                    is_directory,
                                                    model_type);
 }
 }  // namespace
 
 // Process a single update. Will avoid touching global state.
 ServerUpdateProcessingResult ProcessUpdatesCommand::ProcessUpdate(
     const sync_pb::SyncEntity& proto_update,
     const Cryptographer* cryptographer,
     syncable::WriteTransaction* const trans) {
 
-  const SyncEntity& update = *static_cast<const SyncEntity*>(&proto_update);
-  syncable::Id server_id = update.id();
+  const sync_pb::SyncEntity& update =
+      *static_cast<const sync_pb::SyncEntity*>(&proto_update);

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

static cast

[rlarocque, 2012/07/11 19:22:16]

Done.

+  syncable::Id server_id = SyncableIdFromProto(update.id_string());
   const std::string name = SyncerProtoUtil::NameFromSyncEntity(update);
 
   // Look to see if there's a local item that should recieve this update,
   // maybe due to a duplicate client tag or a lost commit response.
   syncable::Id local_id = FindLocalIdToUpdate(trans, update);
 
   // FindLocalEntryToUpdate has veto power.
   if (local_id.IsNull()) {
     return SUCCESS_PROCESSED;  // The entry has become irrelevant.
   }
@@ skipping 34 matching lines @@
     // Force application of this update, no matter what.
     target_entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
   }
 
   // If this is a newly received undecryptable update, and the only thing that
   // has changed are the specifics, store the original decryptable specifics,
   // (on which any current or future local changes are based) before we
   // overwrite SERVER_SPECIFICS.
   // MTIME, CTIME, and NON_UNIQUE_NAME are not enforced.
   if (!update.deleted() && !target_entry.Get(syncable::SERVER_IS_DEL) &&
-      (update.parent_id() == target_entry.Get(syncable::SERVER_PARENT_ID)) &&
+      (SyncableIdFromProto(update.parent_id_string()) ==
+          target_entry.Get(syncable::SERVER_PARENT_ID)) &&
       (update.position_in_parent() ==
           target_entry.Get(syncable::SERVER_POSITION_IN_PARENT)) &&
       update.has_specifics() && update.specifics().has_encrypted() &&
       !cryptographer->CanDecrypt(update.specifics().encrypted())) {
     sync_pb::EntitySpecifics prev_specifics =
         target_entry.Get(syncable::SERVER_SPECIFICS);
     // We only store the old specifics if they were decryptable and applied and
     // there is no BASE_SERVER_SPECIFICS already. Else do nothing.
     if (!target_entry.Get(syncable::IS_UNAPPLIED_UPDATE) &&
         !syncer::IsRealDataType(syncer::GetModelTypeFromSpecifics(
@@ skipping 12 matching lines @@
     target_entry.Put(syncable::BASE_SERVER_SPECIFICS,
                      sync_pb::EntitySpecifics());
   }
 
   UpdateServerFieldsFromUpdate(&target_entry, update, name);
 
   return SUCCESS_PROCESSED;
 }
 
 }  // namespace syncer