[Sync] //components/sync internal changes [DO NOT SUBMIT]

components/sync/engine_impl/directory_update_handler_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_update_handler.h"
+#include "components/sync/engine_impl/directory_update_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "sync/engine/syncer_proto_util.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/test/test_entry_factory.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/sessions/directory_type_debug_info_emitter.h"
-#include "sync/sessions/status_controller.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/mutable_entry.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_write_transaction.h"
-#include "sync/test/engine/fake_model_worker.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/base/model_type.h"
+#include "components/sync/core/test/test_entry_factory.h"
+#include "components/sync/engine_impl/syncer_proto_util.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/sessions_impl/directory_type_debug_info_emitter.h"
+#include "components/sync/sessions_impl/status_controller.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/mutable_entry.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_write_transaction.h"
+#include "components/sync/test/engine/fake_model_worker.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 {
 
 using syncable::Id;
 using syncable::UNITTEST;
 
 static const int64_t kDefaultVersion = 1000;
 
 // A test harness for tests that focus on processing updates.
 //
 // Update processing is what occurs when we first download updates.  It converts
 // the received protobuf message into information in the syncable::Directory.
 // Any invalid or redundant updates will be dropped at this point.
 class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
  public:
   DirectoryUpdateHandlerProcessUpdateTest()
-      : ui_worker_(new FakeModelWorker(GROUP_UI)) {
-  }
+      : ui_worker_(new FakeModelWorker(GROUP_UI)) {}
 
   ~DirectoryUpdateHandlerProcessUpdateTest() override {}
 
   void SetUp() override { dir_maker_.SetUp(); }
 
   void TearDown() override { dir_maker_.TearDown(); }
 
-  syncable::Directory* dir() {
-    return dir_maker_.directory();
-  }
+  syncable::Directory* dir() { return dir_maker_.directory(); }
 
  protected:
   std::unique_ptr<sync_pb::SyncEntity> CreateUpdate(const std::string& id,
                                                     const std::string& parent,
                                                     const ModelType& type);
 
   // This exists mostly to give tests access to the protected member function.
   // Warning: This takes the syncable directory lock.
-  void UpdateSyncEntities(
-      DirectoryUpdateHandler* handler,
-      const SyncEntityList& applicable_updates,
-      sessions::StatusController* status);
+  void UpdateSyncEntities(DirectoryUpdateHandler* handler,
+                          const SyncEntityList& applicable_updates,
+                          sessions::StatusController* status);
 
   // Another function to access private member functions.
-  void UpdateProgressMarkers(
-      DirectoryUpdateHandler* handler,
-      const sync_pb::DataTypeProgressMarker& progress);
+  void UpdateProgressMarkers(DirectoryUpdateHandler* handler,
+                             const sync_pb::DataTypeProgressMarker& progress);
 
-  scoped_refptr<FakeModelWorker> ui_worker() {
-    return ui_worker_;
-  }
+  scoped_refptr<FakeModelWorker> ui_worker() { return ui_worker_; }
 
   bool EntryExists(const std::string& id) {
     syncable::ReadTransaction trans(FROM_HERE, dir());
-    syncable::Entry e(&trans, syncable::GET_BY_ID,
-                      Id::CreateFromServerId(id));
+    syncable::Entry e(&trans, syncable::GET_BY_ID, Id::CreateFromServerId(id));
     return e.good() && !e.GetIsDel();
   }
 
   bool TypeRootExists(ModelType model_type) {
     return dir()->InitialSyncEndedForType(model_type);
   }
 
  protected:
   // Used in the construction of DirectoryTypeDebugInfoEmitters.
   base::ObserverList<TypeDebugInfoObserver> type_observers_;
@@ skipping 40 matching lines @@
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Add a bookmark item to the update message.
   std::string root = Id::GetRoot().GetServerId();
   Id server_id = Id::CreateFromServerId("b1");
   std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_originator_cache_guid(
-      std::string(kCacheGuid, arraysize(kCacheGuid)-1));
+      std::string(kCacheGuid, arraysize(kCacheGuid) - 1));
   Id client_id = Id::CreateFromClientString("-2");
   e->set_originator_client_item_id(client_id.GetServerId());
   e->set_position_in_parent(0);
 
   // Add it to the applicable updates list.
   SyncEntityList bookmark_updates;
   bookmark_updates.push_back(e.get());
 
   // Process the update.
   UpdateSyncEntities(&handler, bookmark_updates, &status);
