[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 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 556 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 =
+      ExtensionRegistry::Get(browser_context())
+          ->GetExtensionById(params->item_id, ExtensionRegistry::EVERYTHING);
 
-  ExtensionSystem* system = ExtensionSystem::Get(GetProfile());
-  ManagementPolicy* management_policy = system->management_policy();
-  const Extension* extension =
-      ExtensionRegistry::Get(GetProfile())
-          ->GetExtensionById(params->item_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));
+
+  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->item_id, ExtensionRegistry::EVERYTHING);
 
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
+  if (!user_gesture())

[not at google - send to devlin, 2015/02/26 00:56:47]

... drive by I guess?

[Devlin, 2015/02/26 01:14:03]

Yes. :)

+    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->item_id.empty());
-  ExtensionService* service = GetExtensionService(GetProfile());
-  service->ReloadExtension(params->item_id);
-  return true;
+  const Extension* extension =
+      ExtensionRegistry::Get(browser_context())
+          ->GetExtensionById(params->item_id, ExtensionRegistry::EVERYTHING);

[not at google - send to devlin, 2015/02/26 00:56:47]

Can we pull this huge 3-line "get me installed extension" into a member
function?

[Devlin, 2015/02/26 01:14:03]

Was meaning to do that for awhile. Done.

+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  // Default to failing "noisily".

[not at google - send to devlin, 2015/02/26 00:56:47]

comment unnecssary

[Devlin, 2015/02/26 01:14:03]

Done.

+  bool fail_quietly =
+      params->options.get() &&
+      params->options->fail_quietly.get() &&
+      *params->options->fail_quietly;
+
+  ExtensionService* service = GetExtensionService(browser_context());
+  if (fail_quietly)
+    service->ReloadExtensionWithQuietFailure(params->item_id);
+  else
+    service->ReloadExtension(params->item_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 651 matching lines @@
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions