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

components/sync/syncable/directory_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/syncable/directory_unittest.h"
+#include "components/sync/syncable/directory_unittest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/values_test_util.h"
-#include "sync/internal_api/public/base/attachment_id_proto.h"
-#include "sync/syncable/syncable_proto_util.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/test_syncable_utils.h"
-#include "sync/test/test_directory_backing_store.h"
-#include "sync/util/mock_unrecoverable_error_handler.h"
+#include "components/sync/base/attachment_id_proto.h"
+#include "components/sync/base/mock_unrecoverable_error_handler.h"
+#include "components/sync/syncable/syncable_proto_util.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/test/engine/test_syncable_utils.h"
+#include "components/sync/test/test_directory_backing_store.h"
 
 using base::ExpectDictBooleanValue;
 using base::ExpectDictStringValue;
 
 namespace syncer {
 
 namespace syncable {
 
 namespace {
 
@@ skipping 19 matching lines @@
   ASSERT_TRUE(e->GetSpecifics().has_bookmark());
   ASSERT_EQ("http://demo/", e->GetSpecifics().bookmark().url());
   ASSERT_EQ(std::string(bytes, bytes_length),
             e->GetSpecifics().bookmark().favicon());
 }
 
 }  // namespace
 
 const char SyncableDirectoryTest::kDirectoryName[] = "Foo";
 
-SyncableDirectoryTest::SyncableDirectoryTest() {
-}
+SyncableDirectoryTest::SyncableDirectoryTest() {}
 
-SyncableDirectoryTest::~SyncableDirectoryTest() {
-}
+SyncableDirectoryTest::~SyncableDirectoryTest() {}
 
 void SyncableDirectoryTest::SetUp() {
   ASSERT_TRUE(connection_.OpenInMemory());
   ASSERT_EQ(OPENED, ReopenDirectory());
 }
 
 void SyncableDirectoryTest::TearDown() {
   if (dir_)
     dir_->SaveChanges();
   dir_.reset();
@@ skipping 26 matching lines @@
 // Creates an empty entry and sets the ID field to id.
 void SyncableDirectoryTest::CreateEntry(const ModelType& model_type,
                                         const std::string& entryname,
                                         const int id) {
   CreateEntry(model_type, entryname, TestIdFactory::FromNumber(id));
 }
 
 void SyncableDirectoryTest::CreateEntry(const ModelType& model_type,
                                         const std::string& entryname,
                                         const Id& id) {
-  CreateEntryWithAttachmentMetadata(
-      model_type, entryname, id, sync_pb::AttachmentMetadata());
+  CreateEntryWithAttachmentMetadata(model_type, entryname, id,
+                                    sync_pb::AttachmentMetadata());
 }
 
 void SyncableDirectoryTest::CreateEntryWithAttachmentMetadata(
     const ModelType& model_type,
     const std::string& entryname,
     const Id& id,
     const sync_pb::AttachmentMetadata& attachment_metadata) {
   WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
   MutableEntry me(&wtrans, CREATE, model_type, wtrans.root_id(), entryname);
   ASSERT_TRUE(me.good());
@@ skipping 79 matching lines @@
 }
 
 DirectoryChangeDelegate* SyncableDirectoryTest::directory_change_delegate() {
   return &delegate_;
 }
 
 Encryptor* SyncableDirectoryTest::encryptor() {
   return &encryptor_;
 }
 
-
 TestUnrecoverableErrorHandler*
 SyncableDirectoryTest::unrecoverable_error_handler() {
   return &handler_;
 }
 
 void SyncableDirectoryTest::ValidateEntry(BaseTransaction* trans,
                                           int64_t id,
                                           bool check_name,
                                           const std::string& name,
                                           int64_t base_version,
@@ skipping 65 matching lines @@
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     ASSERT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end();
-         ++i) {
+         i != snapshot.dirty_metas.end(); ++i) {
       ASSERT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     std::vector<int64_t> new_dirty_metahandles;
     for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
@@ skipping 13 matching lines @@
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end();
-         ++i) {
+         i != snapshot.dirty_metas.end(); ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
 
   // half of 2 * metahandles_to_create
@@ skipping 69 matching lines @@
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each changed metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(number_changed, snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
-         i != snapshot.dirty_metas.end();
-         ++i) {
+         i != snapshot.dirty_metas.end(); ++i) {
       EXPECT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 // Test delete journals management.
 TEST_F(SyncableDirectoryTest, ManageDeleteJournals) {
   sync_pb::EntitySpecifics bookmark_specifics;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specifics);
@@ skipping 617 matching lines @@
     ASSERT_TRUE(item.good());
     item.PutId(id_factory.NewServerId());
     item.PutSpecifics(specifics);
     item.PutBaseVersion(1);
     item.PutIsDir(false);
     item.PutIsDel(false);
     ASSERT_EQ(datatype, item.GetModelType());
 
     // It's critical that deletion records retain their datatype, so that
     // they can be dispatched to the appropriate change processor.
-    MutableEntry deleted_item(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "Deleted Item");
+    MutableEntry deleted_item(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                              "Deleted Item");
     ASSERT_TRUE(item.good());
     deleted_item.PutId(id_factory.NewServerId());
     deleted_item.PutSpecifics(specifics);
     deleted_item.PutBaseVersion(1);
     deleted_item.PutIsDir(false);
     deleted_item.PutIsDel(true);
     ASSERT_EQ(datatype, deleted_item.GetModelType());
 
-    MutableEntry server_folder(
-        &trans, CREATE_NEW_UPDATE_ITEM, id_factory.NewServerId());
+    MutableEntry server_folder(&trans, CREATE_NEW_UPDATE_ITEM,
+                               id_factory.NewServerId());
     ASSERT_TRUE(server_folder.good());
     server_folder.PutServerSpecifics(specifics);
     server_folder.PutBaseVersion(1);
     server_folder.PutServerIsDir(true);
     server_folder.PutServerIsDel(false);
     ASSERT_EQ(datatype, server_folder.GetServerModelType());
 
-    MutableEntry server_item(
-        &trans, CREATE_NEW_UPDATE_ITEM, id_factory.NewServerId());
+    MutableEntry server_item(&trans, CREATE_NEW_UPDATE_ITEM,
+                             id_factory.NewServerId());
     ASSERT_TRUE(server_item.good());
     server_item.PutServerSpecifics(specifics);
     server_item.PutBaseVersion(1);
     server_item.PutServerIsDir(false);
     server_item.PutServerIsDel(false);
     ASSERT_EQ(datatype, server_item.GetServerModelType());
 
     sync_pb::SyncEntity folder_entity;
     folder_entity.set_id_string(SyncableIdToProto(id_factory.NewServerId()));
     folder_entity.set_deleted(false);
@@ skipping 196 matching lines @@
   Id zombie_id = id_factory.NewLocalId();
 
   // We're about to do some bad things.  Tell the directory verification
   // routines to look the other way.
   dir()->SetInvariantCheckLevel(OFF);
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
     // Create an uncommitted tombstone entry.
-    MutableEntry server_knows(
-        &trans, CREATE, BOOKMARKS, id_factory.root(), "server_knows");
+    MutableEntry server_knows(&trans, CREATE, BOOKMARKS, id_factory.root(),
+                              "server_knows");
     server_knows.PutId(server_knows_id);
     server_knows.PutIsUnsynced(true);
     server_knows.PutIsDel(true);
     server_knows.PutBaseVersion(5);
     server_knows.PutServerVersion(4);
 
     // Create a valid update entry.
-    MutableEntry not_is_del(
-        &trans, CREATE, BOOKMARKS, id_factory.root(), "not_is_del");
+    MutableEntry not_is_del(&trans, CREATE, BOOKMARKS, id_factory.root(),
+                            "not_is_del");
     not_is_del.PutId(not_is_del_id);
     not_is_del.PutIsDel(false);
     not_is_del.PutIsUnsynced(true);
 
     // Create a tombstone which should never be sent to the server because the
     // server never knew about the item's existence.
     //
     // New clients should never put entries into this state.  We work around
     // this by setting IS_DEL before setting IS_UNSYNCED, something which the
     // client should never do in practice.
@@ skipping 74 matching lines @@
 
     MutableEntry parent(&trans, CREATE, BOOKMARKS, id_factory.root(), "parent");
     parent.PutIsDir(true);
     parent.PutIsUnsynced(true);
 
     // The code is littered with DCHECKs that try to stop us from doing what
     // we're about to do.  Our work-around is to create a bookmark based on
     // a server update, then update its local specifics without updating its
     // local unique position.
 
-    MutableEntry child(
-        &trans, CREATE_NEW_UPDATE_ITEM, id_factory.MakeServer("child"));
+    MutableEntry child(&trans, CREATE_NEW_UPDATE_ITEM,
+                       id_factory.MakeServer("child"));
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(BOOKMARKS, &specifics);
     child.PutIsUnappliedUpdate(true);
     child.PutSpecifics(specifics);
 
     EXPECT_TRUE(child.ShouldMaintainPosition());
     EXPECT_TRUE(!child.GetUniquePosition().IsValid());
   }
 
   EXPECT_EQ(FAILED_DATABASE_CORRUPT, SimulateSaveAndReloadDir());
@@ skipping 276 matching lines @@
 };
 
 // Stress test Directory by accessing it from several threads concurrently.
 TEST_F(SyncableDirectoryTest, StressTransactions) {
   const int kThreadCount = 7;
   base::PlatformThreadHandle threads[kThreadCount];
   std::unique_ptr<StressTransactionsDelegate> thread_delegates[kThreadCount];
 
   for (int i = 0; i < kThreadCount; ++i) {
     thread_delegates[i].reset(new StressTransactionsDelegate(dir().get(), i));
-    ASSERT_TRUE(base::PlatformThread::Create(
-        0, thread_delegates[i].get(), &threads[i]));
+    ASSERT_TRUE(base::PlatformThread::Create(0, thread_delegates[i].get(),
+                                             &threads[i]));
   }
 
   for (int i = 0; i < kThreadCount; ++i) {
     base::PlatformThread::Join(threads[i]);
   }
 }
 
 // Verify that Directory is notifed when a MutableEntry's AttachmentMetadata
 // changes.
 TEST_F(SyncableDirectoryTest, MutableEntry_PutAttachmentMetadata) {
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
   sync_pb::AttachmentIdProto attachment_id_proto =
       syncer::CreateAttachmentIdProto(0, 0);
   *record->mutable_id() = attachment_id_proto;
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
     // Create an entry with attachment metadata and see that the attachment id
     // is not linked.
-    MutableEntry entry(
-        &trans, CREATE, PREFERENCES, trans.root_id(), "some entry");
+    MutableEntry entry(&trans, CREATE, PREFERENCES, trans.root_id(),
+                       "some entry");
     entry.PutId(TestIdFactory::FromNumber(-1));
     entry.PutIsUnsynced(true);
 
     Directory::Metahandles metahandles;
     ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
-    dir()->GetMetahandlesByAttachmentId(
-        &trans, attachment_id_proto, &metahandles);
+    dir()->GetMetahandlesByAttachmentId(&trans, attachment_id_proto,
+                                        &metahandles);
     ASSERT_TRUE(metahandles.empty());
 
     // Now add the attachment metadata and see that Directory believes it is
     // linked.
     entry.PutAttachmentMetadata(attachment_metadata);
     ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id_proto));
-    dir()->GetMetahandlesByAttachmentId(
-        &trans, attachment_id_proto, &metahandles);
+    dir()->GetMetahandlesByAttachmentId(&trans, attachment_id_proto,
+                                        &metahandles);
     ASSERT_FALSE(metahandles.empty());
     ASSERT_EQ(metahandles[0], entry.GetMetahandle());
 
     // Clear out the attachment metadata and see that it's no longer linked.
     sync_pb::AttachmentMetadata empty_attachment_metadata;
     entry.PutAttachmentMetadata(empty_attachment_metadata);
     ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
-    dir()->GetMetahandlesByAttachmentId(
-        &trans, attachment_id_proto, &metahandles);
+    dir()->GetMetahandlesByAttachmentId(&trans, attachment_id_proto,
+                                        &metahandles);
     ASSERT_TRUE(metahandles.empty());
   }
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
 }
 
 // Verify that UpdateAttachmentId updates attachment_id and is_on_server flag.
 TEST_F(SyncableDirectoryTest, MutableEntry_UpdateAttachmentId) {
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* r1 = attachment_metadata.add_record();
   sync_pb::AttachmentMetadataRecord* r2 = attachment_metadata.add_record();
   *r1->mutable_id() = syncer::CreateAttachmentIdProto(0, 0);
   *r2->mutable_id() = syncer::CreateAttachmentIdProto(0, 0);
   sync_pb::AttachmentIdProto attachment_id_proto = r1->id();
 
   WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
-  MutableEntry entry(
-      &trans, CREATE, PREFERENCES, trans.root_id(), "some entry");
+  MutableEntry entry(&trans, CREATE, PREFERENCES, trans.root_id(),
+                     "some entry");
   entry.PutId(TestIdFactory::FromNumber(-1));
   entry.PutAttachmentMetadata(attachment_metadata);
 
   {
     const sync_pb::AttachmentMetadata& entry_metadata =
         entry.GetAttachmentMetadata();
     ASSERT_EQ(2, entry_metadata.record_size());
     ASSERT_FALSE(entry_metadata.record(0).is_on_server());
     ASSERT_FALSE(entry_metadata.record(1).is_on_server());
     ASSERT_FALSE(entry.GetIsUnsynced());
@@ skipping 18 matching lines @@
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
   sync_pb::AttachmentIdProto attachment_id_proto =
       syncer::CreateAttachmentIdProto(0, 0);
   *record->mutable_id() = attachment_id_proto;
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
   const Id id = TestIdFactory::FromNumber(-1);
 
   // Create an entry with attachment metadata and see that the attachment id
   // is linked.
-  CreateEntryWithAttachmentMetadata(
-      PREFERENCES, "some entry", id, attachment_metadata);
+  CreateEntryWithAttachmentMetadata(PREFERENCES, "some entry", id,
+                                    attachment_metadata);
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id_proto));
 
   // Delete the entry and see that it's still linked because the entry hasn't
   // yet been purged.
   DeleteEntry(id);
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id_proto));
 
   // Reload the Directory, purging the deleted entry, and see that the
   // attachment is no longer linked.
   SimulateSaveAndReloadDir();
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
 }
 
 // Verify that a given attachment can be referenced by multiple entries and that
 // any one of the references is sufficient to ensure it remains linked.
 TEST_F(SyncableDirectoryTest, Directory_LastReferenceUnlinksAttachments) {
   // Create one attachment.
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
   sync_pb::AttachmentIdProto attachment_id_proto =
       syncer::CreateAttachmentIdProto(0, 0);
   *record->mutable_id() = attachment_id_proto;
 
   // Create two entries, each referencing the attachment.
   const Id id1 = TestIdFactory::FromNumber(-1);
   const Id id2 = TestIdFactory::FromNumber(-2);
-  CreateEntryWithAttachmentMetadata(
-      PREFERENCES, "some entry", id1, attachment_metadata);
-  CreateEntryWithAttachmentMetadata(
-      PREFERENCES, "some other entry", id2, attachment_metadata);
+  CreateEntryWithAttachmentMetadata(PREFERENCES, "some entry", id1,
+                                    attachment_metadata);
+  CreateEntryWithAttachmentMetadata(PREFERENCES, "some other entry", id2,
+                                    attachment_metadata);
 
   // See that the attachment is considered linked.
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id_proto));
 
   // Delete the first entry, reload the Directory, see that the attachment is
   // still linked.
   DeleteEntry(id1);
   SimulateSaveAndReloadDir();
   ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id_proto));
 
   // Delete the second entry, reload the Directory, see that the attachment is
   // no loner linked.
   DeleteEntry(id2);
   SimulateSaveAndReloadDir();
   ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id_proto));
 }
 
 TEST_F(SyncableDirectoryTest, Directory_GetAttachmentIdsToUpload) {
   // Create one attachment, referenced by two entries.
   AttachmentId attachment_id = AttachmentId::Create(0, 0);
   sync_pb::AttachmentIdProto attachment_id_proto = attachment_id.GetProto();
   sync_pb::AttachmentMetadata attachment_metadata;
   sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
   *record->mutable_id() = attachment_id_proto;
   const Id id1 = TestIdFactory::FromNumber(-1);
   const Id id2 = TestIdFactory::FromNumber(-2);
-  CreateEntryWithAttachmentMetadata(
-      PREFERENCES, "some entry", id1, attachment_metadata);
-  CreateEntryWithAttachmentMetadata(
-      PREFERENCES, "some other entry", id2, attachment_metadata);
+  CreateEntryWithAttachmentMetadata(PREFERENCES, "some entry", id1,
+                                    attachment_metadata);
+  CreateEntryWithAttachmentMetadata(PREFERENCES, "some other entry", id2,
+                                    attachment_metadata);
 
   // See that Directory reports that this attachment is not on the server.
   AttachmentIdList ids;
   {
     ReadTransaction trans(FROM_HERE, dir().get());
     dir()->GetAttachmentIdsToUpload(&trans, PREFERENCES, &ids);
   }
   ASSERT_EQ(1U, ids.size());
   ASSERT_EQ(attachment_id, *ids.begin());
 
@@ skipping 248 matching lines @@
   EXPECT_FALSE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 
   // Mark as complete and verify.
   dir()->MarkInitialSyncEndedForType(&trans, PREFERENCES);
   EXPECT_TRUE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer