Support remote installation of extensions and apps.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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 3003 matching lines @@
 
 }  // namespace
 
 // Test adding a pending extension.
 TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) {
   InitializeEmptyExtensionService();
 
   const std::string kFakeId(all_zero);
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const bool kFakeInstallSilently(true);
+  const bool kFakeRemoteInstall(false);
 
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      kFakeId, kFakeUpdateURL, &IsExtension,
-      kFakeInstallSilently));
+  EXPECT_TRUE(
+      service_->pending_extension_manager()->AddFromSync(kFakeId,
+                                                         kFakeUpdateURL,
+                                                         &IsExtension,
+                                                         kFakeInstallSilently,
+                                                         kFakeRemoteInstall));
 
   const extensions::PendingExtensionInfo* pending_extension_info;
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kFakeId)));
   EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
   EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
   EXPECT_EQ(kFakeInstallSilently, pending_extension_info->install_silently());
+  EXPECT_EQ(kFakeRemoteInstall, pending_extension_info->remote_install());
 }
 
 namespace {
 const char kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kGoodUpdateURL[] = "http://good.update/url";
 const bool kGoodIsFromSync = true;
 const bool kGoodInstallSilently = true;
+const bool kGoodRemoteInstall = false;
 }  // namespace
 
 // Test updating a pending extension.
 TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
   InitializeEmptyExtensionService();
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      kGoodId, GURL(kGoodUpdateURL), &IsExtension,
-      kGoodInstallSilently));
+  EXPECT_TRUE(
+      service_->pending_extension_manager()->AddFromSync(kGoodId,
+                                                         GURL(kGoodUpdateURL),
+                                                         &IsExtension,
+                                                         kGoodInstallSilently,
+                                                         kGoodRemoteInstall));
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   UpdateExtension(kGoodId, path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 
   const Extension* extension = service_->GetExtensionById(kGoodId, true);
   ASSERT_TRUE(extension);
 }
 
 namespace {
 
 bool IsTheme(const Extension* extension) {
   return extension->is_theme();
 }
 
 }  // namespace
 
 // Test updating a pending theme.
 // Disabled due to ASAN failure. http://crbug.com/108320
 TEST_F(ExtensionServiceTest, DISABLED_UpdatePendingTheme) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      theme_crx, GURL(), &IsTheme, false));
+      theme_crx, GURL(), &IsTheme, false, false));
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   base::FilePath path = data_dir_.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_TRUE(extension);
 
@@ skipping 38 matching lines @@
                                                     profile_.get()));
 }
 
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  The external update should overwrite a sync update,
 // but a sync update should not overwrite a non-sync update.
 TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
   InitializeEmptyExtensionService();
 
   // Add a crx to be installed from the update mechanism.
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      kGoodId, GURL(kGoodUpdateURL), &IsExtension,
-      kGoodInstallSilently));
+  EXPECT_TRUE(
+      service_->pending_extension_manager()->AddFromSync(kGoodId,
+                                                         GURL(kGoodUpdateURL),
+                                                         &IsExtension,
+                                                         kGoodInstallSilently,
+                                                         kGoodRemoteInstall));
 
   // Check that there is a pending crx, with is_from_sync set to true.
   const extensions::PendingExtensionInfo* pending_extension_info;
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_TRUE(pending_extension_info->is_from_sync());
 
   // Add a crx to be updated, with the same ID, from a non-sync source.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       kGoodId,
       std::string(),
       GURL(kGoodUpdateURL),
       Manifest::EXTERNAL_PREF_DOWNLOAD,
       Extension::NO_FLAGS,
       false));
 
   // Check that there is a pending crx, with is_from_sync set to false.
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_FALSE(pending_extension_info->is_from_sync());
   EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
             pending_extension_info->install_source());
 
   // Add a crx to be installed from the update mechanism.
-  EXPECT_FALSE(service_->pending_extension_manager()->AddFromSync(
-      kGoodId, GURL(kGoodUpdateURL), &IsExtension,
-      kGoodInstallSilently));
+  EXPECT_FALSE(
+      service_->pending_extension_manager()->AddFromSync(kGoodId,
+                                                         GURL(kGoodUpdateURL),
+                                                         &IsExtension,
+                                                         kGoodInstallSilently,
+                                                         kGoodRemoteInstall));
 
   // Check that the external, non-sync update was not overridden.
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_FALSE(pending_extension_info->is_from_sync());
   EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
             pending_extension_info->install_source());
 }
 
 // Updating a theme should fail if the updater is explicitly told that
 // the CRX is not a theme.
 TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      theme_crx, GURL(), &IsExtension, true));
