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

components/sync/core/write_node.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/internal_api/public/write_node.h"
+#include "components/sync/core/write_node.h"
 
 #include <stdint.h>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "sync/internal_api/public/base_transaction.h"
-#include "sync/internal_api/public/write_transaction.h"
-#include "sync/internal_api/syncapi_internal.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/protocol/typed_url_specifics.pb.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/nigori_util.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/util/cryptographer.h"
+#include "components/sync/base/cryptographer.h"
+#include "components/sync/core/base_transaction.h"
+#include "components/sync/core/write_transaction.h"
+#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/protocol/typed_url_specifics.pb.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/nigori_util.h"
+#include "components/sync/syncable/syncable_util.h"
 
 using std::string;
 using std::vector;
 
 namespace syncer {
 
 using syncable::kEncryptedString;
 using syncable::SPECIFICS;
 
 static const char kDefaultNameForNewNodes[] = " ";
@@ skipping 21 matching lines @@
   std::string new_legal_title;
   if (type != BOOKMARKS && needs_encryption) {
     new_legal_title = kEncryptedString;
   } else {
     DCHECK(base::IsStringUTF8(title));
     SyncAPINameToServerName(title, &new_legal_title);
     base::TruncateUTF8ToByteSize(new_legal_title, 255, &new_legal_title);
   }
 
   std::string current_legal_title;
-  if (BOOKMARKS == type &&
-      entry_->GetSpecifics().has_encrypted()) {
+  if (BOOKMARKS == type && entry_->GetSpecifics().has_encrypted()) {
     // Encrypted bookmarks only have their title in the unencrypted specifics.
     current_legal_title = GetBookmarkSpecifics().title();
   } else {
     // Non-bookmarks and legacy bookmarks (those with no title in their
     // specifics) store their title in NON_UNIQUE_NAME. Non-legacy bookmarks
     // store their title in specifics as well as NON_UNIQUE_NAME.
     current_legal_title = entry_->GetNonUniqueName();
   }
 
   bool title_matches = (current_legal_title == new_legal_title);
-  bool encrypted_without_overwriting_name = (needs_encryption &&
-      entry_->GetNonUniqueName() != kEncryptedString);
+  bool encrypted_without_overwriting_name =
+      (needs_encryption && entry_->GetNonUniqueName() != kEncryptedString);
 
   // For bookmarks, we also set the title field in the specifics.
   // TODO(zea): refactor bookmarks to not need this functionality.
   sync_pb::EntitySpecifics specifics = GetEntitySpecifics();
   if (GetModelType() == BOOKMARKS &&
       specifics.bookmark().title() != new_legal_title) {
     specifics.mutable_bookmark()->set_title(new_legal_title);
     SetEntitySpecifics(specifics);  // Does it's own encryption checking.
     title_matches = false;
   }
 
   // If the title matches and the NON_UNIQUE_NAME is properly overwritten as
   // necessary, nothing needs to change.
   if (title_matches && !encrypted_without_overwriting_name) {
     DVLOG(2) << "Title matches, dropping change.";
     return;
   }
 
   // For bookmarks, this has to happen after we set the title in the specifics,
   // because the presence of a title in the NON_UNIQUE_NAME is what controls
   // the logic deciding whether this is an empty node or a legacy bookmark.
   // See BaseNode::GetUnencryptedSpecific(..).
   if (needs_encryption)
     entry_->PutNonUniqueName(kEncryptedString);
   else
     entry_->PutNonUniqueName(new_legal_title);
 
-  DVLOG(1) << "Overwriting title of type "
-           << ModelTypeToString(type)
+  DVLOG(1) << "Overwriting title of type " << ModelTypeToString(type)
            << " and marking for syncing.";
   MarkForSyncing();
 }
 
 void WriteNode::SetBookmarkSpecifics(
     const sync_pb::BookmarkSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
-void WriteNode::SetNigoriSpecifics(
-    const sync_pb::NigoriSpecifics& new_value) {
+void WriteNode::SetNigoriSpecifics(const sync_pb::NigoriSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_nigori()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetPasswordSpecifics(
     const sync_pb::PasswordSpecificsData& data) {
   DCHECK_EQ(GetModelType(), PASSWORDS);
 
   Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
@@ skipping 14 matching lines @@
   // This will only update password_specifics if the underlying unencrypted blob
   // was different from |data| or was not encrypted with the proper passphrase.
   if (!cryptographer->Encrypt(data, password_specifics->mutable_encrypted())) {
     LOG(ERROR) << "Failed to encrypt password, possibly due to sync node "
                << "corruption";
     return;
   }
   SetEntitySpecifics(entity_specifics);
 }
 
-void WriteNode::SetEntitySpecifics(
-    const sync_pb::EntitySpecifics& new_value) {
-  ModelType new_specifics_type =
-      GetModelTypeFromSpecifics(new_value);
+void WriteNode::SetEntitySpecifics(const sync_pb::EntitySpecifics& new_value) {
+  ModelType new_specifics_type = GetModelTypeFromSpecifics(new_value);
   CHECK(!new_value.password().has_client_only_encrypted_data());
   DCHECK_NE(new_specifics_type, UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
            << ModelTypeToString(new_specifics_type);
   DCHECK_EQ(new_specifics_type, GetModelType());
 
   // Preserve unknown fields.
   const sync_pb::EntitySpecifics& old_specifics = entry_->GetSpecifics();
   sync_pb::EntitySpecifics new_specifics;
   new_specifics.CopyFrom(new_value);
-  new_specifics.mutable_unknown_fields()
-      ->append(old_specifics.unknown_fields());
+  new_specifics.mutable_unknown_fields()->append(
+      old_specifics.unknown_fields());
 
   // Will update the entry if encryption was necessary.
   if (!UpdateEntryWithEncryption(GetTransaction()->GetWrappedTrans(),
-                                 new_specifics,
-                                 entry_)) {
+                                 new_specifics, entry_)) {
     return;
   }
   if (entry_->GetSpecifics().has_encrypted()) {
     // EncryptIfNecessary already updated the entry for us and marked for
     // syncing if it was needed. Now we just make a copy of the unencrypted
     // specifics so that if this node is updated, we do not have to decrypt the
     // old data. Note that this only modifies the node's local data, not the
     // entry itself.
     SetUnencryptedSpecifics(new_value);
   }
@@ skipping 87 matching lines @@
     return false;
   }
 
   syncable::Id parent_id = parent.GetSyncId();
   DCHECK(!parent_id.IsNull());
 
   // Start out with a dummy name.  We expect
   // the caller to set a meaningful name after creation.
   string dummy(kDefaultNameForNewNodes);
 
-  entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                      syncable::CREATE, BOOKMARKS,
-                                      parent_id, dummy);
+  entry_ =
+      new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
+                                 syncable::CREATE, BOOKMARKS, parent_id, dummy);
 
   if (!entry_->good())
     return false;
 
   // Entries are untitled folders by default.
   entry_->PutIsDir(true);
 
   if (!PutPredecessor(predecessor)) {
     return false;
   }
@@ skipping 84 matching lines @@
     }  // Else just reuse the existing entry.
     entry_ = existing_entry.release();
     // If entry is undeleted, its specifics are reset to default, unencrypted
     // value, and therefore no decryption is necessary. Moreover trying to
     // decrypt the password entry will fail because passwords are expected to be
     // encrypted.
     if (!entry_undeleted && !DecryptIfNecessary())
       return INIT_FAILED_DECRYPT_EXISTING_ENTRY;
   } else {
     entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
-                                        syncable::CREATE,
-                                        model_type, parent_id, dummy);
+                                        syncable::CREATE, model_type, parent_id,
+                                        dummy);
   }
 
   if (!entry_->good())
     return INIT_FAILED_COULD_NOT_CREATE_ENTRY;
 
   // Has no impact if the client tag is already set.
   entry_->PutUniqueClientTag(hash);
 
   // We don't support directory and tag combinations.
   entry_->PutIsDir(false);
@@ skipping 76 matching lines @@
   syncable::Id predecessor_id =
       predecessor ? predecessor->GetSyncId() : syncable::Id();
   return entry_->PutPredecessor(predecessor_id);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 }  // namespace syncer