[Sync] Put everything in sync/api into csync namespace

chrome/browser/extensions/extension_service_unittest.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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 4187 matching lines @@
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = (*service_->extensions()->begin())->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, (*service_->extensions()->begin())->id());
 }
 
 namespace {
-  class TestSyncProcessorStub : public SyncChangeProcessor {
-    virtual SyncError ProcessSyncChanges(
+  class TestSyncProcessorStub : public csync::SyncChangeProcessor {
+    virtual csync::SyncError ProcessSyncChanges(
         const tracked_objects::Location& from_here,
-        const SyncChangeList& change_list) OVERRIDE {
-      return SyncError();
+        const csync::SyncChangeList& change_list) OVERRIDE {
+      return csync::SyncError();
     }
   };
 }
 
 TEST_F(ExtensionServiceTest, GetSyncData) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
-  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
   ASSERT_EQ(list.size(), 1U);
-  extensions::ExtensionSyncData data(list[0]);
+  extensions::ExtensionSyncData  data(list[0]);
   EXPECT_EQ(extension->id(), data.id());
   EXPECT_FALSE(data.uninstalled());
   EXPECT_EQ(service_->IsExtensionEnabled(good_crx), data.enabled());
   EXPECT_EQ(service_->IsIncognitoEnabled(good_crx), data.incognito_enabled());
   EXPECT_TRUE(data.version().Equals(*extension->version()));
   EXPECT_EQ(extension->update_url(), data.update_url());
   EXPECT_EQ(extension->name(), data.name());
 }
 
 TEST_F(ExtensionServiceTest, GetSyncDataTerminated) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   TerminateExtension(good_crx);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
-  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
   ASSERT_EQ(list.size(), 1U);
-  extensions::ExtensionSyncData data(list[0]);
+  extensions::ExtensionSyncData  data(list[0]);
   EXPECT_EQ(extension->id(), data.id());
   EXPECT_FALSE(data.uninstalled());
   EXPECT_EQ(service_->IsExtensionEnabled(good_crx), data.enabled());
   EXPECT_EQ(service_->IsIncognitoEnabled(good_crx), data.incognito_enabled());
   EXPECT_TRUE(data.version().Equals(*extension->version()));
   EXPECT_EQ(extension->update_url(), data.update_url());
   EXPECT_EQ(extension->name(), data.name());
 }
 
 TEST_F(ExtensionServiceTest, GetSyncDataFilter) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(syncable::APPS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
-  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
   ASSERT_EQ(list.size(), 0U);
 }
 
 TEST_F(ExtensionServiceTest, GetSyncExtensionDataUserSettings) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    extensions::ExtensionSyncData data(list[0]);
+    extensions::ExtensionSyncData  data(list[0]);
     EXPECT_TRUE(data.enabled());
     EXPECT_FALSE(data.incognito_enabled());
   }
 
   service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    extensions::ExtensionSyncData data(list[0]);
+    extensions::ExtensionSyncData  data(list[0]);
     EXPECT_FALSE(data.enabled());
     EXPECT_FALSE(data.incognito_enabled());
   }
 
   service_->SetIsIncognitoEnabled(good_crx, true);
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    extensions::ExtensionSyncData data(list[0]);
+    extensions::ExtensionSyncData  data(list[0]);
     EXPECT_FALSE(data.enabled());
     EXPECT_TRUE(data.incognito_enabled());
   }
 
   service_->EnableExtension(good_crx);
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
     ASSERT_EQ(list.size(), 1U);
