[Extensions UI] Update extensions page to use api methods for permissions prompt

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/developer_private/show_permissions_dialog_helper.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"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
-#include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/file_highlighter.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/warning_service.h"
@@ skipping 28 matching lines @@
 const char kRequiresUserGestureError[] =
     "This action requires a user gesture.";
 const char kCouldNotShowSelectFileDialogError[] =
     "Could not show a file chooser.";
 const char kFileSelectionCanceled[] =
     "File selection was canceled.";
 const char kNoSuchRendererError[] = "No such renderer.";
 const char kInvalidPathError[] = "Invalid path.";
 const char kManifestKeyIsRequiredError[] =
     "The 'manifestKey' argument is required for manifest files.";
+const char kCouldNotFindWebContentsError[] =
+    "Could not find a valid web contents.";
 
 const char kUnpackedAppsFolder[] = "apps_target";
 const char kManifestFile[] = "manifest.json";
 
 ExtensionService* GetExtensionService(content::BrowserContext* context) {
   return ExtensionSystem::Get(context)->extension_service();
 }
 
 ExtensionUpdater* GetExtensionUpdater(Profile* profile) {
   return GetExtensionService(profile)->updater();
@@ skipping 432 matching lines @@
   // Should this take into account policy settings?
   util::SetIsIncognitoEnabled(
       extension->id(), browser_context(), params->allow);
 
   return RespondNow(NoArguments());
 }
 
 DeveloperPrivateAllowIncognitoFunction::
     ~DeveloperPrivateAllowIncognitoFunction() {}
 
+DeveloperPrivateReloadFunction::~DeveloperPrivateReloadFunction() {}
+
 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 &&
                       *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()));
-  const Extension* extension =
-      ExtensionRegistry::Get(GetProfile())
-          ->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING);
+DeveloperPrivateShowPermissionsDialogFunction::
+DeveloperPrivateShowPermissionsDialogFunction() {}
 
-  if (!extension)
-    return false;
+DeveloperPrivateShowPermissionsDialogFunction::
+~DeveloperPrivateShowPermissionsDialogFunction() {}
 
-  // Released by InstallUIAbort or InstallUIProceed.
-  AddRef();
-  std::vector<base::FilePath> retained_file_paths;
-  if (extension->permissions_data()->HasAPIPermission(
-          APIPermission::kFileSystem)) {
-    std::vector<apps::SavedFileEntry> retained_file_entries =
-        apps::SavedFilesService::Get(GetProfile())
-            ->GetAllFileEntries(extension_id_);
-    for (size_t i = 0; i < retained_file_entries.size(); i++) {
-      retained_file_paths.push_back(retained_file_entries[i].path);
-    }
-  }
-  std::vector<base::string16> retained_device_messages;
-  if (extension->permissions_data()->HasAPIPermission(APIPermission::kUsb)) {
-    retained_device_messages =
-        extensions::DevicePermissionsManager::Get(GetProfile())
-            ->GetPermissionMessageStrings(extension_id_);
-  }
-  prompt_->ReviewPermissions(
-      this, extension, retained_file_paths, retained_device_messages);
-  return true;
+ExtensionFunction::ResponseAction
+DeveloperPrivateShowPermissionsDialogFunction::Run() {
+  scoped_ptr<developer::ShowPermissionsDialog::Params> params(
+      developer::ShowPermissionsDialog::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  const Extension* target_extension = GetExtensionById(params->extension_id);
+  if (!target_extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  content::WebContents* web_contents = GetSenderWebContents();
+  if (!web_contents)
+    return RespondNow(Error(kCouldNotFindWebContentsError));
+
+  ShowPermissionsDialogHelper::Show(
+      browser_context(),
+      web_contents,
+      target_extension,
+      source_context_type() == Feature::WEBUI_CONTEXT,
+      base::Bind(&DeveloperPrivateShowPermissionsDialogFunction::Finish, this));
+  return RespondLater();
 }
 
-DeveloperPrivateReloadFunction::~DeveloperPrivateReloadFunction() {}
-
-// This is called when the user clicks "Revoke File Access."
-void DeveloperPrivateShowPermissionsDialogFunction::InstallUIProceed() {
-  Profile* profile = GetProfile();
-  extensions::DevicePermissionsManager::Get(profile)->Clear(extension_id_);
-  const Extension* extension = ExtensionRegistry::Get(
-      profile)->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING);
-  apps::SavedFilesService::Get(profile)->ClearQueue(extension);
-  apps::AppLoadService::Get(profile)
-      ->RestartApplicationIfRunning(extension_id_);
-  SendResponse(true);
-  Release();
+void DeveloperPrivateShowPermissionsDialogFunction::Finish() {
+  Respond(NoArguments());
 }
 
-void DeveloperPrivateShowPermissionsDialogFunction::InstallUIAbort(
-    bool user_initiated) {
-  SendResponse(true);
-  Release();
-}
-
-DeveloperPrivateShowPermissionsDialogFunction::
-    DeveloperPrivateShowPermissionsDialogFunction() {}
-
-DeveloperPrivateShowPermissionsDialogFunction::
-    ~DeveloperPrivateShowPermissionsDialogFunction() {}
-
 ExtensionFunction::ResponseAction DeveloperPrivateInspectFunction::Run() {
   scoped_ptr<developer::Inspect::Params> params(
       developer::Inspect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::InspectOptions& options = params->options;
 
   int render_process_id = 0;
   if (options.render_process_id.as_string &&
       !base::StringToInt(*options.render_process_id.as_string,
                          &render_process_id)) {
@@ skipping 614 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