Apps/Extensions Sync refactoring -- delete most of the old glue, implement new sync API.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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 22 matching lines @@
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider_impl.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/external_pref_extension_loader.h"
 #include "chrome/browser/extensions/pack_extension_job.cc"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 3386 matching lines @@
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }
 
 namespace {
-
-bool AllExtensions(const Extension& extension) {
-  return true;
+  class TestSyncProcessorStub : public SyncChangeProcessor {
+    virtual SyncError ProcessSyncChanges(
+        const tracked_objects::Location& from_here,
+        const SyncChangeList& change_list) OVERRIDE {
+      return SyncError();
+    }
+  };
 }
 
-bool NoExtensions(const Extension& extension) {
-  return false;
-}
-
-bool ExtensionsOnly(const Extension& extension) {
-  return extension.GetType() == Extension::TYPE_EXTENSION;
-}
-
-bool ThemesOnly(const Extension& extension) {
-  return extension.is_theme();
-}
-
-bool GoodOnly(const Extension& extension) {
-  return extension.id() == good_crx;
-}
-
-}  // namespace
-
 TEST_F(ExtensionServiceTest, GetSyncData) {
   InitializeEmptyExtensionService();
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
-  ExtensionSyncData data;
-  EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
-  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);
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
+
+  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  ASSERT_EQ(list.size(), 1U);
+  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"), true);
   TerminateExtension(good_crx);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
-  ExtensionSyncData data;
-  EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
+
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
+
+  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  ASSERT_EQ(list.size(), 1U);
+  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"), true);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
-  ExtensionSyncData data;
-  EXPECT_FALSE(service_->GetSyncData(*extension, &ThemesOnly, &data));
+
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
+      &processor);
+
+  SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+  ASSERT_EQ(list.size(), 0U);
 }
 
 TEST_F(ExtensionServiceTest, GetSyncDataUserSettings) {
   InitializeEmptyExtensionService();
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   const Extension* extension = service_->GetInstalledExtension(good_crx);
   ASSERT_TRUE(extension);
 
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
+
   {
-    ExtensionSyncData data;
-    EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
-    EXPECT_TRUE(data.enabled);
-    EXPECT_FALSE(data.incognito_enabled);
+    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    ASSERT_EQ(list.size(), 1U);
+    ExtensionSyncData data(list[0]);
+    EXPECT_TRUE(data.enabled());
+    EXPECT_FALSE(data.incognito_enabled());
   }
 
   service_->DisableExtension(good_crx);
   {
-    ExtensionSyncData data;
-    EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
-    EXPECT_FALSE(data.enabled);
-    EXPECT_FALSE(data.incognito_enabled);
+    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    ASSERT_EQ(list.size(), 1U);
+    ExtensionSyncData data(list[0]);
+    EXPECT_FALSE(data.enabled());
+    EXPECT_FALSE(data.incognito_enabled());
   }
 
   service_->SetIsIncognitoEnabled(good_crx, true);
   {
-    ExtensionSyncData data;
-    EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
-    EXPECT_FALSE(data.enabled);
-    EXPECT_TRUE(data.incognito_enabled);
+    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    ASSERT_EQ(list.size(), 1U);
+    ExtensionSyncData data(list[0]);
+    EXPECT_FALSE(data.enabled());
+    EXPECT_TRUE(data.incognito_enabled());
   }
 
   service_->EnableExtension(good_crx);
   {
-    ExtensionSyncData data;
-    EXPECT_TRUE(service_->GetSyncData(*extension, &AllExtensions, &data));
-    EXPECT_TRUE(data.enabled);
-    EXPECT_TRUE(data.incognito_enabled);
+    SyncDataList list = service_->GetAllSyncData(syncable::EXTENSIONS);
+    ASSERT_EQ(list.size(), 1U);
+    ExtensionSyncData data(list[0]);
+    EXPECT_TRUE(data.enabled());
+    EXPECT_TRUE(data.incognito_enabled());
   }
 }
 
 TEST_F(ExtensionServiceTest, GetSyncDataList) {
   InitializeEmptyExtensionService();
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   InstallCrx(data_dir_.AppendASCII("page_action.crx"), true);
   InstallCrx(data_dir_.AppendASCII("theme.crx"), true);
   InstallCrx(data_dir_.AppendASCII("theme2.crx"), true);
 
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::APPS, SyncDataList(),
+      &processor);
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
+
   service_->DisableExtension(page_action);
   TerminateExtension(theme2_crx);
 
-  EXPECT_EQ(4u, service_->GetSyncDataList(&AllExtensions).size());
-  EXPECT_EQ(0u, service_->GetSyncDataList(&NoExtensions).size());
-  EXPECT_EQ(2u, service_->GetSyncDataList(&ExtensionsOnly).size());
-  EXPECT_EQ(2u, service_->GetSyncDataList(&ThemesOnly).size());
-  EXPECT_EQ(1u, service_->GetSyncDataList(&GoodOnly).size());
+  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(),
+      &processor);
 