+      theme_crx, GURL(), &IsExtension, true, false));
 
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   base::FilePath path = data_dir_.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, FAILED_SILENTLY);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_FALSE(extension);
 }
 
 // TODO(akalin): Test updating a pending extension non-silently once
 // we can mock out ExtensionInstallUI and inject our version into
 // UpdateExtension().
 
 // Test updating a pending extension which fails the should-install test.
 TEST_F(ExtensionServiceTest, UpdatePendingExtensionFailedShouldInstallTest) {
   InitializeEmptyExtensionService();
   // Add pending extension with a flipped is_theme.
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
-      kGoodId, GURL(kGoodUpdateURL), &IsTheme, kGoodInstallSilently));
+  EXPECT_TRUE(
+      service_->pending_extension_manager()->AddFromSync(kGoodId,
+                                                         GURL(kGoodUpdateURL),
+                                                         &IsTheme,
+                                                         kGoodInstallSilently,
+                                                         kGoodRemoteInstall));
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   UpdateExtension(kGoodId, path, UPDATED);
 
   // TODO(akalin): Figure out how to check that the extensions
   // directory is cleaned up properly in OnExtensionInstalled().
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 }
@@ skipping 26 matching lines @@
   service_->pending_extension_manager()->AddExtensionImpl(
       good->id(),
       std::string(),
       extensions::ManifestURL::GetUpdateURL(good),
       Version(),
       &IsExtension,
       kGoodIsFromSync,
       kGoodInstallSilently,
       Manifest::INTERNAL,
       Extension::NO_FLAGS,
-      false);
+      false,
+      kGoodRemoteInstall);
   UpdateExtension(good->id(), path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 }
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests blacklisting then unblacklisting extensions after the service has been
 // initialized.
 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
   extensions::TestBlacklist test_blacklist;
@@ skipping 2187 matching lines @@
 
   service_->Init();
   ASSERT_TRUE(service_->is_ready());
 
   ASSERT_EQ(3u, loaded_.size());
 
   // We start enabled.
   const Extension* extension = service_->GetExtensionById(good0, true);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(service_->IsExtensionEnabled(good0));
-  extensions::ExtensionSyncData disable_good_crx(*extension, false, false);
+  extensions::ExtensionSyncData disable_good_crx(
+      *extension, false, false, false);
 
   // Then sync data arrives telling us to disable |good0|.
   syncer::SyncDataList sync_data;
   sync_data.push_back(disable_good_crx.GetSyncData());
   extension_sync_service_->MergeDataAndStartSyncing(
       syncer::EXTENSIONS,
       sync_data,
       scoped_ptr<syncer::SyncChangeProcessor>(
           new syncer::FakeSyncChangeProcessor),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
@@ skipping 26 matching lines @@
   // Disable extension before first sync data arrives.
   service_->DisableExtension(good0, Extension::DISABLE_USER_ACTION);
   ASSERT_FALSE(service_->IsExtensionEnabled(good0));
 
   // Enable extension - this is now the most recent state.
   service_->EnableExtension(good0);
   ASSERT_TRUE(service_->IsExtensionEnabled(good0));
 
   // Now sync data comes in that says to disable good0. This should be
   // ignored.
-  extensions::ExtensionSyncData disable_good_crx(*extension, false, false);
+  extensions::ExtensionSyncData disable_good_crx(
+      *extension, false, false, false);
   syncer::SyncDataList sync_data;
   sync_data.push_back(disable_good_crx.GetSyncData());
   extension_sync_service_->MergeDataAndStartSyncing(
       syncer::EXTENSIONS,
       sync_data,
       scoped_ptr<syncer::SyncChangeProcessor>(
           new syncer::FakeSyncChangeProcessor),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // The extension was enabled locally before the sync data arrived, so it
@@ skipping 979 matching lines @@
     Version version("1.0.0.0");
 
     return service_->OnExternalExtensionFileFound(
         crx_id_, &version, crx_path_, Manifest::EXTERNAL_PREF,
         Extension::NO_FLAGS, false);
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service_->pending_extension_manager()->AddFromSync(
-        crx_id_, GURL(kGoodUpdateURL), &IsExtension, kGoodInstallSilently);
+        crx_id_,
+        GURL(kGoodUpdateURL),
+        &IsExtension,
+        kGoodInstallSilently,
+        kGoodRemoteInstall);
   }
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
     return service_->OnExternalExtensionUpdateUrlFound(
         crx_id_,
         std::string(),
         GURL(),
         Manifest::EXTERNAL_POLICY_DOWNLOAD,
@@ skipping 398 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             registry_->disabled_extensions().GetIDs());
 }