Add ExtensionManagement based ExternalLoader

chrome/browser/extensions/api/management/management_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
-#include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
+#include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
+#include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
-#include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
+#include "components/policy/core/common/mock_configuration_policy_provider.h"
+#include "components/policy/core/common/policy_map.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/test/net/url_request_prepackaged_interceptor.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
-#include "extensions/browser/pref_names.h"
 #include "net/url_request/url_fetcher.h"
+#include "policy/policy_constants.h"
+#include "testing/gmock/include/gmock/gmock.h"
 
 using extensions::Extension;
 using extensions::ExtensionRegistry;
 using extensions::Manifest;
+using policy::PolicyMap;
+using testing::Return;
+using testing::_;
+
+namespace {
+
+std::string BuildForceInstallPolicyValue(const char* extension_id,
+                                         const char* update_url) {
+  return base::StringPrintf("%s;%s", extension_id, update_url);
+}
+
+}  // namespace
 
 class ExtensionManagementTest : public ExtensionBrowserTest {
+ public:
+  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+    EXPECT_CALL(policy_provider_, IsInitializationComplete(_))
+        .WillRepeatedly(Return(true));
+    policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
+        &policy_provider_);
+  }
+
  protected:
+  void UpdateProviderPolicy(const PolicyMap& policy) {
+    policy_provider_.UpdateChromePolicy(policy);
+    base::RunLoop().RunUntilIdle();
+  }
+
   // Helper method that returns whether the extension is at the given version.
   // This calls version(), which must be defined in the extension's bg page,
   // as well as asking the extension itself.
   //
   // Note that 'version' here means something different than the version field
   // in the extension's manifest. We use the version as reported by the
   // background page to test how overinstalling crx files with the same
   // manifest version works.
   bool IsExtensionAtVersion(const Extension* extension,
                             const std::string& expected_version) {
@@ skipping 14 matching lines @@
         ext_host->render_view_host(), "version()", &version_from_bg);
     EXPECT_TRUE(exec);
     if (!exec)
       return false;
 
     if (version_from_bg != expected_version ||
         extension->VersionString() != expected_version)
       return false;
     return true;
   }
+
+ private:
+  policy::MockConfigurationPolicyProvider policy_provider_;
 };
 
 #if defined(OS_LINUX)
 // Times out sometimes on Linux.  http://crbug.com/89727
 #define MAYBE_InstallSameVersion DISABLED_InstallSameVersion
 #else
 #define MAYBE_InstallSameVersion InstallSameVersion
 #endif
 
 // Tests that installing the same version overwrites.
@@ skipping 417 matching lines @@
   interceptor.SetResponseIgnoreQuery(
       GURL("http://localhost/autoupdate/manifest"),
       basedir.AppendASCII("manifest_v2.xml"));
   interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"),
                                      basedir.AppendASCII("v2.crx"));
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser()->profile());
   const size_t size_before = registry->enabled_extensions().size();
   ASSERT_TRUE(registry->disabled_extensions().is_empty());
 
-  PrefService* prefs = browser()->profile()->GetPrefs();
-  const base::DictionaryValue* forcelist =
-      prefs->GetDictionary(extensions::pref_names::kInstallForceList);
-  ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
+  ASSERT_TRUE(extensions::ExtensionManagementFactory::GetForBrowserContext(
+                  browser()->profile())
+                  ->GetForceInstallList()
+                  ->empty())
+      << kForceInstallNotEmptyHelp;
 
-  {
-    // Set the policy as a user preference and fire notification observers.
-    DictionaryPrefUpdate pref_update(prefs,
-                                     extensions::pref_names::kInstallForceList);
-    base::DictionaryValue* forcelist = pref_update.Get();
-    extensions::ExternalPolicyLoader::AddExtension(
-        forcelist, kExtensionId, "http://localhost/autoupdate/manifest");
-  }
+  base::ListValue forcelist;
+  forcelist.AppendString(BuildForceInstallPolicyValue(
+      kExtensionId, "http://localhost/autoupdate/manifest"));
+  PolicyMap policies;
+  policies.Set(policy::key::kExtensionInstallForcelist,
+               policy::POLICY_LEVEL_MANDATORY,
+               policy::POLICY_SCOPE_USER,
+               forcelist.DeepCopy(),
+               NULL);
+  UpdateProviderPolicy(policies);
 
   // Check if the extension got installed.
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, registry->enabled_extensions().size());
   const Extension* extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   ASSERT_EQ("2.0", extension->VersionString());
   EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location());
 
   // Try to disable and uninstall the extension which should fail.
   DisableExtension(kExtensionId);
   EXPECT_EQ(size_before + 1, registry->enabled_extensions().size());
   EXPECT_EQ(0u, registry->disabled_extensions().size());
   UninstallExtension(kExtensionId);
   EXPECT_EQ(size_before + 1, registry->enabled_extensions().size());
   EXPECT_EQ(0u, registry->disabled_extensions().size());
 
   // Now try to disable it through the management api, again failing.
   ExtensionTestMessageListener listener1("ready", false);
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("management/uninstall_extension")));
   ASSERT_TRUE(listener1.WaitUntilSatisfied());
   EXPECT_EQ(size_before + 2, registry->enabled_extensions().size());
   EXPECT_EQ(0u, registry->disabled_extensions().size());
 
   // Check that emptying the list triggers uninstall.