-  ExtensionSyncData extension_sync_data;
-  extension_sync_data.id = good_crx;
-  extension_sync_data.uninstalled = true;
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics =
+      specifics.MutableExtension(sync_pb::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);
+  list[0] = sync_change;
 
   // Should do nothing.
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+  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, true);
   EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
 
   // Should uninstall the extension.
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+  service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
 
   // Should again do nothing.
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+  service_->ProcessSyncChanges(FROM_HERE, list);
+  EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
 }
 
-
 TEST_F(ExtensionServiceTest, ProcessSyncDataSettings) {
   InitializeEmptyExtensionService();
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
 
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
-  ExtensionSyncData extension_sync_data;
-  extension_sync_data.id = good_crx;
-  extension_sync_data.version =
-      *(service_->GetInstalledExtension(good_crx)->version());
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics =
+      specifics.MutableExtension(sync_pb::extension);
+  ext_specifics->set_id(good_crx);
+  ext_specifics->set_version(
+      service_->GetInstalledExtension(good_crx)->version()->GetString());
+  ext_specifics->set_enabled(false);
 
-  extension_sync_data.enabled = false;
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
-  EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
-  EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
+  {
+    SyncData sync_data = SyncData::CreateLocalData(good_crx, "Name", specifics);
+    SyncChange sync_change(SyncChange::ACTION_UPDATE, sync_data);
+    SyncChangeList list(1);
+    list[0] = sync_change;
+    service_->ProcessSyncChanges(FROM_HERE, list);
+    EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
+    EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
+  }
 
-  extension_sync_data.enabled = true;
-  extension_sync_data.incognito_enabled = true;
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
-  EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
-  EXPECT_TRUE(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);
+    list[0] = sync_change;
+    service_->ProcessSyncChanges(FROM_HERE, list);
+    EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
+    EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
+  }
 
-  extension_sync_data.enabled = false;
-  extension_sync_data.incognito_enabled = true;
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
-  EXPECT_FALSE(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);
+    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(),
+      &processor);
 
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   TerminateExtension(good_crx);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
-  ExtensionSyncData extension_sync_data;
-  extension_sync_data.id = good_crx;
-  extension_sync_data.version =
-      *(service_->GetInstalledExtension(good_crx)->version());
-  extension_sync_data.enabled = false;
-  extension_sync_data.incognito_enabled = true;
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics =
+      specifics.MutableExtension(sync_pb::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);
+  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();
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
 
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
 
-  ExtensionSyncData extension_sync_data;
-  extension_sync_data.id = good_crx;
-  extension_sync_data.enabled = true;
-  extension_sync_data.version =
-      *(service_->GetInstalledExtension(good_crx)->version());
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics =
+      specifics.MutableExtension(sync_pb::extension);
+  ext_specifics->set_id(good_crx);
+  ext_specifics->set_enabled(true);
 
-  // Should do nothing if extension version == sync version.
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
-  EXPECT_FALSE(service_->updater()->WillCheckSoon());
+  {
+    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);
+    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 ProcessSyncData).
+  // the TODO in ProcessExtensionSyncData).
   {
-    scoped_ptr<Version> version(Version::GetVersionFromString("0.0.0.0"));
-    extension_sync_data.version = *version;
-    service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+    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);
+    list[0] = sync_change;
+
+    service_->ProcessSyncChanges(FROM_HERE, list);
     EXPECT_FALSE(service_->updater()->WillCheckSoon());
   }
 
   // Should kick off an update if extension version < sync version.
   {
-    scoped_ptr<Version> version(Version::GetVersionFromString("9.9.9.9"));
-    extension_sync_data.version = *version;
-    service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+    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);
+    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();
+  TestSyncProcessorStub processor;
+  service_->MergeDataAndStartSyncing(syncable::EXTENSIONS, SyncDataList(),
+      &processor);
 
-  ExtensionSyncData extension_sync_data;
-  extension_sync_data.id = good_crx;
-  extension_sync_data.update_url = GURL("http://www.google.com");
-  extension_sync_data.enabled = false;
-  extension_sync_data.incognito_enabled = true;
-  {
-    scoped_ptr<Version> version(Version::GetVersionFromString("1.2.3.4"));
-    extension_sync_data.version = *version;
-  }
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics =
+      specifics.MutableExtension(sync_pb::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);
+  list[0] = sync_change;
+
 
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
-  service_->ProcessSyncData(extension_sync_data, &AllExtensions);
+  service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(service_->updater()->WillCheckSoon());
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
 
   PendingExtensionInfo info;
   EXPECT_TRUE(
       service_->pending_extension_manager()->GetById(good_crx, &info));
-  EXPECT_EQ(extension_sync_data.update_url, info.update_url());
+  EXPECT_EQ(ext_specifics->update_url(), info.update_url().spec());
   EXPECT_TRUE(info.is_from_sync());
   EXPECT_TRUE(info.install_silently());
   EXPECT_EQ(Extension::INTERNAL, info.install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 TEST_F(ExtensionServiceTest, HigherPriorityInstall) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
@@ skipping 164 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }