[Extensions] Merge developerPrivate.enable and management.setEnabled functions

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 145 matching lines @@
   scoped_ptr<Event> event(new Event(
       developer_private::OnItemStateChanged::kEventName, args.Pass()));
   EventRouter::Get(browser_context)->BroadcastEvent(event.Pass());
 }
 
 }  // namespace
 
 namespace AllowFileAccess = api::developer_private::AllowFileAccess;
 namespace AllowIncognito = api::developer_private::AllowIncognito;
 namespace ChoosePath = api::developer_private::ChoosePath;
-namespace Enable = api::developer_private::Enable;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace Inspect = api::developer_private::Inspect;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<DeveloperPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<DeveloperPrivateAPI>*
@@ skipping 613 matching lines @@
   SendResponse(true);
   Release();
 }
 
 DeveloperPrivateShowPermissionsDialogFunction::
     DeveloperPrivateShowPermissionsDialogFunction() {}
 
 DeveloperPrivateShowPermissionsDialogFunction::
     ~DeveloperPrivateShowPermissionsDialogFunction() {}
 
-DeveloperPrivateEnableFunction::DeveloperPrivateEnableFunction() {}
-
-bool DeveloperPrivateEnableFunction::RunSync() {
-  scoped_ptr<Enable::Params> params(Enable::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  const std::string& extension_id = params->item_id;
-
-  const Extension* extension =
-      ExtensionRegistry::Get(GetProfile())->GetExtensionById(
-          extension_id, ExtensionRegistry::EVERYTHING);
-  if (!extension) {
-    LOG(ERROR) << "Did not find extension with id " << extension_id;
-    return false;
-  }
-  ExtensionSystem* system = ExtensionSystem::Get(GetProfile());
-  ManagementPolicy* policy = system->management_policy();
-  bool enable = params->enable;
-  if (!policy->UserMayModifySettings(extension, nullptr) ||
-      (!enable && policy->MustRemainEnabled(extension, nullptr)) ||
-      (enable && policy->MustRemainDisabled(extension, nullptr, nullptr))) {
-    LOG(ERROR) << "Attempt to change enable state denied by management policy. "
-               << "Extension id: " << extension_id;
-    return false;
-  }
-
-  ExtensionService* service = system->extension_service();
-  if (enable) {
-    ExtensionPrefs* prefs = ExtensionPrefs::Get(GetProfile());
-    if (prefs->DidExtensionEscalatePermissions(extension_id)) {
-      // If the extension escalated permissions, we have to show a dialog.
-      content::WebContents* web_contents = GetSenderWebContents();
-      if (!web_contents)
-        return false;
-
-      ShowExtensionDisabledDialog(service, web_contents, extension);
-    } else if ((prefs->GetDisableReasons(extension_id) &
-                    Extension::DISABLE_UNSUPPORTED_REQUIREMENT)) {
-      // Recheck the requirements.
-      requirements_checker_.reset(new ChromeRequirementsChecker());
-      AddRef();  // Released in OnRequirementsChecked.
-      // TODO(devlin): Uh... asynchronous code in a sync extension function?
-      requirements_checker_->Check(
-          make_scoped_refptr(extension),
-          base::Bind(&DeveloperPrivateEnableFunction::OnRequirementsChecked,
-                     this, extension_id));
-    } else {
-      // Otherwise, we're good to re-enable the extension.
-      service->EnableExtension(extension_id);
-    }
-  } else {  // !enable (i.e., disable)
-    service->DisableExtension(extension_id, Extension::DISABLE_USER_ACTION);
-  }
-  return true;
-}
-
-void DeveloperPrivateEnableFunction::OnRequirementsChecked(
-    const std::string& extension_id,
-    const std::vector<std::string>& requirements_errors) {
-  if (requirements_errors.empty()) {
-    GetExtensionService(GetProfile())->EnableExtension(extension_id);
-  } else {
-    ExtensionErrorReporter::GetInstance()->ReportError(
-        base::UTF8ToUTF16(JoinString(requirements_errors, ' ')),
-        true);  // Be noisy.
-  }
-  Release();
-}
-
-DeveloperPrivateEnableFunction::~DeveloperPrivateEnableFunction() {}
-
 bool DeveloperPrivateInspectFunction::RunSync() {
   scoped_ptr<developer::Inspect::Params> params(
       developer::Inspect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const developer::InspectOptions& options = params->options;
 
   int render_process_id;
   base::StringToInt(options.render_process_id, &render_process_id);
 
   if (render_process_id == -1) {
@@ skipping 513 matching lines @@
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions