[Extensions] Make chrome://extensions use api functions for file access, reload

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"
@@ skipping 72 matching lines @@
 
 using content::RenderViewHost;
 
 namespace extensions {
 
 namespace developer_private = api::developer_private;
 
 namespace {
 
 const char kNoSuchExtensionError[] = "No such extension.";
+const char kSupervisedUserError[] =
+    "Supervised users cannot modify extension settings.";
+const char kCannotModifyPolicyExtensionError[] =
+    "Cannot modify the extension by policy.";
+const char kRequiresUserGestureError[] =
+    "This action requires a user gesture.";
 
 const char kUnpackedAppsFolder[] = "apps_target";
 
-ExtensionService* GetExtensionService(Profile* profile) {
-  return ExtensionSystem::Get(profile)->extension_service();
+ExtensionService* GetExtensionService(content::BrowserContext* context) {
+  return ExtensionSystem::Get(context)->extension_service();
 }
 
 ExtensionUpdater* GetExtensionUpdater(Profile* profile) {
   return GetExtensionService(profile)->updater();
 }
 
 GURL GetImageURLFromData(const std::string& contents) {
   std::string contents_base64;
   base::Base64Encode(contents, &contents_base64);
 
@@ skipping 217 matching lines @@
   if (!EventRouter::Get(profile_)->HasEventListener(
           developer_private::OnItemStateChanged::kEventName)) {
     developer_private_event_router_.reset(NULL);
   } else {
     developer_private_event_router_->RemoveExtensionId(details.extension_id);
   }
 }
 
 namespace api {
 
+DeveloperPrivateAPIFunction::~DeveloperPrivateAPIFunction() {
+}
+
+const Extension* DeveloperPrivateAPIFunction::GetExtensionById(
+    const std::string& id) {
+  return ExtensionRegistry::Get(browser_context())->GetExtensionById(
+      id, ExtensionRegistry::EVERYTHING);
+}
+
 bool DeveloperPrivateAutoUpdateFunction::RunSync() {
   ExtensionUpdater* updater = GetExtensionUpdater(GetProfile());
   if (updater)
     updater->CheckNow(ExtensionUpdater::CheckParams());
   SetResult(new base::FundamentalValue(true));
   return true;
 }
 
 DeveloperPrivateAutoUpdateFunction::~DeveloperPrivateAutoUpdateFunction() {}
 
@@ skipping 318 matching lines @@
       base::Bind(&DeveloperPrivateGetItemsInfoFunction::GetIconsOnFileThread,
                  this,
                  item_list,
                  id_to_icon));
 
   return true;
 }
 
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
-bool DeveloperPrivateAllowFileAccessFunction::RunSync() {
+ExtensionFunction::ResponseAction
+DeveloperPrivateAllowFileAccessFunction::Run() {
   scoped_ptr<AllowFileAccess::Params> params(
       AllowFileAccess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  EXTENSION_FUNCTION_VALIDATE(user_gesture_);
+  const Extension* extension = GetExtensionById(params->extension_id);
 
-  ExtensionSystem* system = ExtensionSystem::Get(GetProfile());
-  ManagementPolicy* management_policy = system->management_policy();
-  const Extension* extension =
-      ExtensionRegistry::Get(GetProfile())
-          ->GetExtensionById(params->extension_id,
-                             ExtensionRegistry::EVERYTHING);
-  bool result = true;
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
 
-  if (!extension) {
-    result = false;
-  } else if (!management_policy->UserMayModifySettings(extension, NULL)) {
+  if (!user_gesture())
+    return RespondNow(Error(kRequiresUserGestureError));
+
+  if (util::IsExtensionSupervised(
+          extension, Profile::FromBrowserContext(browser_context()))) {
+    return RespondNow(Error(kSupervisedUserError));
+  }
+
+  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();
-    result = false;
-  } else {
-    util::SetAllowFileAccess(extension->id(), GetProfile(), params->allow);
-    result = true;
+    return RespondNow(Error(kCannotModifyPolicyExtensionError));
   }
 
-  return result;
+  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 =
-      ExtensionRegistry::Get(browser_context())
-          ->GetExtensionById(params->extension_id,
-                             ExtensionRegistry::EVERYTHING);
+  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() {}
 
-bool DeveloperPrivateReloadFunction::RunSync() {
+ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
   scoped_ptr<Reload::Params> params(Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  CHECK(!params->extension_id.empty());
-  ExtensionService* service = GetExtensionService(GetProfile());
-  service->ReloadExtension(params->extension_id);
-  return true;
+  const Extension* extension = GetExtensionById(params->extension_id);
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  bool fail_quietly = params->options && params->options->fail_quietly;
+
+  ExtensionService* service = GetExtensionService(browser_context());
+  if (fail_quietly)
+    service->ReloadExtensionWithQuietFailure(params->extension_id);
+  else
+    service->ReloadExtension(params->extension_id);
+
+  // TODO(devlin): We shouldn't return until the extension has finished trying
+  // to reload (and then we could also return the error).
+  return RespondNow(NoArguments());
 }
 
 bool DeveloperPrivateShowPermissionsDialogFunction::RunSync() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id_));
   CHECK(!extension_id_.empty());
   AppWindowRegistry* registry = AppWindowRegistry::Get(GetProfile());
   DCHECK(registry);
   AppWindow* app_window =
       registry->GetAppWindowForRenderViewHost(render_view_host());
   prompt_.reset(new ExtensionInstallPrompt(app_window->web_contents()));
@@ skipping 577 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0u, &dict));
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions