Disable extensions besides externally installed ones and themes.

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2009 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 <algorithm>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json_reader.h"
@@ skipping 113 matching lines @@
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_INSTALLED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::THEME_INSTALLED,
                    NotificationService::AllSources());
 
     profile_.reset(new TestingProfile());
     service_ = new ExtensionsService(profile_.get(), &loop_, &loop_);
-    service_->set_extensions_enabled(true);
+    service_->SetExtensionsEnabled(true);
     service_->set_show_extensions_prompts(false);
 
     // When we start up, we want to make sure there is no external provider,
     // since the ExtensionService on Windows will use the Registry as a default
     // provider and if there is something already registered there then it will
     // interfere with the tests. Those tests that need an external provider
     // will register one specifically.
     service_->ClearProvidersForTesting();
 
     total_successes_ = 0;
@@ skipping 39 matching lines @@
       case NotificationType::THEME_INSTALLED:
         installed_ = Details<Extension>(details).ptr();
         break;
 
       default:
         DCHECK(false);
     }
   }
 
   void SetExtensionsEnabled(bool enabled) {
-    service_->set_extensions_enabled(enabled);
+    service_->SetExtensionsEnabled(enabled);
   }
 
   void SetMockExternalProvider(Extension::Location location,
                                ExternalExtensionProvider* provider) {
     service_->SetProviderForTesting(location, provider);
   }
 
  protected:
   void InstallExtension(const FilePath& path,
                         bool should_succeed) {
@@ skipping 286 matching lines @@
   ValidatePrefKeyCount(pref_count);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 #if defined(OS_WIN)  // TODO(port)
 // Test Packaging and installing an extension.
 // TODO(rafaelw): add more tests for failure cases.
 TEST_F(ExtensionsServiceTest, PackExtension) {
-  SetExtensionsEnabled(true);
-
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path.AppendASCII("good")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
 
   FilePath output_directory;
   file_util::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_"),
       &output_directory);
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
@@ skipping 10 matching lines @@
   file_util::Delete(privkey_path, false);
 }
 
 // Test Packaging and installing an extension using an openssl generated key.
 // The openssl is generated with the following:
 // > openssl genrsa -out privkey.pem 1024
 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
 // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
 // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
 TEST_F(ExtensionsServiceTest, PackExtensionOpenSSLKey) {
-  SetExtensionsEnabled(true);
-
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path.AppendASCII("good")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
   FilePath privkey_path(extensions_path.AppendASCII(
       "openssl_privkey_asn1.pem"));
   ASSERT_TRUE(file_util::PathExists(privkey_path));
 
   FilePath output_directory;
@@ skipping 252 matching lines @@
   EXPECT_EQ(loaded_[1]->location(), Extension::LOAD);
 
   // --load-extension doesn't add entries to prefs
   ValidatePrefKeyCount(0);
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, ExternalInstallRegistry) {
+  // This should all work, even when normal extension installation is disabled.
+  SetExtensionsEnabled(false);
+
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* reg_provider =
       new MockExtensionProvider(Extension::EXTERNAL_REGISTRY);
   SetMockExternalProvider(Extension::EXTERNAL_REGISTRY, reg_provider);
 
@@ skipping 189 matching lines @@
 
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::KILLBIT);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // The extension should also be gone from disk.
   FilePath extension_path = install_path.DirName();
   extension_path = extension_path.AppendASCII(good_crx);
   EXPECT_FALSE(file_util::PathExists(extension_path)) <<
       extension_path.ToWStringHack();
+
+  // This shouldn't work if extensions are disabled.
+  SetExtensionsEnabled(false);
+
+  pref_provider->UpdateOrAddExtension(good_crx, "1.0", source_path);
+  service_->CheckForUpdates();
+  loop_.RunAllPending();
+
+  ASSERT_EQ(0u, loaded_.size());
+  ASSERT_EQ(1u, GetErrors().size());
 }