[Sync] Move sessions/ to engine/cycle/ and rename things to match.

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 "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 "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/cycle/directory_type_debug_info_emitter.h"
+#include "components/sync/engine_impl/cycle/status_controller.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"
@@ skipping 27 matching lines @@
 
  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);
+                          StatusController* status);
 
   // Another function to access private member functions.
   void UpdateProgressMarkers(DirectoryUpdateHandler* handler,
                              const sync_pb::DataTypeProgressMarker& progress);
 
   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));
@@ skipping 24 matching lines @@
   e->set_non_unique_name(id);
   e->set_name(id);
   e->set_version(kDefaultVersion);
   AddDefaultFieldValue(type, e->mutable_specifics());
   return e;
 }
 
 void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
     DirectoryUpdateHandler* handler,
     const SyncEntityList& applicable_updates,
-    sessions::StatusController* status) {
+    StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir());
   handler->UpdateSyncEntities(&trans, applicable_updates, status);
 }
 
 void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
     DirectoryUpdateHandler* handler,
     const sync_pb::DataTypeProgressMarker& progress) {
   handler->UpdateProgressMarker(progress);
 }
 
 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
 
 // Test that the bookmark tag is set on newly downloaded items.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
-  sessions::StatusController status;
+  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));
   Id client_id = Id::CreateFromClientString("-2");
   e->set_originator_client_item_id(client_id.GetServerId());
@@ skipping 18 matching lines @@
   // intend to make such a change.
   EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag());
 }
 
 // Test the receipt of a type root node.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
-  sessions::StatusController status;
+  StatusController status;
 
   // Create an update that mimics the bookmark root.
   Id server_id = Id::CreateFromServerId("xyz");
   std::string root = Id::GetRoot().GetServerId();
   std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_server_defined_unique_tag("google_chrome_bookmarks");
   e->set_folder(true);
 
   // Add it to the applicable updates list.
@@ skipping 14 matching lines @@
   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Test the receipt of a non-bookmark item.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
   DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
-  sessions::StatusController status;
+  StatusController status;
 
   std::string root = Id::GetRoot().GetServerId();
   Id server_id = Id::CreateFromServerId("xyz");
   std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL);
   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
 
   // Add it to the applicable updates list.
   SyncEntityList autofill_updates;
   autofill_updates.push_back(e.get());
@@ skipping 28 matching lines @@
   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);
-  sessions::StatusController status;
+  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));
@@ skipping 30 matching lines @@
                            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);
-  sessions::StatusController status;
+  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");
@@ skipping 52 matching lines @@
     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);
-  sessions::StatusController status;
+  StatusController status;
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   context.set_context("context");
   context.set_version(1);
@@ skipping 29 matching lines @@
     ASSERT_EQ(attachment_metadata.SerializeAsString(),
               e.GetServerAttachmentMetadata().SerializeAsString());
   }
 }
 
 // Tests that IsInitialSyncEnded value is updated by ApplyUpdates, but not by
 // ProcessGetUpdatesResponse.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, IsInitialSyncEnded) {
   DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
-  sessions::StatusController status;
+  StatusController status;
 
   EXPECT_FALSE(handler.IsInitialSyncEnded());
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(AUTOFILL));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   std::unique_ptr<sync_pb::SyncEntity> e = CreateUpdate(
       SyncableIdToProto(Id::CreateFromServerId("e1")), "", AUTOFILL);
@@ skipping 60 matching lines @@
 
   const UpdateCounters& GetPasswordsUpdateCounters() {
     return passwords_emitter_.GetUpdateCounters();
   }
 
   const UpdateCounters& GetArticlesUpdateCounters() {
     return articles_emitter_.GetUpdateCounters();
   }
 
  protected:
-  void ApplyBookmarkUpdates(sessions::StatusController* status) {
+  void ApplyBookmarkUpdates(StatusController* status) {
     update_handler_map_.find(BOOKMARKS)->second->ApplyUpdates(status);
   }
 
-  void ApplyPasswordUpdates(sessions::StatusController* status) {
+  void ApplyPasswordUpdates(StatusController* status) {
     update_handler_map_.find(PASSWORDS)->second->ApplyUpdates(status);
   }
 
-  void ApplyArticlesUpdates(sessions::StatusController* status) {
+  void ApplyArticlesUpdates(StatusController* status) {
     update_handler_map_.find(ARTICLES)->second->ApplyUpdates(status);
   }
 
   TestEntryFactory* entry_factory() { return entry_factory_.get(); }
 
   syncable::Directory* directory() { return dir_maker_.directory(); }
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
@@ skipping 14 matching lines @@
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 }  // namespace
 
 // Test update application for a few bookmark items.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
-  sessions::StatusController status;
+  StatusController status;
 
   std::string root_server_id = Id::GetRoot().GetServerId();
   int64_t parent_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "parent", DefaultBookmarkSpecifics(), root_server_id);
   int64_t child_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "child", DefaultBookmarkSpecifics(), "parent");
 
   ApplyBookmarkUpdates(&status);
@@ skipping 25 matching lines @@
 // Test that the applicator can handle updates delivered out of order.
 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;
