[Extensions] Add a developerPrivate.updateExtensionConfiguration function

chrome/browser/extensions/api/developer_private/developer_private_api.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 "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/saved_files_service.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #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"
 #include "chrome/browser/extensions/extension_ui_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/shared_module_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ skipping 128 matching lines @@
       developer_private::OnItemStateChanged::kEventName, args.Pass()));
   EventRouter::Get(browser_context)->BroadcastEvent(event.Pass());
 }
 
 std::string ReadFileToString(const base::FilePath& path) {
   std::string data;
   ignore_result(base::ReadFileToString(path, &data));
   return data;
 }
 
+bool UserCanModifyExtensionConfiguration(
+    const Extension* extension,
+    content::BrowserContext* browser_context,
+    std::string* error) {
+  // Currently, we only gate file access modification on account permissions.
+  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;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<DeveloperPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
@@ skipping 217 matching lines @@
       registry->enabled_extensions().GetByID(params->id);
   if (!extension &&
       (extension = registry->disabled_extensions().GetByID(params->id)) !=
           nullptr) {
     state = developer::EXTENSION_STATE_DISABLED;
   } else if (!extension &&
              (extension =
                   registry->terminated_extensions().GetByID(params->id)) !=
                   nullptr) {
     state = developer::EXTENSION_STATE_TERMINATED;
-  } else {
+  }
+
+  if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
-  }
 
   return RespondNow(OneArgument(ExtensionInfoGenerator(browser_context()).
       CreateExtensionInfo(*extension, state)->ToValue().release()));
 }
 
 DeveloperPrivateGetItemsInfoFunction::DeveloperPrivateGetItemsInfoFunction() {}
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateGetItemsInfoFunction::Run() {
   scoped_ptr<developer::GetItemsInfo::Params> params(
@@ skipping 52 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DeveloperPrivateGetItemsInfoFunction::Finish, this));
 }
 
 void DeveloperPrivateGetItemsInfoFunction::Finish() {
   Respond(ArgumentList(developer::GetItemsInfo::Results::Create(item_list_)));
 }
 
+DeveloperPrivateUpdateExtensionConfigurationFunction::
+~DeveloperPrivateUpdateExtensionConfigurationFunction() {}
+
 ExtensionFunction::ResponseAction
-DeveloperPrivateAllowFileAccessFunction::Run() {
-  scoped_ptr<AllowFileAccess::Params> params(
-      AllowFileAccess::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
+DeveloperPrivateUpdateExtensionConfigurationFunction::Run() {
+  scoped_ptr<developer::UpdateExtensionConfiguration::Params> params(
+      developer::UpdateExtensionConfiguration::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
 
-  const Extension* extension = GetExtensionById(params->extension_id);
+  const developer::ExtensionConfigurationUpdate& update = params->update;
 
+  const Extension* extension = GetExtensionById(update.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));
+  if (update.file_access) {

[not at google - send to devlin, 2015/03/17 14:31:31]

I like it.

+    std::string error;
+    if (!UserCanModifyExtensionConfiguration(extension,
+                                             browser_context(),
+                                             &error)) {
+      return RespondNow(Error(error));
+    }
+    util::SetAllowFileAccess(
+        extension->id(), browser_context(), *update.file_access);
   }
-
-  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));
+  if (update.incognito_access) {
+    util::SetIsIncognitoEnabled(
+        extension->id(), browser_context(), *update.incognito_access);
   }
-
-  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);
+  if (update.error_collection) {
+    ErrorConsole::Get(browser_context())->SetReportingAllForExtension(
+        extension->id(), *update.error_collection);
+  }
+  if (update.run_on_all_urls) {
+    util::SetAllowedScriptingOnAllUrls(
+        extension->id(), browser_context(), *update.run_on_all_urls);
+  }
+  if (update.show_action_button) {
+    ExtensionActionAPI::SetBrowserActionVisibility(
+        ExtensionPrefs::Get(browser_context()),
+        extension->id(),
+        *update.show_action_button);
+  }
 
   return RespondNow(NoArguments());
 }
 
-DeveloperPrivateAllowIncognitoFunction::
-    ~DeveloperPrivateAllowIncognitoFunction() {}
-
 ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
   scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = GetExtensionById(params->extension_id);
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
   bool fail_quietly = params->options &&
                       params->options->fail_quietly &&
@@ skipping 702 matching lines @@
 
   TabStripModel* tab_strip = browser->tab_strip_model();
   tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(web_contents),
                            false);  // Not through direct user gesture.
   return RespondNow(NoArguments());
 }
 
 }  // namespace api
 
 }  // namespace extensions