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

components/sync/core/base_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/base_node.h"
+#include "components/sync/core/base_node.h"
 
 #include <stdint.h>
 
 #include <stack>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "sync/internal_api/public/base_transaction.h"
-#include "sync/internal_api/syncapi_internal.h"
-#include "sync/protocol/app_specifics.pb.h"
-#include "sync/protocol/autofill_specifics.pb.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/protocol/extension_specifics.pb.h"
-#include "sync/protocol/nigori_specifics.pb.h"
-#include "sync/protocol/password_specifics.pb.h"
-#include "sync/protocol/session_specifics.pb.h"
-#include "sync/protocol/theme_specifics.pb.h"
-#include "sync/protocol/typed_url_specifics.pb.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/syncable_base_transaction.h"
-#include "sync/syncable/syncable_id.h"
-#include "sync/util/time.h"
+#include "components/sync/base/time.h"
+#include "components/sync/core/base_transaction.h"
+#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/protocol/app_specifics.pb.h"
+#include "components/sync/protocol/autofill_specifics.pb.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/protocol/extension_specifics.pb.h"
+#include "components/sync/protocol/nigori_specifics.pb.h"
+#include "components/sync/protocol/password_specifics.pb.h"
+#include "components/sync/protocol/session_specifics.pb.h"
+#include "components/sync/protocol/theme_specifics.pb.h"
+#include "components/sync/protocol/typed_url_specifics.pb.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/syncable_base_transaction.h"
+#include "components/sync/syncable/syncable_id.h"
 
 using sync_pb::AutofillProfileSpecifics;
 
 namespace syncer {
 
 using syncable::SPECIFICS;
 
 // Helper function to look up the int64_t metahandle of an object given the ID
 // string.
 static int64_t IdToMetahandle(syncable::BaseTransaction* trans,
                               const syncable::Id& id) {
   if (id.IsNull())
     return kInvalidId;
   syncable::Entry entry(trans, syncable::GET_BY_ID, id);
   if (!entry.good())
     return kInvalidId;
   return entry.GetMetahandle();
 }
 
 BaseNode::BaseNode() : password_data_(new sync_pb::PasswordSpecificsData) {}
 
 BaseNode::~BaseNode() {}
 
 bool BaseNode::DecryptIfNecessary() {
   if (GetIsPermanentFolder())
-      return true;  // Ignore unique folders.
-  const sync_pb::EntitySpecifics& specifics =
-      GetEntry()->GetSpecifics();
+    return true;  // Ignore unique folders.
+  const sync_pb::EntitySpecifics& specifics = GetEntry()->GetSpecifics();
   if (specifics.has_password()) {
     // Passwords have their own legacy encryption structure.
     std::unique_ptr<sync_pb::PasswordSpecificsData> data(
         DecryptPasswordSpecifics(specifics,
                                  GetTransaction()->GetCryptographer()));
     if (!data) {
       GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
           FROM_HERE, std::string("Failed to decrypt encrypted node of type ") +
                          ModelTypeToString(GetModelType()));
       return false;
     }
     password_data_.swap(data);
     return true;
   }
 
   // We assume any node with the encrypted field set has encrypted data and if
   // not we have no work to do, with the exception of bookmarks. For bookmarks
   // we must make sure the bookmarks data has the title field supplied. If not,
   // we fill the unencrypted_data_ with a copy of the bookmark specifics that
   // follows the new bookmarks format.
   if (!specifics.has_encrypted()) {
-    if (GetModelType() == BOOKMARKS &&
-        !specifics.bookmark().has_title() &&
+    if (GetModelType() == BOOKMARKS && !specifics.bookmark().has_title() &&
         !GetTitle().empty()) {  // Last check ensures this isn't a new node.
       // We need to fill in the title.
       std::string title = GetTitle();
       std::string server_legal_title;
       SyncAPINameToServerName(title, &server_legal_title);
       DVLOG(1) << "Reading from legacy bookmark, manually returning title "
                << title;
       unencrypted_data_.CopyFrom(specifics);
-      unencrypted_data_.mutable_bookmark()->set_title(
-          server_legal_title);
+      unencrypted_data_.mutable_bookmark()->set_title(server_legal_title);
     }
     return true;
   }
 
   const sync_pb::EncryptedData& encrypted = specifics.encrypted();
-  std::string plaintext_data = GetTransaction()->GetCryptographer()->
-      DecryptToString(encrypted);
+  std::string plaintext_data =
+      GetTransaction()->GetCryptographer()->DecryptToString(encrypted);
   if (plaintext_data.length() == 0) {
     GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
         FROM_HERE, std::string("Failed to decrypt encrypted node of type ") +
                        ModelTypeToString(GetModelType()));
     return false;
   } else if (!unencrypted_data_.ParseFromString(plaintext_data)) {
     GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
         FROM_HERE, std::string("Failed to parse encrypted node of type ") +
                        ModelTypeToString(GetModelType()));
     return false;
@@ skipping 64 matching lines @@
 }
 
 std::string BaseNode::GetTitle() const {
   std::string result;
   // TODO(zea): refactor bookmarks to not need this functionality.
   if (BOOKMARKS == GetModelType() &&
       GetEntry()->GetSpecifics().has_encrypted()) {
     // Special case for legacy bookmarks dealing with encryption.
     ServerNameToSyncAPIName(GetBookmarkSpecifics().title(), &result);
   } else {
-    ServerNameToSyncAPIName(GetEntry()->GetNonUniqueName(),
-                            &result);
+    ServerNameToSyncAPIName(GetEntry()->GetNonUniqueName(), &result);
   }
   return result;
 }
 
 bool BaseNode::HasChildren() const {
   syncable::Directory* dir = GetTransaction()->GetDirectory();
   syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
   return dir->HasChildren(trans, GetEntry()->GetId());
 }
 
@@ skipping 89 matching lines @@
     const sync_pb::EntitySpecifics& specifics) {
   ModelType type = GetModelTypeFromSpecifics(specifics);
   DCHECK_NE(UNSPECIFIED, type);
   if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(GetModelType(), type);
   }
   unencrypted_data_.CopyFrom(specifics);
 }
 
 }  // namespace syncer