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

components/sync/engine_impl/directory_commit_contribution_unittest.cc

 // Copyright 2014 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/directory_commit_contribution.h"
+#include "components/sync/engine_impl/directory_commit_contribution.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
-#include "sync/internal_api/public/base/attachment_id_proto.h"
-#include "sync/sessions/status_controller.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/syncable_read_transaction.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/test_directory_setter_upper.h"
-#include "sync/test/engine/test_id_factory.h"
-#include "sync/test/engine/test_syncable_utils.h"
+#include "components/sync/base/attachment_id_proto.h"
+#include "components/sync/sessions_impl/status_controller.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/syncable_read_transaction.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/test/engine/test_directory_setter_upper.h"
+#include "components/sync/test/engine/test_id_factory.h"
+#include "components/sync/test/engine/test_syncable_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 class DirectoryCommitContributionTest : public ::testing::Test {
  public:
   void SetUp() override {
     dir_maker_.SetUp();
 
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
@@ skipping 23 matching lines @@
     if (attachment_metadata.record_size() > 0) {
       entry.PutAttachmentMetadata(attachment_metadata);
     }
     entry.PutIsUnsynced(true);
     return entry.GetMetahandle();
   }
 
   int64_t CreateUnsyncedItem(syncable::WriteTransaction* trans,
                              ModelType type,
                              const std::string& tag) {
-    return CreateUnsyncedItemWithAttachments(
-        trans, type, tag, sync_pb::AttachmentMetadata());
+    return CreateUnsyncedItemWithAttachments(trans, type, tag,
+                                             sync_pb::AttachmentMetadata());
   }
 
   int64_t CreateSyncedItem(syncable::WriteTransaction* trans,
                            ModelType type,
                            const std::string& tag) {
     syncable::Entry parent_entry(trans, syncable::GET_TYPE_ROOT, type);
-    syncable::MutableEntry entry(
-        trans,
-        syncable::CREATE,
-        type,
-        parent_entry.GetId(),
-        tag);
+    syncable::MutableEntry entry(trans, syncable::CREATE, type,
+                                 parent_entry.GetId(), tag);
 
     entry.PutId(syncable::Id::CreateFromServerId(
         id_factory_.NewServerId().GetServerId()));
     entry.PutBaseVersion(10);
     entry.PutServerVersion(10);
     entry.PutIsUnappliedUpdate(false);
     entry.PutIsUnsynced(false);
     entry.PutIsDel(false);
     entry.PutServerIsDel(false);
 
     return entry.GetMetahandle();
   }
 
   void CreateSuccessfulCommitResponse(
       const sync_pb::SyncEntity& entity,
       sync_pb::CommitResponse::EntryResponse* response) {
     response->set_response_type(sync_pb::CommitResponse::SUCCESS);
     response->set_non_unique_name(entity.name());
     response->set_version(entity.version() + 1);
     response->set_parent_id_string(entity.parent_id_string());
 
     if (entity.id_string()[0] == '-')  // Look for the - in 'c-1234' style IDs.
       response->set_id_string(id_factory_.NewServerId().GetServerId());
     else
       response->set_id_string(entity.id_string());
   }
 
-  syncable::Directory* dir() {
-    return dir_maker_.directory();
-  }
+  syncable::Directory* dir() { return dir_maker_.directory(); }
 
   TestIdFactory id_factory_;
 
   // Used in construction of DirectoryTypeDebugInfoEmitters.
   base::ObserverList<TypeDebugInfoObserver> type_observers_;
 
  private:
   base::MessageLoop loop_;  // Neeed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
 };
