[Extensions UI] Use developerPrivate API for profile configuration

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_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/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/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"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/app_window/app_window.h"
@@ skipping 38 matching lines @@
 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 kCannotUpdateSupervisedProfileSettingsError[] =
+    "Cannot change settings for a supervised profile.";
 
 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 69 matching lines @@
     LOG(ERROR) << "Attempt to change settings of an extension that is "
                << "non-usermanagable was made. Extension id : "
                << extension->id();
     *error = kCannotModifyPolicyExtensionError;
     return false;
   }
 
   return true;
 }
 
+// Runs the install verifier for all extensions that are enabled, disabled, or
+// terminated.
+void PerformVerificationCheck(content::BrowserContext* context) {
+  scoped_ptr<ExtensionSet> extensions =
+      ExtensionRegistry::Get(context)->GenerateInstalledExtensionsSet(
+          ExtensionRegistry::ENABLED |
+          ExtensionRegistry::DISABLED |
+          ExtensionRegistry::TERMINATED);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
+  bool should_do_verification_check = false;
+  for (const scoped_refptr<const Extension>& extension : *extensions) {
+    if (ui_util::ShouldDisplayInExtensionSettings(extension.get(), context) &&
+        ((prefs->GetDisableReasons(extension->id()) &
+             Extension::DISABLE_NOT_VERIFIED) != 0)) {
+      should_do_verification_check = true;
+      break;
+    }
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
+                        should_do_verification_check);
+  if (should_do_verification_check)
+    ExtensionSystem::Get(context)->install_verifier()->VerifyAllExtensions();
+}
+
 }  // namespace
 
 namespace ChoosePath = api::developer_private::ChoosePath;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<DeveloperPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 259 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_)));
 }
 
+DeveloperPrivateGetProfileConfigurationFunction::
+~DeveloperPrivateGetProfileConfigurationFunction() {
+}
+
+ExtensionFunction::ResponseAction
+DeveloperPrivateGetProfileConfigurationFunction::Run() {
+  developer::ProfileInfo info;
+  info.is_supervised = GetProfile()->IsSupervised();
+  info.is_incognito_available =
+      IncognitoModePrefs::GetAvailability(GetProfile()->GetPrefs()) !=
+          IncognitoModePrefs::DISABLED;
+  info.in_developer_mode =
+      !info.is_supervised &&
+      GetProfile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
+  info.app_info_dialog_enabled = CanShowAppInfoDialog();
+  info.can_load_unpacked =
+      !ExtensionManagementFactory::GetForBrowserContext(browser_context())
+          ->BlacklistedByDefault();
+
+  // If this is called from the chrome://extensions page, we use this as a
+  // heuristic that it's a good time to verify installs. We do this on startup,
+  // but there's a chance that it failed erroneously, so it's good to double-
+  // check.
+  if (source_context_type() == Feature::WEBUI_CONTEXT)
+    PerformVerificationCheck(browser_context());
+
+  return RespondNow(OneArgument(info.ToValue()));
+}
+
+DeveloperPrivateUpdateProfileConfigurationFunction::
+~DeveloperPrivateUpdateProfileConfigurationFunction() {
+}
+
+ExtensionFunction::ResponseAction
+DeveloperPrivateUpdateProfileConfigurationFunction::Run() {
+  scoped_ptr<developer::UpdateProfileConfiguration::Params> params(
+      developer::UpdateProfileConfiguration::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  const developer::ProfileConfigurationUpdate& update = params->update;
+  PrefService* prefs = GetProfile()->GetPrefs();
+  if (update.in_developer_mode) {
+    if (GetProfile()->IsSupervised())
+      return RespondNow(Error(kCannotUpdateSupervisedProfileSettingsError));
+    prefs->SetBoolean(prefs::kExtensionsUIDeveloperMode,
+                      *update.in_developer_mode);
+  }
+
+  return RespondNow(NoArguments());
+}
+
 DeveloperPrivateUpdateExtensionConfigurationFunction::
 ~DeveloperPrivateUpdateExtensionConfigurationFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateUpdateExtensionConfigurationFunction::Run() {
   scoped_ptr<developer::UpdateExtensionConfiguration::Params> params(
       developer::UpdateExtensionConfiguration::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const developer::ExtensionConfigurationUpdate& update = params->update;
@@ skipping 633 matching lines @@
   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;
     if (!extension)
       return RespondNow(Error(kNoSuchExtensionError));
 
-    Profile* profile = Profile::FromBrowserContext(browser_context());
+    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());
   }
 
   content::RenderViewHost* rvh =
       content::RenderViewHost::FromID(properties.render_process_id,
@@ skipping 41 matching lines @@
 ~DeveloperPrivateDeleteExtensionErrorsFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateDeleteExtensionErrorsFunction::Run() {
   scoped_ptr<developer::DeleteExtensionErrors::Params> params(
       developer::DeleteExtensionErrors::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::DeleteExtensionErrorsProperties& properties =
       params->properties;
 
-  ErrorConsole* error_console =
-      ErrorConsole::Get(Profile::FromBrowserContext(browser_context()));
+  ErrorConsole* error_console = ErrorConsole::Get(GetProfile());
   int type = -1;
   if (properties.type != developer::ERROR_TYPE_NONE) {
     type = properties.type == developer::ERROR_TYPE_MANIFEST ?
         ExtensionError::MANIFEST_ERROR : ExtensionError::RUNTIME_ERROR;
   }
   std::set<int> error_ids;
   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());
 }
 
 }  // namespace api
 
 }  // namespace extensions