Make sure sideload wipeout doesn't interfere with the tests.

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 93 matching lines @@
 using content::DOMStorageContext;
 using content::IndexedDBContext;
 using content::PluginService;
 using extensions::APIPermission;
 using extensions::APIPermissionSet;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionCreator;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionSystem;
+using extensions::FeatureSwitch;
 using extensions::PermissionSet;
 
 namespace keys = extension_manifest_keys;
 
 namespace {
 
 // Extension ids used during testing.
 const char* const all_zero = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const char* const zero_n_one = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab";
 const char* const good0 = "behllobkkfkfnphdnhnkndlbkcpglgmj";
@@ skipping 387 matching lines @@
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 class ExtensionServiceTest
   : public ExtensionServiceTestBase, public content::NotificationObserver {
  public:
   ExtensionServiceTest()
       : installed_(NULL),
         override_external_install_prompt_(
-            extensions::FeatureSwitch::prompt_for_external_extensions(),
-            false) {
+            FeatureSwitch::prompt_for_external_extensions(), false),
+        override_sideload_wipeout_(
+            FeatureSwitch::sideload_wipeout(), 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_;
+  FeatureSwitch::ScopedOverride override_external_install_prompt_;
+  FeatureSwitch::ScopedOverride override_sideload_wipeout_;
 
  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 4540 matching lines @@
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }
 
 #if ENABLE_EXTERNAL_INSTALL_UI
 // Test that installing an external extension displays a GlobalError.
 TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) {
-  extensions::FeatureSwitch::ScopedOverride prompt(
-      extensions::FeatureSwitch::prompt_for_external_extensions(), true);
+  FeatureSwitch::ScopedOverride prompt(
+      FeatureSwitch::prompt_for_external_extensions(), true);
 
   InitializeEmptyExtensionService();
   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.
   EXPECT_FALSE(extensions::HasExternalInstallError(service_));
@@ skipping 25 matching lines @@
                                  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);
+  FeatureSwitch::ScopedOverride prompt(
+      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);
+  FeatureSwitch::ScopedOverride prompt(
+      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  // ENABLE_EXTERNAL_INSTALL_UI