@@ skipping 71 matching lines @@
 
   const sync_pb::CommitMessage& commit_message = message.commit();
 
   std::set<syncable::Id> ids_for_commit;
   ASSERT_EQ(3, commit_message.entries_size());
   for (int i = 0; i < commit_message.entries_size(); ++i) {
     const sync_pb::SyncEntity& entity = commit_message.entries(i);
     // The entities in this test have client-style IDs since they've never been
     // committed before, so we must use CreateFromClientString to re-create them
     // from the commit message.
-    ids_for_commit.insert(syncable::Id::CreateFromClientString(
-            entity.id_string()));
+    ids_for_commit.insert(
+        syncable::Id::CreateFromClientString(entity.id_string()));
   }
 
   ASSERT_EQ(3U, ids_for_commit.size());
   {
     syncable::ReadTransaction trans(FROM_HERE, dir());
     for (std::set<syncable::Id>::iterator it = ids_for_commit.begin();
          it != ids_for_commit.end(); ++it) {
       SCOPED_TRACE(it->value());
       syncable::Entry entry(&trans, syncable::GET_BY_ID, *it);
       ASSERT_TRUE(entry.good());
@@ skipping 22 matching lines @@
   DirectoryTypeDebugInfoEmitter emitter(PREFERENCES, &type_observers_);
   std::unique_ptr<DirectoryCommitContribution> pref_cc(
       DirectoryCommitContribution::Build(dir(), PREFERENCES, 25, &emitter));
   ASSERT_TRUE(pref_cc);
 
   sync_pb::ClientToServerMessage message;
   pref_cc->AddToCommitMessage(&message);
 
   const sync_pb::CommitMessage& commit_message = message.commit();
   ASSERT_EQ(1, commit_message.entries_size());
-  EXPECT_TRUE(
-      commit_message.entries(0).specifics().has_preference());
+  EXPECT_TRUE(commit_message.entries(0).specifics().has_preference());
 
   pref_cc->CleanUp();
 }
 
 // As ususal, bookmarks are special.  Bookmark deletion is special.
 // Deleted bookmarks include a valid "is folder" bit and their full specifics
 // (especially the meta info, which is what server really wants).
 TEST_F(DirectoryCommitContributionTest, DeletedBookmarksWithSpecifics) {
   int64_t bm1;
   {
@@ skipping 181 matching lines @@
   int64_t art2_handle;
   int64_t art3_handle;
   {
     syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, dir());
 
     // art1 has two attachments, both have been uploaded to the server.  art1 is
     // eligible to be committed.
     sync_pb::AttachmentMetadata art1_attachments;
     AddAttachment(&art1_attachments, true /* is_on_server */);
     AddAttachment(&art1_attachments, true /* is_on_server */);
-    art1_handle = CreateUnsyncedItemWithAttachments(
-        &trans, ARTICLES, "art1", art1_attachments);
+    art1_handle = CreateUnsyncedItemWithAttachments(&trans, ARTICLES, "art1",
+                                                    art1_attachments);
 
     // art2 has two attachments, one of which has been uploaded to the
     // server. art2 is not eligible to be committed.
     sync_pb::AttachmentMetadata art2_attachments;
     AddAttachment(&art2_attachments, false /* is_on_server */);
     AddAttachment(&art2_attachments, true /* is_on_server */);
-    art2_handle = CreateUnsyncedItemWithAttachments(
-        &trans, ARTICLES, "art2", art2_attachments);
+    art2_handle = CreateUnsyncedItemWithAttachments(&trans, ARTICLES, "art2",
+                                                    art2_attachments);
 
     // art3 has two attachments, neither of which have been uploaded to the
     // server. art2 is not eligible to be committed.
     sync_pb::AttachmentMetadata art3_attachments;
     AddAttachment(&art3_attachments, false /* is_on_server */);
     AddAttachment(&art3_attachments, false /* is_on_server */);
-    art3_handle = CreateUnsyncedItemWithAttachments(
-        &trans, ARTICLES, "art3", art3_attachments);
+    art3_handle = CreateUnsyncedItemWithAttachments(&trans, ARTICLES, "art3",
+                                                    art3_attachments);
   }
 
   DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_);
   std::unique_ptr<DirectoryCommitContribution> art_cc(
       DirectoryCommitContribution::Build(dir(), ARTICLES, 25, &emitter));
 
   // Only art1 is ready.
   EXPECT_EQ(1U, art_cc->GetNumEntries());
 
   sync_pb::ClientToServerMessage message;
@@ skipping 31 matching lines @@
     EXPECT_FALSE(a3.GetId().ServerKnows());
     EXPECT_FALSE(a3.GetSyncing());
     EXPECT_FALSE(a3.GetDirtySync());
     EXPECT_EQ(0, a3.GetServerVersion());
   }
 
   art_cc->CleanUp();
 }
 
 }  // namespace syncer