@@ skipping 92 matching lines @@
 
   sync_pb::DataTypeProgressMarker saved;
   dir()->GetDownloadProgress(BOOKMARKS, &saved);
 
   EXPECT_EQ(progress.token(), saved.token());
   EXPECT_EQ(progress.data_type_id(), saved.data_type_id());
 }
 
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, GarbageCollectionByVersion) {
   DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
-  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
-                                 ui_worker(), &emitter);
+  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, ui_worker(),
+                                 &emitter);
   sessions::StatusController status;
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   context.set_context("context");
   context.set_version(1);
 
   std::unique_ptr<sync_pb::SyncEntity> e1 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")), "",
                    SYNCED_NOTIFICATIONS);
 
   std::unique_ptr<sync_pb::SyncEntity> e2 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")), "",
                    SYNCED_NOTIFICATIONS);
   e2->set_version(kDefaultVersion + 100);
 
   // Add to the applicable updates list.
   SyncEntityList updates;
   updates.push_back(e1.get());
   updates.push_back(e2.get());
 
   // Process and apply updates.
-  EXPECT_EQ(
-      SYNCER_OK,
-      handler.ProcessGetUpdatesResponse(progress, context, updates, &status));
+  EXPECT_EQ(SYNCER_OK, handler.ProcessGetUpdatesResponse(progress, context,
+                                                         updates, &status));
   handler.ApplyUpdates(&status);
 
   // Verify none is deleted because they are unapplied during GC.
   EXPECT_TRUE(TypeRootExists(SYNCED_NOTIFICATIONS));
   EXPECT_TRUE(EntryExists(e1->id_string()));
   EXPECT_TRUE(EntryExists(e2->id_string()));
 
   // Process and apply again. Old entry is deleted but not root.
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 20);
-  EXPECT_EQ(SYNCER_OK,
-            handler.ProcessGetUpdatesResponse(
-                progress, context, SyncEntityList(), &status));
+  EXPECT_EQ(SYNCER_OK, handler.ProcessGetUpdatesResponse(
+                           progress, context, SyncEntityList(), &status));
   handler.ApplyUpdates(&status);
   EXPECT_FALSE(EntryExists(e1->id_string()));
   EXPECT_TRUE(EntryExists(e2->id_string()));
 }
 
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ContextVersion) {
   DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
-  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
-                                 ui_worker(), &emitter);
+  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, ui_worker(),
+                                 &emitter);
   sessions::StatusController status;
   int field_number = GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS);
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
 
   sync_pb::DataTypeContext old_context;
   old_context.set_version(1);
   old_context.set_context("data");
   old_context.set_data_type_id(field_number);
 
   std::unique_ptr<sync_pb::SyncEntity> e1 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")), "",
                    SYNCED_NOTIFICATIONS);
 
   SyncEntityList updates;
   updates.push_back(e1.get());
 
   // The first response should be processed fine.
-  EXPECT_EQ(SYNCER_OK,
-            handler.ProcessGetUpdatesResponse(
-                progress, old_context, updates, &status));
+  EXPECT_EQ(SYNCER_OK, handler.ProcessGetUpdatesResponse(progress, old_context,
+                                                         updates, &status));
   handler.ApplyUpdates(&status);
 
   // The PREFERENCES root should be auto-created.
   EXPECT_TRUE(TypeRootExists(SYNCED_NOTIFICATIONS));
 
   EXPECT_TRUE(EntryExists(e1->id_string()));
 
   {
     sync_pb::DataTypeContext dir_context;
     syncable::ReadTransaction trans(FROM_HERE, dir());
-    trans.directory()->GetDataTypeContext(
-        &trans, SYNCED_NOTIFICATIONS, &dir_context);
+    trans.directory()->GetDataTypeContext(&trans, SYNCED_NOTIFICATIONS,
+                                          &dir_context);
     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
   }
 
   sync_pb::DataTypeContext new_context;
   new_context.set_version(0);
   new_context.set_context("old");
   new_context.set_data_type_id(field_number);
 
   std::unique_ptr<sync_pb::SyncEntity> e2 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")), "",
                    SYNCED_NOTIFICATIONS);
   updates.clear();
   updates.push_back(e2.get());
 
   // The second response, with an old context version, should result in an
   // error and the updates should be dropped.
   EXPECT_EQ(DATATYPE_TRIGGERED_RETRY,
-            handler.ProcessGetUpdatesResponse(
-                progress, new_context, updates, &status));
+            handler.ProcessGetUpdatesResponse(progress, new_context, updates,
+                                              &status));
   handler.ApplyUpdates(&status);
 
   EXPECT_FALSE(EntryExists(e2->id_string()));
 
   {
     sync_pb::DataTypeContext dir_context;
     syncable::ReadTransaction trans(FROM_HERE, dir());
-    trans.directory()->GetDataTypeContext(
-        &trans, SYNCED_NOTIFICATIONS, &dir_context);
+    trans.directory()->GetDataTypeContext(&trans, SYNCED_NOTIFICATIONS,
+                                          &dir_context);
     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
   }
 }
 
 // See that updates containing attachment metadata are applied
 // (i.e. server_attachment_metadata is copied to attachment_metadata).
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ProcessAndApplyUpdatesWithAttachments) {
   DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_);
   DirectoryUpdateHandler handler(dir(), ARTICLES, ui_worker(), &emitter);
