[Sync] Move //sync to //components/sync.

components/sync/engine_impl/syncer_util.cc

 // Copyright 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 "components/sync/engine_impl/syncer_util.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "sync/engine/conflict_resolver.h"
-#include "sync/engine/syncer_proto_util.h"
-#include "sync/engine/syncer_types.h"
-#include "sync/internal_api/public/base/attachment_id_proto.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/unique_position.h"
-#include "sync/protocol/bookmark_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/model_neutral_mutable_entry.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/syncable_changes_version.h"
-#include "sync/syncable/syncable_model_neutral_write_transaction.h"
-#include "sync/syncable/syncable_proto_util.h"
-#include "sync/syncable/syncable_read_transaction.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/util/cryptographer.h"
-#include "sync/util/time.h"
+#include "components/sync/base/attachment_id_proto.h"
+#include "components/sync/base/cryptographer.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/base/time.h"
+#include "components/sync/base/unique_position.h"
+#include "components/sync/engine_impl/conflict_resolver.h"
+#include "components/sync/engine_impl/syncer_proto_util.h"
+#include "components/sync/engine_impl/syncer_types.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/protocol/password_specifics.pb.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/model_neutral_mutable_entry.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/syncable_changes_version.h"
+#include "components/sync/syncable/syncable_model_neutral_write_transaction.h"
+#include "components/sync/syncable/syncable_proto_util.h"
+#include "components/sync/syncable/syncable_read_transaction.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
 
 namespace syncer {
 
 using syncable::CHANGES_VERSION;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::GET_BY_HANDLE;
 using syncable::GET_BY_ID;
 using syncable::ID;
 using syncable::Id;
 
-syncable::Id FindLocalIdToUpdate(
-    syncable::BaseTransaction* trans,
-    const sync_pb::SyncEntity& update) {
+syncable::Id FindLocalIdToUpdate(syncable::BaseTransaction* trans,
+                                 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();
   const syncable::Id& update_id = SyncableIdFromProto(update.id_string());
 
   if (update.has_client_defined_unique_tag() &&
       !update.client_defined_unique_tag().empty()) {
@@ skipping 42 matching lines @@
         // 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.GetBaseVersion() ||
                CHANGES_VERSION == local_entry.GetBaseVersion());
         return local_entry.GetId();
       }
     }
   } else if (update.has_originator_cache_guid() &&
-      update.originator_cache_guid() == client_id) {
+             update.originator_cache_guid() == client_id) {
     // If a commit succeeds, but the response does not come back fast enough
     // then the syncer might assume that it was never committed.
     // The server will track the client that sent up the original commit and
     // return this in a get updates response. When this matches a local
     // uncommitted item, we must mutate our local item and version to pick up
     // the committed version of the same item whose commit response was lost.
     // There is however still a race condition if the server has not
     // completed the commit by the time the syncer tries to get updates
     // again. To mitigate this, we need to have the server time out in
     // a reasonable span, our commit batches have to be small enough
@@ skipping 17 matching lines @@
       int64_t new_version = update.version();
       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.GetIsUnsynced());
 
       // Just a quick sanity check.
       DCHECK(!local_entry.GetId().ServerKnows());
 
