Don't block shared_module extensions by the policy blacklist.

chrome/browser/policy/policy_browsertest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/extensions/api/messaging/message_service.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_management_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/shared_module_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_cache_fake.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_stream_devices_controller.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/net/ssl_config_service_manager.h"
 #include "chrome/browser/net/url_request_mock_util.h"
@@ skipping 66 matching lines @@
 #include "content/public/common/process_type.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
 #include "content/public/test/mock_notification_observer.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_host.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/process_manager.h"
+#include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
+#include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/url_util.h"
 #include "net/http/http_stream_factory.h"
 #include "net/ssl/ssl_config.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
@@ skipping 1454 matching lines @@
   // AdBlock was automatically removed.
   ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true));
 
   // And can't be installed again, nor can good.crx.
   EXPECT_FALSE(InstallExtension(kAdBlockCrxName));
   EXPECT_FALSE(service->GetExtensionById(kAdBlockCrxId, true));
   EXPECT_FALSE(InstallExtension(kGoodCrxName));
   EXPECT_FALSE(service->GetExtensionById(kGoodCrxId, true));
 }
 
+IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallBlacklistSharedModules) {
+  // Verifies that shared_modules are not affected by the blacklist.
+
+  const char kImporterId[] = "pchakhniekfaeoddkifplhnfbffomabh";
+  const char kSharedModuleId[] = "nfgclafboonjbiafbllihiailjlhelpm";

[elijahtaylor1, 2014/10/22 16:40:01]

be careful if you are using a new ID that is not whitelisted to be a shared
module.  "export" is whitelisted for all extensions on dev, but only a handful
on stable.  I've gotten bitten by the windows official builder because it would
report "stable" or "beta" channel.  You can override the channel via a scoped
member variable for the class, but I forget the exact class name.

[Joao da Silva, 2014/10/22 18:31:05]

Thanks for the tip. I'll fake the channel.

+
+  // Verify that the extensions are not installed initially.
+  ExtensionService* service = extension_service();
+  ASSERT_FALSE(service->GetExtensionById(kImporterId, true));
+  ASSERT_FALSE(service->GetExtensionById(kSharedModuleId, true));
+
+  // Mock the webstore update URL. This is where the shared module extension
+  // will be installed from.
+  base::FilePath update_xml_path = base::FilePath(kTestExtensionsDir)
+                                       .Append("policy_shared_module")
+                                       .Append("update.xml");
+  GURL update_xml_url(URLRequestMockHTTPJob::GetMockUrl(update_xml_path));
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kAppsGalleryUpdateURL, update_xml_url.spec());
+  ui_test_utils::NavigateToURL(browser(), update_xml_url);
+
+  // Blacklist "*" but force-install the importer extension. The shared module
+  // should be automatically installed too.
+  base::ListValue blacklist;
+  blacklist.AppendString("*");
+  base::ListValue forcelist;
+  forcelist.AppendString(
+      base::StringPrintf("%s;%s", kImporterId, update_xml_url.spec().c_str()));
+  PolicyMap policies;
+  policies.Set(key::kExtensionInstallBlacklist, POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER, blacklist.DeepCopy(), NULL);
+  policies.Set(key::kExtensionInstallForcelist, POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER, forcelist.DeepCopy(), NULL);
+
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(browser()->profile());
+  extensions::TestExtensionRegistryObserver observe_importer(
+      registry, kImporterId);
+  extensions::TestExtensionRegistryObserver observe_shared_module(
+      registry, kSharedModuleId);
+  UpdateProviderPolicy(policies);
+  observe_importer.WaitForExtensionLoaded();
+  observe_shared_module.WaitForExtensionLoaded();
+
+  // Verify that both extensions got installed.
+  const extensions::Extension* importer =
+      service->GetExtensionById(kImporterId, true);
+  ASSERT_TRUE(importer);
+  EXPECT_EQ(kImporterId, importer->id());
+  const extensions::Extension* shared_module =
+      service->GetExtensionById(kSharedModuleId, true);
+  ASSERT_TRUE(shared_module);
+  EXPECT_EQ(kSharedModuleId, shared_module->id());
+  EXPECT_TRUE(shared_module->is_shared_module());
+
+  // Verify the dependency.
+  scoped_ptr<extensions::ExtensionSet> set =
+      service->shared_module_service()->GetDependentExtensions(shared_module);
+  ASSERT_TRUE(set);
+  EXPECT_EQ(1u, set->size());
+  EXPECT_TRUE(set->Contains(importer->id()));
+
+  std::vector<extensions::SharedModuleInfo::ImportInfo> imports =
+      extensions::SharedModuleInfo::GetImports(importer);
+  ASSERT_EQ(1u, imports.size());
+  EXPECT_EQ(kSharedModuleId, imports[0].extension_id);
+}
+
 IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionInstallWhitelist) {
   // Verifies that the whitelist can open exceptions to the blacklist.
   ExtensionService* service = extension_service();
   ASSERT_FALSE(service->GetExtensionById(kGoodCrxId, true));
   ASSERT_FALSE(service->GetExtensionById(kAdBlockCrxId, true));
   base::ListValue blacklist;
   blacklist.Append(new base::StringValue("*"));
   base::ListValue whitelist;
   whitelist.Append(new base::StringValue(kGoodCrxId));
   PolicyMap policies;
@@ skipping 1732 matching lines @@
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser2->tab_strip_model()->GetActiveWebContents(),
       "domAutomationController.send(window.showModalDialog !== undefined);",
       &result));
   EXPECT_TRUE(result);
 }
 
 #endif  // !defined(CHROME_OS)
 
 }  // namespace policy