[Extensions] Add a developerPrivate.updateExtensionConfiguration function

chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc

 // Copyright 2015 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/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
@@ skipping 37 matching lines @@
 
   // A wrapper around extension_function_test_utils::RunFunction that runs with
   // the associated browser, no flags, and can take stack-allocated arguments.
   bool RunFunction(const scoped_refptr<UIThreadExtensionFunction>& function,
                    const base::ListValue& args);
 
   // Loads an unpacked extension that is backed by a real directory, allowing
   // it to be reloaded.
   const Extension* LoadUnpackedExtension();
 
-  // Tests a developer private function (T) that sets an extension pref, and
-  // verifies it with |has_pref|.
-  template<typename T>
+  // Tests setting various extension prefs.
   void TestExtensionPrefSetting(
-      bool (*has_pref)(const std::string&, content::BrowserContext*));
+      bool (*has_pref)(const std::string&, content::BrowserContext*),
+      api::developer_private::PermissionType permission,
+      bool require_user_gesture);
 
   testing::AssertionResult TestPackExtensionFunction(
       const base::ListValue& args,
       api::developer_private::PackStatus expected_status,
       int expected_flags);
 
   Browser* browser() { return browser_.get(); }
 
  private:
   // ExtensionServiceTestBase:
@@ skipping 17 matching lines @@
       make_scoped_ptr(args.DeepCopy()),
       browser(),
       extension_function_test_utils::NONE);
 }
 
 const Extension* DeveloperPrivateApiUnitTest::LoadUnpackedExtension() {
   const char kManifest[] =
       "{"
       " \"name\": \"foo\","
       " \"version\": \"1.0\","
-      " \"manifest_version\": 2"
+      " \"manifest_version\": 2,"
+      " \"permissions\": [\"*://*/*\"]"
       "}";
 
   test_extension_dirs_.push_back(new TestExtensionDir);
   TestExtensionDir* dir = test_extension_dirs_.back();
   dir->WriteManifest(kManifest);
 
   // TODO(devlin): We should extract out methods to load an unpacked extension
   // synchronously. We do it in ExtensionBrowserTest, but that's not helpful
   // for unittests.
   TestExtensionRegistryObserver registry_observer(registry());
   scoped_refptr<UnpackedInstaller> installer(
       UnpackedInstaller::Create(service()));
   installer->Load(dir->unpacked_path());
   base::FilePath extension_path =
       base::MakeAbsoluteFilePath(dir->unpacked_path());
   const Extension* extension = nullptr;
   do {
     extension = registry_observer.WaitForExtensionLoaded();
   } while (extension->path() != extension_path);
   // The fact that unpacked extensions get file access by default is an
   // irrelevant detail to these tests. Disable it.
   ExtensionPrefs::Get(browser_context())->SetAllowFileAccess(extension->id(),
                                                              false);
   return extension;
 }
 
-template<typename T>
 void DeveloperPrivateApiUnitTest::TestExtensionPrefSetting(
-    bool (*has_pref)(const std::string&, content::BrowserContext*)) {
+    bool (*has_pref)(const std::string&, content::BrowserContext*),
+    api::developer_private::PermissionType permission,
+    bool require_user_gesture) {
   // Sadly, we need a "real" directory here, because toggling incognito causes
   // a reload (which needs a path).
   std::string extension_id = LoadUnpackedExtension()->id();
 
-  scoped_refptr<UIThreadExtensionFunction> function(new T());
+  scoped_refptr<UIThreadExtensionFunction> function(
+      new api::DeveloperPrivateSetExtensionPermissionFunction());
 
-  base::ListValue enable_args;
-  enable_args.AppendString(extension_id);
-  enable_args.AppendBoolean(true);
+  std::string permission_string = api::developer_private::ToString(permission);
 
-  EXPECT_FALSE(has_pref(extension_id, profile()));
+  base::ListValue args;
+  base::DictionaryValue* parameters = new base::DictionaryValue();
+  parameters->SetString("extensionId", extension_id);
+  parameters->SetString("permission", permission_string);
+  parameters->SetBoolean("isActive", true);
+  args.Append(parameters);

[not at google - send to devlin, 2015/03/16 21:48:08]

consider using DictionaryBuilder 

[Devlin, 2015/03/16 22:41:37]

I did consider it, but this is shorter when we want to cache the DictionaryValue
pointer to modify it on line 163 :)

 
-  // Pref-setting should require a user action.
-  EXPECT_FALSE(RunFunction(function, enable_args));
-  EXPECT_EQ(std::string("This action requires a user gesture."),
-            function->GetError());
+  EXPECT_FALSE(has_pref(extension_id, profile())) << permission_string;
 