@@ skipping 11 matching lines @@
 
   std::unique_ptr<sync_pb::SyncEntity> e1 = CreateUpdate(
       SyncableIdToProto(Id::CreateFromServerId("e1")), "", ARTICLES);
   sync_pb::AttachmentIdProto* attachment_id = e1->add_attachment_id();
   *attachment_id = CreateAttachmentIdProto(0, 0);
 
   SyncEntityList updates;
   updates.push_back(e1.get());
 
   // Process and apply updates.
-  EXPECT_EQ(
-      SYNCER_OK,
-      handler.ProcessGetUpdatesResponse(progress, context, updates, &status));
+  EXPECT_EQ(SYNCER_OK, handler.ProcessGetUpdatesResponse(progress, context,
+                                                         updates, &status));
   handler.ApplyUpdates(&status);
 
   ASSERT_TRUE(TypeRootExists(ARTICLES));
   ASSERT_TRUE(EntryExists(e1->id_string()));
   {
     syncable::ReadTransaction trans(FROM_HERE, dir());
-    syncable::Entry e(&trans,
-                      syncable::GET_BY_ID,
+    syncable::Entry e(&trans, syncable::GET_BY_ID,
                       Id::CreateFromServerId(e1->id_string()));
 
     // See that the attachment_metadata is correct.
     sync_pb::AttachmentMetadata attachment_metadata = e.GetAttachmentMetadata();
     ASSERT_EQ(1, attachment_metadata.record_size());
     ASSERT_EQ(attachment_id->SerializeAsString(),
               attachment_metadata.record(0).id().SerializeAsString());
     ASSERT_TRUE(attachment_metadata.record(0).is_on_server());
 
     // See that attachment_metadata and server_attachment_metadata are equal.
@@ skipping 93 matching lines @@
   }
 
   void ApplyPasswordUpdates(sessions::StatusController* status) {
     update_handler_map_.find(PASSWORDS)->second->ApplyUpdates(status);
   }
 
   void ApplyArticlesUpdates(sessions::StatusController* status) {
     update_handler_map_.find(ARTICLES)->second->ApplyUpdates(status);
   }
 
-  TestEntryFactory* entry_factory() {
-    return entry_factory_.get();
-  }
+  TestEntryFactory* entry_factory() { return entry_factory_.get(); }
 
-  syncable::Directory* directory() {
-    return dir_maker_.directory();
-  }
+  syncable::Directory* directory() { return dir_maker_.directory(); }
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   std::unique_ptr<TestEntryFactory> entry_factory_;
 
   scoped_refptr<FakeModelWorker> ui_worker_;
   scoped_refptr<FakeModelWorker> password_worker_;
   scoped_refptr<FakeModelWorker> passive_worker_;
 
@@ skipping 45 matching lines @@
     ASSERT_TRUE(child.good());
 
     EXPECT_FALSE(parent.GetIsUnsynced());
     EXPECT_FALSE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
     EXPECT_FALSE(child.GetIsUnappliedUpdate());
   }
 }
 
 // Test that the applicator can handle updates delivered out of order.
-TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
-       BookmarkChildrenBeforeParent) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkChildrenBeforeParent) {
   // Start with some bookmarks whose parents are unknown.
   std::string root_server_id = Id::GetRoot().GetServerId();
   int64_t a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
   int64_t x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
 
   // Update application will fail.
   sessions::StatusController status1;
   ApplyBookmarkUpdates(&status1);
@@ skipping 126 matching lines @@
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Re-parent from root to "Y"
     entry.PutServerVersion(entry_factory()->GetNextRevision());
     entry.PutIsUnappliedUpdate(true);
     entry.PutServerParentId(TestIdFactory::MakeServer("Y"));
   }
 
   // Item 'Y' is child of 'X'.