-    extensions::ExtensionSyncData data(list[0]);
+    extensions::ExtensionSyncData  data(list[0]);
     EXPECT_TRUE(data.enabled());
     EXPECT_TRUE(data.incognito_enabled());
   }
 }
 
 TEST_F(ExtensionServiceTest, SyncForUninstalledExternalExtension) {
   InitializeEmptyExtensionService();
   InstallCRXWithLocation(data_dir_.AppendASCII("good.crx"),
                          Extension::EXTERNAL_PREF, INSTALL_NEW);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   UninstallExtension(good_crx, false);
   EXPECT_TRUE(service_->IsExternalExtensionUninstalled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
   sync_pb::ExtensionSpecifics* extension_specifics =
       app_specifics->mutable_extension();
   extension_specifics->set_id(good_crx);
   extension_specifics->set_version("1.0");
   extension_specifics->set_enabled(true);
 
-  SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-  SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-  SyncChangeList list(1);
+  csync::SyncData sync_data =
+      csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+  csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+  csync::SyncChangeList list(1);
   list[0] = sync_change;
 
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(service_->IsExternalExtensionUninstalled(good_crx));
 }
 
 TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettings) {
   InitializeEmptyExtensionService();
   const Extension* app =
       PackAndInstallCRX(data_dir_.AppendASCII("app"), INSTALL_NEW);
   ASSERT_TRUE(app);
   ASSERT_TRUE(app->is_app());
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(syncable::APPS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   StringOrdinal initial_ordinal = StringOrdinal::CreateInitialOrdinal();
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::APPS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::APPS);
     ASSERT_EQ(list.size(), 1U);
 
     extensions::AppSyncData app_sync_data(list[0]);
     EXPECT_TRUE(initial_ordinal.Equal(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equal(app_sync_data.page_ordinal()));
   }
 
   ExtensionSorting* sorting = service_->extension_prefs()->extension_sorting();
   sorting->SetAppLaunchOrdinal(app->id(), initial_ordinal.CreateAfter());
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::APPS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::APPS);
     ASSERT_EQ(list.size(), 1U);
 
     extensions::AppSyncData app_sync_data(list[0]);
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equal(app_sync_data.page_ordinal()));
   }
 
   sorting->SetPageOrdinal(app->id(), initial_ordinal.CreateAfter());
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::APPS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::APPS);
     ASSERT_EQ(list.size(), 1U);
 
     extensions::AppSyncData app_sync_data(list[0]);
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.page_ordinal()));
   }
 }
 
 TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettingsOnExtensionMoved) {
   InitializeEmptyExtensionService();
   const size_t kAppCount = 3;
   const Extension* apps[kAppCount];
   apps[0] = PackAndInstallCRX(data_dir_.AppendASCII("app1"), INSTALL_NEW);
   apps[1] = PackAndInstallCRX(data_dir_.AppendASCII("app2"), INSTALL_NEW);
   apps[2] = PackAndInstallCRX(data_dir_.AppendASCII("app4"), INSTALL_NEW);
   for (size_t i = 0; i < kAppCount; ++i) {
     ASSERT_TRUE(apps[i]);
     ASSERT_TRUE(apps[i]->is_app());
   }
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(syncable::APPS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   service_->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
   {
-    SyncDataList list = service_->GetAllSyncData(syncable::APPS);
+    csync::SyncDataList list = service_->GetAllSyncData(syncable::APPS);
     ASSERT_EQ(list.size(), 3U);
 
     extensions::AppSyncData data[kAppCount];
     for (size_t i = 0; i < kAppCount; ++i)
     {
       data[i] = extensions::AppSyncData(list[i]);
     }
 
     // The sync data is not always in the same order our apps were installed in,
     // so we do that sorting here so we can make sure the values are changed as
@@ skipping 12 matching lines @@
 }
 
 TEST_F(ExtensionServiceTest, GetSyncDataList) {
   InitializeEmptyExtensionService();
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   InstallCRX(data_dir_.AppendASCII("page_action.crx"), INSTALL_NEW);
   InstallCRX(data_dir_.AppendASCII("theme.crx"), INSTALL_NEW);
   InstallCRX(data_dir_.AppendASCII("theme2.crx"), INSTALL_NEW);
 
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(syncable::APPS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   service_->DisableExtension(page_action, Extension::DISABLE_USER_ACTION);
   TerminateExtension(theme2_crx);
 
   EXPECT_EQ(0u, service_->GetAllSyncData(syncable::APPS).size());
   EXPECT_EQ(2u, service_->GetAllSyncData(syncable::EXTENSIONS).size());
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataUninstall) {
   InitializeEmptyExtensionService();
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version("1.0");
-  SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-  SyncChange sync_change(SyncChange::ACTION_DELETE, sync_data);
-  SyncChangeList list(1);
+  csync::SyncData sync_data =
+      csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+  csync::SyncChange sync_change(csync::SyncChange::ACTION_DELETE, sync_data);
+  csync::SyncChangeList list(1);
   list[0] = sync_change;
 
   // Should do nothing.
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
 
   // Install the extension.
   FilePath extension_path = data_dir_.AppendASCII("good.crx");
   InstallCRX(extension_path, INSTALL_NEW);
   EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
@@ skipping 18 matching lines @@
   sync_pb::EntitySpecifics specifics;
   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
   sync_pb::ExtensionSpecifics* extension_specifics =
       app_specifics->mutable_extension();
   extension_specifics->set_id(good_crx);
   extension_specifics->set_version(
       service_->GetInstalledExtension(good_crx)->version()->GetString());
 
   {
     extension_specifics->set_enabled(true);
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_DELETE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_DELETE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
 
     // Should do nothing
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
   }
 
   {
     extension_specifics->set_enabled(false);
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
 
     // Should again do nothing.
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
   }
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataSettings) {
   InitializeEmptyExtensionService();
   InitializeExtensionProcessManager();
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version(
       service_->GetInstalledExtension(good_crx)->version()->GetString());
   ext_specifics->set_enabled(false);
 
   {
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
     EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
   }
 
   {
     ext_specifics->set_enabled(true);
     ext_specifics->set_incognito_enabled(true);
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
     EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
   }
 
   {
     ext_specifics->set_enabled(false);
     ext_specifics->set_incognito_enabled(true);
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
     EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
   }
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataTerminatedExtension) {
   InitializeExtensionServiceWithUpdater();
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   TerminateExtension(good_crx);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version(
       service_->GetInstalledExtension(good_crx)->version()->GetString());
   ext_specifics->set_enabled(false);
   ext_specifics->set_incognito_enabled(true);
-  SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-  SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-  SyncChangeList list(1);
+  csync::SyncData sync_data =
+      csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+  csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+  csync::SyncChangeList list(1);
   list[0] = sync_change;
 
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataVersionCheck) {
   InitializeExtensionServiceWithUpdater();
   InitializeRequestContext();
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_enabled(true);
 
   {
     ext_specifics->set_version(
         service_->GetInstalledExtension(good_crx)->version()->GetString());
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
 
     // Should do nothing if extension version == sync version.
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service_->updater()->WillCheckSoon());
   }
 
   // Should do nothing if extension version > sync version (but see
   // the TODO in ProcessExtensionSyncData).
   {
     ext_specifics->set_version("0.0.0.0");
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
 
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service_->updater()->WillCheckSoon());
   }
 
   // Should kick off an update if extension version < sync version.
   {
     ext_specifics->set_version("9.9.9.9");
-    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-    SyncChangeList list(1);
+    csync::SyncData sync_data =
+        csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+    csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+    csync::SyncChangeList list(1);
     list[0] = sync_change;
 
     service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_TRUE(service_->updater()->WillCheckSoon());
   }
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataNotInstalled) {
   InitializeExtensionServiceWithUpdater();
   InitializeRequestContext();
   TestSyncProcessorStub processor;
-  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
-      scoped_ptr<SyncChangeProcessor>(new TestSyncProcessorStub),
-      scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock()));
+  service_->MergeDataAndStartSyncing(
+      syncable::EXTENSIONS, csync::SyncDataList(),
+      scoped_ptr<csync::SyncChangeProcessor>(new TestSyncProcessorStub),
+      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_enabled(false);
   ext_specifics->set_incognito_enabled(true);
   ext_specifics->set_update_url("http://www.google.com/");
   ext_specifics->set_version("1.2.3.4");
-  SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
-  SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
-  SyncChangeList list(1);
+  csync::SyncData sync_data =
+      csync::SyncData::CreateLocalData(good_crx, "Name", specifics);
+  csync::SyncChange sync_change(csync::SyncChange::ACTION_UPDATE, sync_data);
+  csync::SyncChangeList list(1);
   list[0] = sync_change;
 
 
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(service_->updater()->WillCheckSoon());
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
 
@@ skipping 473 matching lines @@
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_TRUE(service_->PopulateExtensionGlobalError(
       extension_global_error.get()));
   ASSERT_EQ(1u, extension_global_error->get_external_extension_ids()->size());
 }