-      DVLOG(1) << "Reuniting lost commit response IDs. server id: "
-               << update_id << " local id: " << local_entry.GetId()
+      DVLOG(1) << "Reuniting lost commit response IDs. server id: " << update_id
+               << " local id: " << local_entry.GetId()
                << " new version: " << new_version;
 
       return local_entry.GetId();
     }
   } else if (update.has_server_defined_unique_tag() &&
              !update.server_defined_unique_tag().empty()) {
     // The client creates type root folders with a local ID on demand when a
     // progress marker for the given type is initially set.
     // The server might also attempt to send a type root folder for the same
     // type (during the transition period until support for root folders is
@@ skipping 31 matching lines @@
   // treated as an unresolvable conflict. See the description in syncer_types.h.
   // This prevents any unsynced changes from commiting and postpones conflict
   // resolution until all data can be decrypted.
   if (specifics.has_encrypted() &&
       !cryptographer->CanDecrypt(specifics.encrypted())) {
     // We can't decrypt this node yet.
     DVLOG(1) << "Received an undecryptable "
              << ModelTypeToString(entry->GetServerModelType())
              << " update, returning conflict_encryption.";
     return CONFLICT_ENCRYPTION;
-  } else if (specifics.has_password() &&
-             entry->GetUniqueServerTag().empty()) {
+  } else if (specifics.has_password() && entry->GetUniqueServerTag().empty()) {
     // Passwords use their own legacy encryption scheme.
     const sync_pb::PasswordSpecifics& password = specifics.password();
     if (!cryptographer->CanDecrypt(password.encrypted())) {
       DVLOG(1) << "Received an undecryptable password update, returning "
                << "conflict_encryption.";
       return CONFLICT_ENCRYPTION;
     }
   }
 
   if (!entry->GetServerIsDel()) {
@@ skipping 132 matching lines @@
   // Update our position.
   UniquePosition update_pos =
       GetUpdatePosition(update, local_entry->GetUniqueBookmarkTag());
   if (update_pos.IsValid()) {
     local_entry->PutServerUniquePosition(update_pos);
   }
 }
 
 }  // namespace
 