-  entry_factory()->CreateUnsyncedItem(
-      TestIdFactory::MakeServer("Y"), TestIdFactory::MakeServer("X"), "Y", true,
-      BOOKMARKS, NULL);
+  entry_factory()->CreateUnsyncedItem(TestIdFactory::MakeServer("Y"),
+                                      TestIdFactory::MakeServer("X"), "Y", true,
+                                      BOOKMARKS, NULL);
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
   // prevent the update from being applied and note that this is a hierarchy
   // conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   // This should count as a hierarchy conflict.
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Test update application where the update has been orphaned by a local folder
 // deletion.  The update application attempt should fail.
-TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
-       HierarchyConflictDeletedParent) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64_t parent_handle;
-  entry_factory()->CreateUnsyncedItem(
-      Id::CreateFromServerId("parent"), TestIdFactory::root(),
-      "parent", true, BOOKMARKS, &parent_handle);
+  entry_factory()->CreateUnsyncedItem(Id::CreateFromServerId("parent"),
+                                      TestIdFactory::root(), "parent", true,
+                                      BOOKMARKS, &parent_handle);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    syncable::MutableEntry entry(&trans,
-                                 syncable::GET_BY_HANDLE,
+    syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE,
                                  parent_handle);
     entry.PutIsDel(true);
   }
 
   // Create an incoming child from the server.
   int64_t child_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
   // The server's update may seem valid to some other client, but on this client
   // that new item's parent no longer exists.  The update should not be applied
@@ skipping 15 matching lines @@
 
 // Attempt to apply an update that deletes a folder where the folder has
 // locally-created children.  The update application should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted folder as a child of root node.
   int64_t parent_handle =
       entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    syncable::MutableEntry entry(&trans,
-                                 syncable::GET_BY_HANDLE,
+    syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE,
                                  parent_handle);
     ASSERT_TRUE(entry.good());
 
     // Delete it on the server.
     entry.PutServerVersion(entry_factory()->GetNextRevision());
     entry.PutIsUnappliedUpdate(true);
     entry.PutServerParentId(TestIdFactory::root());
     entry.PutServerIsDel(true);
   }
 
   // Create a local child of the server-deleted directory.
-  entry_factory()->CreateUnsyncedItem(
-      TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"),
-      "child", false, BOOKMARKS, NULL);
+  entry_factory()->CreateUnsyncedItem(TestIdFactory::MakeServer("child"),
+                                      TestIdFactory::MakeServer("parent"),
+                                      "child", false, BOOKMARKS, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   // This should count as a hierarchy conflict.
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
     ASSERT_TRUE(parent.good());
     EXPECT_TRUE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(parent.GetIsUnsynced());
   }
 }
 
 // Attempt to apply updates where the updated item's parent is not known to this
 // client.  The update application attempt should fail.
-TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
-       HierarchyConflictUnknownParent) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   int64_t x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64_t y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
@@ skipping 163 matching lines @@
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
       cryptographer = directory()->GetCryptographer(&trans);
 
       KeyParams params = {"localhost", "dummy", "foobar"};
       cryptographer->AddKey(params);
 
       cryptographer->Encrypt(data,
-          specifics.mutable_password()->mutable_encrypted());
+                             specifics.mutable_password()->mutable_encrypted());
     }
     decryptable_handle =
         entry_factory()->CreateUnappliedNewItem("item1", specifics, false);
   }
   {
     // Create a new cryptographer, independent of the one in the session.
     Cryptographer other_cryptographer(cryptographer->encryptor());
     KeyParams params = {"localhost", "dummy", "bazqux"};
     other_cryptographer.AddKey(params);
 
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/2");
 
-    other_cryptographer.Encrypt(data,
-        specifics.mutable_password()->mutable_encrypted());
+    other_cryptographer.Encrypt(
+        data, specifics.mutable_password()->mutable_encrypted());
     undecryptable_handle =
         entry_factory()->CreateUnappliedNewItem("item2", specifics, false);
   }
 
   sessions::StatusController status;
   ApplyPasswordUpdates(&status);
 
   const UpdateCounters& counters = GetPasswordsUpdateCounters();
   EXPECT_EQ(1, counters.num_encryption_conflict_application_failures)
       << "The updates that can't be decrypted should be in encryption "
@@ skipping 97 matching lines @@
   const UpdateCounters& counters = GetArticlesUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied);
   EXPECT_EQ(1, counters.num_local_overwrites);
   EXPECT_EQ(0, counters.num_server_overwrites);
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 }  // namespace syncer