-  ExtensionFunction::ScopedUserGestureForTests scoped_user_gesture;
-  function = new T();
-  EXPECT_TRUE(RunFunction(function, enable_args));
-  EXPECT_TRUE(has_pref(extension_id, profile()));
+  scoped_ptr<ExtensionFunction::ScopedUserGestureForTests> scoped_user_gesture;
+  if (require_user_gesture) {
+    EXPECT_FALSE(RunFunction(function, args)) << permission_string;
+    EXPECT_EQ(std::string("This action requires a user gesture."),
+              function->GetError());
+    scoped_user_gesture.reset(
+        new ExtensionFunction::ScopedUserGestureForTests());
+    function = new api::DeveloperPrivateSetExtensionPermissionFunction();
+  }
 
-  base::ListValue disable_args;
-  disable_args.AppendString(extension_id);
-  disable_args.AppendBoolean(false);
-  function = new T();
-  EXPECT_TRUE(RunFunction(function, disable_args));
-  EXPECT_FALSE(has_pref(extension_id, profile()));
+  EXPECT_TRUE(RunFunction(function, args)) << permission_string;
+  EXPECT_TRUE(has_pref(extension_id, profile())) << permission_string;
+
+  parameters->SetBoolean("isActive", false);
+  function = new api::DeveloperPrivateSetExtensionPermissionFunction();
+  EXPECT_TRUE(RunFunction(function, args)) << permission_string;
+  EXPECT_FALSE(has_pref(extension_id, profile())) << permission_string;
 }
 
 testing::AssertionResult DeveloperPrivateApiUnitTest::TestPackExtensionFunction(
     const base::ListValue& args,
     api::developer_private::PackStatus expected_status,
     int expected_flags) {
   scoped_refptr<UIThreadExtensionFunction> function(
       new api::DeveloperPrivatePackDirectoryFunction());
   if (!RunFunction(function, args))
     return testing::AssertionFailure() << "Could not run function.";
@@ skipping 38 matching lines @@
       profile(), &BuildAPI);
 }
 
 void DeveloperPrivateApiUnitTest::TearDown() {
   test_extension_dirs_.clear();
   browser_.reset();
   browser_window_.reset();
   ExtensionServiceTestBase::TearDown();
 }
 
-// Test developerPrivate.allowIncognito.
-TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateAllowIncognito) {
-  TestExtensionPrefSetting<api::DeveloperPrivateAllowIncognitoFunction>(
-      &util::IsIncognitoEnabled);
+// Test developerPrivate.setExtensionPermission.
+TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateSetExtensionPermission) {
+  FeatureSwitch::ScopedOverride scripts_require_action(
+      FeatureSwitch::scripts_require_action(), true);
+  TestExtensionPrefSetting(
+      &util::IsIncognitoEnabled,
+      api::developer_private::PERMISSION_TYPE_INCOGNITO_ACCESS,
+      true);
+  TestExtensionPrefSetting(
+      &util::AllowFileAccess,
+      api::developer_private::PERMISSION_TYPE_FILE_ACCESS,
+      true);
+  TestExtensionPrefSetting(
+      &util::AllowedScriptingOnAllUrls,
+      api::developer_private::PERMISSION_TYPE_RUN_ON_ALL_URLS,
+      true);
 }
 
 // Test developerPrivate.reload.
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateReload) {
   const Extension* extension = LoadUnpackedExtension();
   std::string extension_id = extension->id();
   scoped_refptr<UIThreadExtensionFunction> function(
       new api::DeveloperPrivateReloadFunction());
   base::ListValue reload_args;
   reload_args.AppendString(extension_id);
 
   TestExtensionRegistryObserver registry_observer(registry());
   EXPECT_TRUE(RunFunction(function, reload_args));
   const Extension* unloaded_extension =
       registry_observer.WaitForExtensionUnloaded();
   EXPECT_EQ(extension, unloaded_extension);
   const Extension* reloaded_extension =
       registry_observer.WaitForExtensionLoaded();
   EXPECT_EQ(extension_id, reloaded_extension->id());
 }
 
-// Test developerPrivate.allowFileAccess.
-TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateAllowFileAccess) {
-  TestExtensionPrefSetting<api::DeveloperPrivateAllowFileAccessFunction>(
-      &util::AllowFileAccess);
-}
-
 // Test developerPrivate.packDirectory.
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivatePackFunction) {
   ResetThreadBundle(content::TestBrowserThreadBundle::DEFAULT);
 
   base::FilePath root_path = data_dir().AppendASCII("good_unpacked");
   base::FilePath crx_path = data_dir().AppendASCII("good_unpacked.crx");
   base::FilePath pem_path = data_dir().AppendASCII("good_unpacked.pem");
 
   // First, test a directory that should pack properly.
   base::ListValue pack_args;
@@ skipping 200 matching lines @@
   ASSERT_EQ(1u, results->GetSize());
   ASSERT_TRUE(results->GetList(0u, &list));
   ASSERT_EQ(1u, list->GetSize());
   ASSERT_TRUE(list->Get(0u, &value));
   scoped_ptr<api::developer_private::ItemInfo> item_info =
       api::developer_private::ItemInfo::FromValue(*value);
   ASSERT_TRUE(item_info);
 }
 
 }  // namespace extensions