-  prefs->ClearPref(extensions::pref_names::kInstallForceList);
+  policies.Erase(policy::key::kExtensionInstallForcelist);
+  UpdateProviderPolicy(policies);
   EXPECT_EQ(size_before + 1, registry->enabled_extensions().size());
   EXPECT_FALSE(service->GetExtensionById(kExtensionId, true));
 }
 
 // See http://crbug.com/103371 and http://crbug.com/120640.
 #if defined(ADDRESS_SANITIZER) || defined(OS_WIN)
 #define MAYBE_PolicyOverridesUserInstall DISABLED_PolicyOverridesUserInstall
 #else
 #define MAYBE_PolicyOverridesUserInstall PolicyOverridesUserInstall
 #endif
@@ skipping 14 matching lines @@
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
   net::URLFetcher::SetEnableInterceptionForTests(true);
 
   interceptor.SetResponseIgnoreQuery(
       GURL("http://localhost/autoupdate/manifest"),
       basedir.AppendASCII("manifest_v2.xml"));
   interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"),
                                      basedir.AppendASCII("v2.crx"));
 
   // Check that the policy is initially empty.
-  PrefService* prefs = browser()->profile()->GetPrefs();
-  const base::DictionaryValue* forcelist =
-      prefs->GetDictionary(extensions::pref_names::kInstallForceList);
-  ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
+  ASSERT_TRUE(extensions::ExtensionManagementFactory::GetForBrowserContext(
+                  browser()->profile())
+                  ->GetForceInstallList()
+                  ->empty())
+      << kForceInstallNotEmptyHelp;
 
   // User install of the extension.
   ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
   ASSERT_EQ(size_before + 1, registry->enabled_extensions().size());
   const Extension* extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::INTERNAL, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
 
   // Setup the force install policy. It should override the location.
-  {
-    DictionaryPrefUpdate pref_update(prefs,
-                                     extensions::pref_names::kInstallForceList);
-    extensions::ExternalPolicyLoader::AddExtension(
-        pref_update.Get(), kExtensionId,
-        "http://localhost/autoupdate/manifest");
-  }
+  base::ListValue forcelist;
+  forcelist.AppendString(BuildForceInstallPolicyValue(
+      kExtensionId, "http://localhost/autoupdate/manifest"));
+  PolicyMap policies;
+  policies.Set(policy::key::kExtensionInstallForcelist,
+               policy::POLICY_LEVEL_MANDATORY,
+               policy::POLICY_SCOPE_USER,
+               forcelist.DeepCopy(),
+               NULL);
+  UpdateProviderPolicy(policies);
+
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, registry->enabled_extensions().size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
 
   // Remove the policy, and verify that the extension was uninstalled.
   // TODO(joaodasilva): it would be nicer if the extension was kept instead,
   // and reverted location to INTERNAL or whatever it was before the policy
   // was applied.
-  prefs->ClearPref(extensions::pref_names::kInstallForceList);
+  policies.Erase(policy::key::kExtensionInstallForcelist);
+  UpdateProviderPolicy(policies);
   ASSERT_EQ(size_before, registry->enabled_extensions().size());
   extension = service->GetExtensionById(kExtensionId, true);
   EXPECT_FALSE(extension);
 
   // User install again, but have it disabled too before setting the policy.
   ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
   ASSERT_EQ(size_before + 1, registry->enabled_extensions().size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::INTERNAL, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
   EXPECT_TRUE(registry->disabled_extensions().is_empty());
 
   DisableExtension(kExtensionId);
   EXPECT_EQ(1u, registry->disabled_extensions().size());
   extension = service->GetExtensionById(kExtensionId, true);
   EXPECT_TRUE(extension);
   EXPECT_FALSE(service->IsExtensionEnabled(kExtensionId));
 
   // Install the policy again. It should overwrite the extension's location,
   // and force enable it too.
-  {
-    DictionaryPrefUpdate pref_update(prefs,
-                                     extensions::pref_names::kInstallForceList);
-    base::DictionaryValue* forcelist = pref_update.Get();
-    extensions::ExternalPolicyLoader::AddExtension(
-        forcelist, kExtensionId, "http://localhost/autoupdate/manifest");
-  }
+  policies.Set(policy::key::kExtensionInstallForcelist,
+               policy::POLICY_LEVEL_MANDATORY,
+               policy::POLICY_SCOPE_USER,
+               forcelist.DeepCopy(),
+               NULL);
+  UpdateProviderPolicy(policies);
+
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, registry->enabled_extensions().size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
   EXPECT_TRUE(registry->disabled_extensions().is_empty());
 }