[Extensions UI] Use developerPrivate API for repair, options, show path

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 "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.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/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_tab_util.h"
 #include "chrome/browser/extensions/extension_ui_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/install_verifier.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/extensions/webstore_reinstaller.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/apps/app_info_dialog.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/extensions/app_launch_params.h"
+#include "chrome/browser/ui/extensions/application_launch.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/pref_names.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"
@@ skipping 11 matching lines @@
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/warning_service.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/install_warning.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
+#include "extensions/common/manifest_handlers/options_page_info.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/grit/extensions_browser_resources.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation.h"
 #include "storage/browser/fileapi/file_system_operation_runner.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
@@ skipping 13 matching lines @@
 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 kCannotUpdateSupervisedProfileSettingsError[] =
     "Cannot change settings for a supervised profile.";
+const char kNoOptionsPageForExtensionError[] =
+    "Extension does not have an options page.";
 
 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();
-}
-
 GURL GetImageURLFromData(const std::string& contents) {
   std::string contents_base64;
   base::Base64Encode(contents, &contents_base64);
 
   // TODO(dvh): make use of content::kDataScheme. Filed as crbug/297301.
   const char kDataURLPrefix[] = "data:;base64,";
   return GURL(kDataURLPrefix + contents_base64);
 }
 
 GURL GetDefaultImageURL(developer_private::ItemType type) {
@@ skipping 238 matching lines @@
 
 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;
+const Extension* DeveloperPrivateAPIFunction::GetEnabledExtensionById(
+    const std::string& id) {
+  return ExtensionRegistry::Get(browser_context())->enabled_extensions().
+      GetByID(id);
 }
 
 DeveloperPrivateAutoUpdateFunction::~DeveloperPrivateAutoUpdateFunction() {}
 
+ExtensionFunction::ResponseAction DeveloperPrivateAutoUpdateFunction::Run() {
+  ExtensionUpdater* updater =
+      ExtensionSystem::Get(browser_context())->extension_service()->updater();
+  if (updater) {
+    ExtensionUpdater::CheckParams params;
+    params.install_immediately = true;
+    updater->CheckNow(params);
+  }
+  return RespondNow(NoArguments());
+}
+
 DeveloperPrivateGetExtensionsInfoFunction::
 ~DeveloperPrivateGetExtensionsInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetExtensionsInfoFunction::Run() {
   scoped_ptr<developer::GetExtensionsInfo::Params> params(
       developer::GetExtensionsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
@@ skipping 792 matching lines @@
 ExtensionFunction::ResponseAction
 DeveloperPrivateOpenDevToolsFunction::Run() {
   scoped_ptr<developer::OpenDevTools::Params> params(
       developer::OpenDevTools::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::OpenDevToolsProperties& properties = params->properties;
 
   if (properties.render_process_id == -1) {
     // This is a lazy background page.
     const Extension* extension = properties.extension_id ?
-        ExtensionRegistry::Get(browser_context())->enabled_extensions().GetByID(
-            *properties.extension_id) : nullptr;
+        GetEnabledExtensionById(*properties.extension_id) : nullptr;
     if (!extension)
       return RespondNow(Error(kNoSuchExtensionError));
 
     Profile* profile = GetProfile();
     if (properties.incognito && *properties.incognito)
       profile = profile->GetOffTheRecordProfile();
 
     // Wakes up the background page and opens the inspect window.
     devtools_util::InspectBackgroundPage(extension, profile);
     return RespondNow(NoArguments());
@@ skipping 62 matching lines @@
   if (properties.error_ids) {
     error_ids.insert(properties.error_ids->begin(),
                      properties.error_ids->end());
   }
   error_console->RemoveErrors(ErrorMap::Filter(
       properties.extension_id, type, error_ids, false));
 
   return RespondNow(NoArguments());
 }
 
+DeveloperPrivateRepairExtensionFunction::
+~DeveloperPrivateRepairExtensionFunction() {}
+
+ExtensionFunction::ResponseAction
+DeveloperPrivateRepairExtensionFunction::Run() {
+  scoped_ptr<developer::RepairExtension::Params> params(
+      developer::RepairExtension::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+  const Extension* extension = GetExtensionById(params->extension_id);
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  content::WebContents* web_contents = GetSenderWebContents();
+  if (!web_contents)
+    return RespondNow(Error(kCouldNotFindWebContentsError));
+
+  scoped_refptr<WebstoreReinstaller> reinstaller(new WebstoreReinstaller(
+      web_contents,
+      params->extension_id,
+      base::Bind(&DeveloperPrivateRepairExtensionFunction::OnReinstallComplete,
+                 this)));
+  reinstaller->BeginReinstall();
+
+  return RespondLater();
+}
+
+void DeveloperPrivateRepairExtensionFunction::OnReinstallComplete(
+    bool success,
+    const std::string& error,
+    webstore_install::Result result) {
+  Respond(success ? NoArguments() : Error(error));
+}
+
+DeveloperPrivateShowOptionsFunction::~DeveloperPrivateShowOptionsFunction() {}
+
+ExtensionFunction::ResponseAction DeveloperPrivateShowOptionsFunction::Run() {
+  scoped_ptr<developer::ShowOptions::Params> params(
+      developer::ShowOptions::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+  const Extension* extension = GetEnabledExtensionById(params->extension_id);
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  if (OptionsPageInfo::GetOptionsPage(extension).is_empty())
+    return RespondNow(Error(kNoOptionsPageForExtensionError));
+
+  content::WebContents* web_contents = GetSenderWebContents();
+  if (!web_contents)
+    return RespondNow(Error(kCouldNotFindWebContentsError));
+
+  ExtensionTabUtil::OpenOptionsPage(
+      extension,
+      chrome::FindBrowserWithWebContents(web_contents));
+  return RespondNow(NoArguments());
+}
+
+DeveloperPrivateShowPathFunction::~DeveloperPrivateShowPathFunction() {}
+
+ExtensionFunction::ResponseAction DeveloperPrivateShowPathFunction::Run() {
+  scoped_ptr<developer::ShowPath::Params> params(
+      developer::ShowPath::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+  const Extension* extension = GetExtensionById(params->extension_id);
+  if (!extension)
+    return RespondNow(Error(kNoSuchExtensionError));
+
+  // We explicitly show manifest.json in order to work around an issue in OSX
+  // where opening the directory doesn't focus the Finder.
+  platform_util::ShowItemInFolder(GetProfile(),
+                                  extension->path().Append(kManifestFilename));
+  return RespondNow(NoArguments());
+}
+
 }  // namespace api
 
 }  // namespace extensions