New post-sideload UI:

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 21 matching lines @@
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_error_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/external_install_ui.h"
 #include "chrome/browser/extensions/external_pref_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/external_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pack_extension_job.h"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/test_management_policy.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/plugins/plugin_prefs_factory.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/common/chrome_constants.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_l10n_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
+#include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/permissions/permission_set.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"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/indexed_db_context.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 431 matching lines @@
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 class ExtensionServiceTest
   : public ExtensionServiceTestBase, public content::NotificationObserver {
  public:
-  ExtensionServiceTest() : installed_(NULL) {
+  ExtensionServiceTest()
+      : installed_(NULL),
+        override_external_install_prompt_(
+            extensions::FeatureSwitch::prompt_for_external_extensions(),
+            false) {
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                    content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
@@ skipping 467 matching lines @@
          iter != value.end(); ++iter)
       list_value->Append(Value::CreateStringValue(*iter));
 
     SetPref(extension_id, pref_path, list_value, msg);
   }
 
  protected:
   extensions::ExtensionList loaded_;
   std::string unloaded_id_;
   const Extension* installed_;
+  extensions::FeatureSwitch::ScopedOverride override_external_install_prompt_;
 
  private:
   content::NotificationRegistrar registrar_;
 };
 
 // Receives notifications from a PackExtensionJob, indicating either that
 // packing succeeded or that there was some error.
 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
  public:
   PackExtensionTestClient(const FilePath& expected_crx_path,
@@ skipping 4537 matching lines @@
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, INSTALL_NEW);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }
 
-TEST_F(ExtensionServiceTest, AlertableExtensionHappyPath) {
+#if !defined(OS_CHROMEOS)
+// Test that installing an external extension displays a GlobalError.
+TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) {
+  extensions::FeatureSwitch::ScopedOverride prompt(
+      extensions::FeatureSwitch::prompt_for_external_extensions(), true);
+
   InitializeEmptyExtensionService();
-  scoped_ptr<ExtensionErrorUI> extension_error_ui(
-      ExtensionErrorUI::Create(service_));
   MockExtensionProvider* provider =
       new MockExtensionProvider(service_, Extension::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
 
+  service_->UpdateExternalExtensionAlert();
   // Should return false, meaning there aren't any extensions that the user
   // needs to know about.
-  ASSERT_FALSE(service_->PopulateExtensionErrorUI(extension_error_ui.get()));
+  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
 
   // This is a normal extension, installed normally.
   // This should NOT trigger an alert.
   set_extensions_enabled(true);
   FilePath path = data_dir_.AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
 
-  // Another normal extension, but installed externally.
-  // This SHOULD trigger an alert.
-  provider->UpdateOrAddExtension(page_action, "1.0.0.0",
-                                 data_dir_.AppendASCII("page_action.crx"));
+  service_->CheckForExternalUpdates();
+  loop_.RunAllPending();
+  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
 
   // A hosted app, installed externally.
   // This should NOT trigger an alert.
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
+  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
 
-  ASSERT_TRUE(service_->PopulateExtensionErrorUI(extension_error_ui.get()));
-  ASSERT_EQ(1u, extension_error_ui->get_external_extension_ids()->size());
+  // Another normal extension, but installed externally.
+  // This SHOULD trigger an alert.
+  provider->UpdateOrAddExtension(page_action, "1.0.0.0",
+                                 data_dir_.AppendASCII("page_action.crx"));
+
+  service_->CheckForExternalUpdates();
+  loop_.RunAllPending();
+  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
 }
+
+// Test that external extensions are initially disabled, and that enabling
+// them clears the prompt.
+TEST_F(ExtensionServiceTest, ExternalInstallInitiallyDisabled) {
+  extensions::FeatureSwitch::ScopedOverride prompt(
+      extensions::FeatureSwitch::prompt_for_external_extensions(), true);
+
+  InitializeEmptyExtensionService();
+  MockExtensionProvider* provider =
+      new MockExtensionProvider(service_, Extension::EXTERNAL_PREF);
+  AddMockExternalProvider(provider);
+
+  provider->UpdateOrAddExtension(page_action, "1.0.0.0",
+                                 data_dir_.AppendASCII("page_action.crx"));
+
+  service_->CheckForExternalUpdates();
+  loop_.RunAllPending();
+  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+  EXPECT_FALSE(service_->IsExtensionEnabled(page_action));
+
+  const Extension* extension =
+      service_->disabled_extensions()->GetByID(page_action);
+  EXPECT_TRUE(extension);
+  EXPECT_EQ(page_action, extension->id());
+
+  service_->EnableExtension(page_action);
+  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+  EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
+}
+
+// Test that installing multiple external extensions works.
+TEST_F(ExtensionServiceTest, ExternalInstallMultiple) {
+  extensions::FeatureSwitch::ScopedOverride prompt(
+      extensions::FeatureSwitch::prompt_for_external_extensions(), true);
+
+  InitializeEmptyExtensionService();
+  MockExtensionProvider* provider =
+      new MockExtensionProvider(service_, Extension::EXTERNAL_PREF);
+  AddMockExternalProvider(provider);
+
+  provider->UpdateOrAddExtension(page_action, "1.0.0.0",
+                                 data_dir_.AppendASCII("page_action.crx"));
+  provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
+                                 data_dir_.AppendASCII("good.crx"));
+  provider->UpdateOrAddExtension(theme_crx, "2.0",
+                                 data_dir_.AppendASCII("theme.crx"));
+
+  service_->CheckForExternalUpdates();
+  loop_.RunAllPending();
+  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+  EXPECT_FALSE(service_->IsExtensionEnabled(page_action));
+  EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_FALSE(service_->IsExtensionEnabled(theme_crx));
+
+  service_->EnableExtension(page_action);
+  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+  service_->EnableExtension(theme_crx);
+  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+  service_->EnableExtension(good_crx);
+  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+}
+#endif  // !defined(OS_CHROMEOS)