-void UpdateServerFieldsFromUpdate(
-    syncable::ModelNeutralMutableEntry* target,
-    const sync_pb::SyncEntity& update,
-    const std::string& name) {
+void UpdateServerFieldsFromUpdate(syncable::ModelNeutralMutableEntry* target,
+                                  const sync_pb::SyncEntity& update,
+                                  const std::string& name) {
   if (update.deleted()) {
     if (target->GetServerIsDel()) {
       // 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;
     }
     // Mark entry as unapplied update first to ensure journaling the deletion.
     target->PutIsUnappliedUpdate(true);
@@ skipping 35 matching lines @@
   // Store the datatype-specific part as a protobuf.
   if (update.has_specifics()) {
     DCHECK_NE(GetModelType(update), UNSPECIFIED)
         << "Storing unrecognized datatype in sync database.";
     target->PutServerSpecifics(update.specifics());
   } else if (update.has_bookmarkdata()) {
     // Legacy protocol response for bookmark data.
     const sync_pb::SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
     UpdateBookmarkSpecifics(update.server_defined_unique_tag(),
                             bookmark.bookmark_url(),
-                            bookmark.bookmark_favicon(),
-                            target);
+                            bookmark.bookmark_favicon(), target);
   }
   target->PutServerAttachmentMetadata(
       CreateAttachmentMetadata(update.attachment_id()));
   if (SyncerProtoUtil::ShouldMaintainPosition(update)) {
     UpdateBookmarkPositioning(update, target);
   }
 
   // We only mark the entry as unapplied if its version is greater than the
   // local data. If we're processing the update that corresponds to one of our
   // commit we don't apply it as time differences may occur.
   if (update.version() > target->GetBaseVersion()) {
     target->PutIsUnappliedUpdate(true);
   }
   DCHECK(!update.deleted());
   target->PutServerIsDel(false);
 }
 
 // Creates a new Entry iff no Entry exists with the given id.
-void CreateNewEntry(syncable::ModelNeutralWriteTransaction *trans,
+void CreateNewEntry(syncable::ModelNeutralWriteTransaction* trans,
                     const syncable::Id& id) {
   syncable::Entry entry(trans, GET_BY_ID, id);
   if (!entry.good()) {
     syncable::ModelNeutralMutableEntry new_entry(
-        trans,
-        syncable::CREATE_NEW_UPDATE_ITEM,
-        id);
+        trans, syncable::CREATE_NEW_UPDATE_ITEM, id);
   }
 }
 
 // This function is called on an entry when we can update the user-facing data
 // from the server data.
-void UpdateLocalDataFromServerData(
-    syncable::WriteTransaction* trans,
-    syncable::MutableEntry* entry) {
+void UpdateLocalDataFromServerData(syncable::WriteTransaction* trans,
+                                   syncable::MutableEntry* entry) {
   DCHECK(!entry->GetIsUnsynced());
   DCHECK(entry->GetIsUnappliedUpdate());
 
   DVLOG(2) << "Updating entry : " << *entry;
   // Start by setting the properties that determine the model_type.
   entry->PutSpecifics(entry->GetServerSpecifics());
   // Clear the previous server specifics now that we're applying successfully.
   entry->PutBaseServerSpecifics(sync_pb::EntitySpecifics());
   entry->PutIsDir(entry->GetServerIsDir());
   // This strange dance around the IS_DEL flag avoids problems when setting
@@ skipping 28 matching lines @@
     LOG(ERROR) << "Permanent item became unsynced " << *entry;
     return VERIFY_UNSYNCABLE;
   }
   if (entry->GetIsDel() && !entry->GetId().ServerKnows()) {
     // Drop deleted uncommitted entries.
     return VERIFY_UNSYNCABLE;
   }
   return VERIFY_OK;
 }
 
-void MarkDeletedChildrenSynced(
-    syncable::Directory* dir,
-    syncable::BaseWriteTransaction* trans,
-    std::set<syncable::Id>* deleted_folders) {
+void MarkDeletedChildrenSynced(syncable::Directory* dir,
+                               syncable::BaseWriteTransaction* trans,
+                               std::set<syncable::Id>* deleted_folders) {
   // There's two options here.
   // 1. Scan deleted unsynced entries looking up their pre-delete tree for any
   //    of the deleted folders.
   // 2. Take each folder and do a tree walk of all entries underneath it.
   // #2 has a lower big O cost, but writing code to limit the time spent inside
   // the transaction during each step is simpler with 1. Changing this decision
   // may be sensible if this code shows up in profiling.
   if (deleted_folders->empty())
     return;
   Directory::Metahandles handles;
   dir->GetUnsyncedMetaHandles(trans, &handles);
   if (handles.empty())
     return;
   Directory::Metahandles::iterator it;
-  for (it = handles.begin() ; it != handles.end() ; ++it) {
+  for (it = handles.begin(); it != handles.end(); ++it) {
     syncable::ModelNeutralMutableEntry entry(trans, GET_BY_HANDLE, *it);
     if (!entry.GetIsUnsynced() || !entry.GetIsDel())
       continue;
     syncable::Id id = entry.GetParentId();
     while (id != trans->root_id()) {
       if (deleted_folders->find(id) != deleted_folders->end()) {
         // We've synced the deletion of this deleted entries parent.
         entry.PutIsUnsynced(false);
         break;
       }
       Entry parent(trans, GET_BY_ID, id);
       if (!parent.good() || !parent.GetIsDel())
         break;
       id = parent.GetParentId();
     }
   }
 }
 
-VerifyResult VerifyNewEntry(
-    const sync_pb::SyncEntity& update,
-    syncable::Entry* target,
-    const bool deleted) {
+VerifyResult VerifyNewEntry(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::ModelNeutralWriteTransaction* trans,
     const sync_pb::SyncEntity& update,
     const bool deleted,
     const bool is_directory,
     ModelType model_type,
     syncable::ModelNeutralMutableEntry* target) {
-
   CHECK(target->good());
   const 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 == 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.
@@ skipping 72 matching lines @@
   if (target->GetIsDel()) {
     if (target->GetUniqueClientTag().empty())
       LOG(WARNING) << "Doing move-aside undeletion on client-tagged item.";
     target->PutId(trans->directory()->NextId());
     target->PutUniqueClientTag(std::string());
     target->PutBaseVersion(CHANGES_VERSION);
     target->PutServerVersion(0);
     return VERIFY_SUCCESS;
   }
   if (update.version() < target->GetServerVersion()) {
-    LOG(WARNING) << "Update older than current server version for "
-                 << *target << " Update:"
+    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