Communicate ExtensionSettings policy to renderers

chrome/browser/extensions/extension_management_unittest.cc

 // Copyright 2014 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_management.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 107 matching lines @@
     if (managed)
       pref_service_->RemoveManagedPref(path);
     else
       pref_service_->RemoveUserPref(path);
   }
 
   const internal::GlobalSettings* ReadGlobalSettings() {
     return extension_management_->global_settings_.get();
   }
 
-  const URLPatternSet& GetRuntimeBlockedHostsById(const std::string& id) {
-    return GetRuntimeBlockedHosts(id, kNonExistingUpdateUrl);
-  }
-
   ExtensionManagement::InstallationMode GetInstallationModeById(
       const std::string& id) {
     return GetInstallationMode(id, kNonExistingUpdateUrl);
   }
 
   ExtensionManagement::InstallationMode GetInstallationModeByUpdateUrl(
       const std::string& update_url) {
     return GetInstallationMode(kNonExistingExtension, update_url);
   }
 
@@ skipping 30 matching lines @@
   // Wrapper of ExtensionManagement::GetInstallationMode, |id| and
   // |update_url| are used to construct an Extension for testing.
   ExtensionManagement::InstallationMode GetInstallationMode(
       const std::string& id,
       const std::string& update_url) {
     scoped_refptr<const Extension> extension =
         CreateExtension(Manifest::UNPACKED, "0.1", id, update_url);
     return extension_management_->GetInstallationMode(extension.get());
   }
 
-  // Wrapper of ExtensionManagement::GetRuntimeBlockedHosts, |id| and
-  // |update_url| are used to construct an Extension for testing.
-  URLPatternSet GetRuntimeBlockedHosts(
-      const std::string& id,
-      const std::string& update_url) {
+  // Wrapper of ExtensionManagement::GetRuntimeBlockedHosts, |id| is used
+  // to construct an Extension for testing.
+  URLPatternSet GetRuntimeBlockedHosts(const std::string& id) {
     scoped_refptr<const Extension> extension =
-        CreateExtension(Manifest::UNPACKED, "0.1", id, update_url);
+        CreateExtension(Manifest::UNPACKED, "0.1", id, kNonExistingUpdateUrl);
     return extension_management_->GetRuntimeBlockedHosts(extension.get());
   }
 
   // Wrapper of ExtensionManagement::GetBlockedAPIPermissions, |id| and
   // |update_url| are used to construct an Extension for testing.
   APIPermissionSet GetBlockedAPIPermissions(const std::string& id,
                                             const std::string& update_url) {
     scoped_refptr<const Extension> extension =
         CreateExtension(Manifest::UNPACKED, "0.1", id, update_url);
     return extension_management_->GetBlockedAPIPermissions(extension.get());
@@ skipping 235 matching lines @@
   EXPECT_EQ(GetInstallationModeById(kTargetExtension2),
             ExtensionManagement::INSTALLATION_FORCED);
   CheckAutomaticallyInstalledUpdateUrl(kTargetExtension2, kExampleUpdateUrl);
   EXPECT_EQ(GetInstallationModeById(kTargetExtension3),
             ExtensionManagement::INSTALLATION_RECOMMENDED);
   CheckAutomaticallyInstalledUpdateUrl(kTargetExtension3, kExampleUpdateUrl);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
   EXPECT_EQ(GetInstallationModeByUpdateUrl(kExampleUpdateUrl),
             ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_TRUE(GetRuntimeBlockedHostsById(kTargetExtension).empty());
-  EXPECT_TRUE(GetRuntimeBlockedHostsById(kTargetExtension4)
+  EXPECT_TRUE(GetRuntimeBlockedHosts(kTargetExtension).is_empty());
+  EXPECT_TRUE(GetRuntimeBlockedHosts(kTargetExtension4)
                   .MatchesURL(GURL("http://test.foo.com/test")));
-  EXPECT_TRUE(GetRuntimeBlockedHostsById(kTargetExtension4)
+  EXPECT_TRUE(GetRuntimeBlockedHosts(kTargetExtension4)
                   .MatchesURL(GURL("https://bar.org/test")));
 
   // Verifies global settings.
   EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   const URLPatternSet& allowed_sites = ReadGlobalSettings()->install_sources;
   EXPECT_EQ(allowed_sites.size(), 1u);
   EXPECT_TRUE(allowed_sites.MatchesURL(GURL("http://foo.com/entry")));
   EXPECT_FALSE(allowed_sites.MatchesURL(GURL("http://bar.com/entry")));
-  EXPECT_TRUE(GetRuntimeBlockedHostsById(kNonExistingExtension)
+  EXPECT_TRUE(GetRuntimeBlockedHosts(kNonExistingExtension)
                   .MatchesURL(GURL("http://example.com/default")));
 
   EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
   const std::vector<Manifest::Type>& allowed_types =
       ReadGlobalSettings()->allowed_types;
   EXPECT_EQ(allowed_types.size(), 2u);
   EXPECT_TRUE(std::find(allowed_types.begin(),
                         allowed_types.end(),
                         Manifest::TYPE_THEME) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
@@ skipping 435 matching lines @@
   EXPECT_FALSE(error.empty());
 
   CreateExtension(Manifest::INTERNAL);
   error.clear();
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), NULL));
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), &error));
   EXPECT_TRUE(error.empty());
 }
 
 }  // namespace extensions