+  StatusController status1;
   ApplyBookmarkUpdates(&status1);
   EXPECT_EQ(0, status1.num_updates_applied());
   EXPECT_EQ(2, status1.num_hierarchy_conflicts());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle);
     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
 
     ASSERT_TRUE(a.good());
     ASSERT_TRUE(x.good());
 
     EXPECT_TRUE(a.GetIsUnappliedUpdate());
     EXPECT_TRUE(x.GetIsUnappliedUpdate());
   }
 
   // Now add their parent and a few siblings.
   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "parent", DefaultBookmarkSpecifics(), root_server_id);
   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_second", DefaultBookmarkSpecifics(), "parent");
   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_second", DefaultBookmarkSpecifics(), "parent");
 
   // Update application will succeed.
-  sessions::StatusController status2;
+  StatusController status2;
   ApplyBookmarkUpdates(&status2);
   EXPECT_EQ(5, status2.num_updates_applied())
       << "All updates should have been successfully applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle);
     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
 
@@ skipping 12 matching lines @@
 
   int original_server_version = -10;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     original_server_version = e.GetServerVersion();
     ASSERT_NE(original_server_version, e.GetBaseVersion());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(1, counters.num_server_overwrites)
       << "Unsynced and unapplied item conflict should be resolved";
   EXPECT_EQ(0, counters.num_updates_applied)
       << "Update should not be applied; we should override the server.";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 19 matching lines @@
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent"));
   }
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(0, counters.num_updates_applied);
   EXPECT_EQ(0, counters.num_server_overwrites);
   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
@@ skipping 26 matching lines @@
   // Item 'Y' is child of 'X'.
   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;
+  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());
@@ skipping 18 matching lines @@
   }
 
   // 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
   // and the update applicator should indicate this is a hierarchy conflict.
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
@@ skipping 21 matching lines @@
   }
 
   // Create a local child of the server-deleted directory.
   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;
+  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) {
   // 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;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "All updates with an unknown ancestors should be in conflict";
   EXPECT_EQ(0, counters.num_updates_applied)
       << "No item with an unknown ancestor should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 19 matching lines @@
       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
   int64_t u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64_t k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
   int64_t k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
   int64_t k4_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "The updates with unknown ancestors should be in conflict";
   EXPECT_EQ(4, counters.num_updates_applied)
       << "The updates with known ancestors should be successfully applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 34 matching lines @@
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PasswordSpecificsData data;
   data.set_origin("http://example.com");
 
   cryptographer->Encrypt(data,
                          specifics.mutable_password()->mutable_encrypted());
   int64_t handle =
       entry_factory()->CreateUnappliedNewItem("item", specifics, false);
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyPasswordUpdates(&status);
 
   const UpdateCounters& counters = GetPasswordsUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied)
       << "The updates that can be decrypted should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
@@ skipping 11 matching lines @@
   std::string root_server_id = Id::GetRoot().GetServerId();
   int64_t folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "folder", encrypted_bookmark, root_server_id);
   int64_t bookmark_handle = entry_factory()->CreateUnappliedNewItem(
       "item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
   int64_t password_handle = entry_factory()->CreateUnappliedNewItem(
       "item3", encrypted_password, false);
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyBookmarkUpdates(&status);
   ApplyPasswordUpdates(&status);
 
   const UpdateCounters& bm_counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, bm_counters.num_encryption_conflict_application_failures)
       << "Updates that can't be decrypted should be in encryption conflict";
   EXPECT_EQ(0, bm_counters.num_updates_applied)
       << "No update that can't be decrypted should be applied";
 
   const UpdateCounters& pw_counters = GetPasswordsUpdateCounters();
@@ skipping 35 matching lines @@
       KeyParams params = {"localhost", "dummy", "foobar"};
       cryptographer->AddKey(params);
 
       cryptographer->Encrypt(data,
                              specifics.mutable_password()->mutable_encrypted());
     }
     decryptable_handle =
         entry_factory()->CreateUnappliedNewItem("item1", specifics, false);
   }
   {
-    // Create a new cryptographer, independent of the one in the session.
+    // Create a new cryptographer, independent of the one in the cycle.
     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());
     undecryptable_handle =
         entry_factory()->CreateUnappliedNewItem("item2", specifics, false);
   }
 
-  sessions::StatusController status;
+  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 "
       << "conflict";
   EXPECT_EQ(1, counters.num_updates_applied)
       << "The undecryptable password update shouldn't be applied";
 
   {
@@ skipping 32 matching lines @@
   sync_pb::AttachmentMetadataRecord* server_record =
       server_metadata.add_record();
   *server_record->mutable_id() = server_attachment_id;
   server_record->set_is_on_server(true);
   entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata);
 
   // At this point we have a simple conflict.  The server says art1 should have
   // server_attachment_id, but the local sync engine says it should have
   // local_attachment_id.
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyArticlesUpdates(&status);
 
   // See that the server won.
   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());
@@ skipping 25 matching lines @@
   record = server_metadata.add_record();
   *record->mutable_id() = id2;
   record->set_is_on_server(true);
   record = local_metadata.add_record();
   *record->mutable_id() = id1;
   record->set_is_on_server(true);
   entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata);
 
   // At this point we have a (false) conflict.
 
-  sessions::StatusController status;
+  StatusController status;
   ApplyArticlesUpdates(&status);
 
   // See that the server won.
   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