[Extensions] Add a developerPrivate.updateExtensionConfiguration function

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

Index: chrome/browser/extensions/api/developer_private/developer_private_api.cc
diff --git a/chrome/browser/extensions/api/developer_private/developer_private_api.cc b/chrome/browser/extensions/api/developer_private/developer_private_api.cc
index 4d55e56bc09c21c44bfe9402d0af230f05a678a6..e04d7626b0d1dbe4dfec285823667d15f0795f65 100644
--- a/chrome/browser/extensions/api/developer_private/developer_private_api.cc
+++ b/chrome/browser/extensions/api/developer_private/developer_private_api.cc
@@ -17,6 +17,7 @@
 #include "chrome/browser/extensions/api/developer_private/developer_private_mangle.h"
 #include "chrome/browser/extensions/api/developer_private/entry_picker.h"
 #include "chrome/browser/extensions/api/developer_private/extension_info_generator.h"
+#include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/devtools_util.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ -165,10 +166,35 @@ std::string ReadFileToString(const base::FilePath& path) {
   return data;
 }
 
+bool UserCanModifyPermission(developer::PermissionType type,
+                             const Extension* extension,
+                             content::BrowserContext* browser_context,
+                             std::string* error) {
+  // Currently, we only gate file access modification on account permissions.
+  if (type != developer::PERMISSION_TYPE_FILE_ACCESS)
+    return true;
+
+  if (util::IsExtensionSupervised(
+          extension, Profile::FromBrowserContext(browser_context))) {
+    *error = kSupervisedUserError;
+    return false;
+  }
+
+  ManagementPolicy* management_policy =
+      ExtensionSystem::Get(browser_context)->management_policy();
+  if (!management_policy->UserMayModifySettings(extension, nullptr)) {
+    LOG(ERROR) << "Attempt to change allow file access of an extension that "
+               << "non-usermanagable was made. Extension id : "
+               << extension->id();
+    *error = kCannotModifyPolicyExtensionError;
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace
 
-namespace AllowFileAccess = api::developer_private::AllowFileAccess;
-namespace AllowIncognito = api::developer_private::AllowIncognito;
 namespace ChoosePath = api::developer_private::ChoosePath;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace Inspect = api::developer_private::Inspect;
@@ -406,10 +432,11 @@ DeveloperPrivateGetExtensionInfoFunction::Run() {
                   registry->terminated_extensions().GetByID(params->id)) !=
                   nullptr) {
     state = developer::EXTENSION_STATE_TERMINATED;
-  } else {
-    return RespondNow(Error(kNoSuchExtensionError));
   }
 
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
   return RespondNow(OneArgument(ExtensionInfoGenerator(browser_context()).
       CreateExtensionInfo(*extension, state)->ToValue().release()));
 }
@@ -481,65 +508,60 @@ void DeveloperPrivateGetItemsInfoFunction::Finish() {
   Respond(ArgumentList(developer::GetItemsInfo::Results::Create(item_list_)));
 }
 
-ExtensionFunction::ResponseAction
-DeveloperPrivateAllowFileAccessFunction::Run() {
-  scoped_ptr<AllowFileAccess::Params> params(
-      AllowFileAccess::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
+DeveloperPrivateSetExtensionPermissionFunction::
+~DeveloperPrivateSetExtensionPermissionFunction() {}
 
-  const Extension* extension = GetExtensionById(params->extension_id);
+ExtensionFunction::ResponseAction
+DeveloperPrivateSetExtensionPermissionFunction::Run() {
+  scoped_ptr<developer::SetExtensionPermission::Params> params(
+      developer::SetExtensionPermission::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+  const developer::SetPermissionProperties& properties = params->properties;
 
+  const Extension* extension = GetExtensionById(properties.extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
-
   if (!user_gesture())
     return RespondNow(Error(kRequiresUserGestureError));
 
-  if (util::IsExtensionSupervised(
-          extension, Profile::FromBrowserContext(browser_context()))) {
-    return RespondNow(Error(kSupervisedUserError));
+  std::string error;
+  if (!UserCanModifyPermission(properties.permission,
+                               extension,
+                               browser_context(),
+                               &error)) {
+    return RespondNow(Error(error));
   }
 
-  ManagementPolicy* management_policy =
-      ExtensionSystem::Get(browser_context())->management_policy();
-  if (!management_policy->UserMayModifySettings(extension, nullptr)) {
-    LOG(ERROR) << "Attempt to change allow file access of an extension that "
-               << "non-usermanagable was made. Extension id : "
-               << extension->id();
-    return RespondNow(Error(kCannotModifyPolicyExtensionError));
+  switch (properties.permission) {
+    case developer::PERMISSION_TYPE_FILE_ACCESS:
+      util::SetAllowFileAccess(
+          extension->id(), browser_context(), properties.is_active);
+      break;
+    case developer::PERMISSION_TYPE_INCOGNITO_ACCESS:
+      util::SetIsIncognitoEnabled(
+          extension->id(), browser_context(), properties.is_active);
+      break;
+    case developer::PERMISSION_TYPE_ERROR_COLLECTION:
+      ErrorConsole::Get(browser_context())->SetReportingAllForExtension(
+          extension->id(), properties.is_active);
+      break;
+    case developer::PERMISSION_TYPE_RUN_ON_ALL_URLS:
+      util::SetAllowedScriptingOnAllUrls(
+          extension->id(), browser_context(), properties.is_active);
+      break;
+    case developer::PERMISSION_TYPE_SHOW_ACTION_BUTTON:
+      ExtensionActionAPI::SetBrowserActionVisibility(
+          ExtensionPrefs::Get(browser_context()),
+          extension->id(),
+          properties.is_active);
+      break;
+    case developer::PERMISSION_TYPE_NONE:
+      NOTREACHED();
   }
 
-  util::SetAllowFileAccess(extension->id(), browser_context(), params->allow);
-  return RespondNow(NoArguments());
-}
-
-DeveloperPrivateAllowFileAccessFunction::
-    ~DeveloperPrivateAllowFileAccessFunction() {}
-
-ExtensionFunction::ResponseAction
-DeveloperPrivateAllowIncognitoFunction::Run() {
-  scoped_ptr<AllowIncognito::Params> params(
-      AllowIncognito::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  const Extension* extension = GetExtensionById(params->extension_id);
-
-  if (!extension)
-    return RespondNow(Error(kNoSuchExtensionError));
-
-  if (!user_gesture())
-    return RespondNow(Error(kRequiresUserGestureError));
-
-  // Should this take into account policy settings?
-  util::SetIsIncognitoEnabled(
-      extension->id(), browser_context(), params->allow);
-
   return RespondNow(NoArguments());
 }
 
-DeveloperPrivateAllowIncognitoFunction::
-    ~DeveloperPrivateAllowIncognitoFunction() {}
-
 ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
   scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());