Revert 110264 - Fix for management API related to escalated permissions disabled extensions

chrome/browser/extensions/extension_management_api.cc

 // Copyright (c) 2011 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/extension_management_api.h"
 
 #include <map>
 #include <string>
 
+#include "base/bind.h"
 #include "base/basictypes.h"
-#include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_event_router.h"
-#include "chrome/browser/extensions/extension_management_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/webui/extension_icon_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 using base::IntToString;
 using content::BrowserThread;
+namespace events = extension_event_names;
 
-namespace events = extension_event_names;
-namespace keys = extension_management_api_constants;
+namespace {
+
+const char kAppLaunchUrlKey[] = "appLaunchUrl";
+const char kDescriptionKey[] = "description";
+const char kEnabledKey[] = "enabled";
+const char kHomepageUrlKey[] = "homepageUrl";
+const char kIconsKey[] = "icons";
+const char kIdKey[] = "id";
+const char kIsAppKey[] = "isApp";
+const char kNameKey[] = "name";
+const char kOfflineEnabledKey[] = "offlineEnabled";
+const char kOptionsUrlKey[] = "optionsUrl";
+const char kPermissionsKey[] = "permissions";
+const char kMayDisableKey[] = "mayDisable";
+const char kSizeKey[] = "size";
+const char kUpdateUrlKey[] = "updateUrl";
+const char kUrlKey[] = "url";
+const char kVersionKey[] = "version";
+
+const char kExtensionCreateError[] =
+    "Failed to create extension from manifest.";
+const char kManifestParseError[] = "Failed to parse manifest.";
+const char kNoExtensionError[] = "Failed to find extension with id *";
+const char kNotAnAppError[] = "Extension * is not an App";
+const char kUserCantDisableError[] = "Extension * can not be disabled by user";
+}
 
 ExtensionService* ExtensionManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
-ExtensionService* AsyncExtensionManagementFunction::service() {
-  return profile()->GetExtensionService();
-}
-
 static DictionaryValue* CreateExtensionInfo(const Extension& extension,
-                                            bool enabled,
-                                            bool permissions_escalated) {
+                                            bool enabled) {
   DictionaryValue* info = new DictionaryValue();
-  info->SetString(keys::kIdKey, extension.id());
-  info->SetBoolean(keys::kIsAppKey, extension.is_app());
-  info->SetString(keys::kNameKey, extension.name());
-  info->SetBoolean(keys::kEnabledKey, enabled);
-  if (!enabled) {
-    const char* reason = permissions_escalated ?
-        keys::kDisabledReasonPermissionsIncrease : keys::kDisabledReasonUnknown;
-    info->SetString(keys::kDisabledReasonKey, reason);
+  info->SetString(kIdKey, extension.id());
+  info->SetBoolean(kIsAppKey, extension.is_app());
+  info->SetString(kNameKey, extension.name());
+  info->SetBoolean(kEnabledKey, enabled);
+  info->SetBoolean(kMayDisableKey,
+                   Extension::UserMayDisable(extension.location()));
+  info->SetBoolean(kOfflineEnabledKey, extension.offline_enabled());
+  info->SetString(kVersionKey, extension.VersionString());
+  info->SetString(kDescriptionKey, extension.description());
+  info->SetString(kOptionsUrlKey,
+                  extension.options_url().possibly_invalid_spec());
+  info->SetString(kHomepageUrlKey,
+                  extension.GetHomepageURL().possibly_invalid_spec());
+  if (!extension.update_url().is_empty()) {
+    info->SetString(kUpdateUrlKey,
+                    extension.update_url().possibly_invalid_spec());
   }
-  info->SetBoolean(keys::kMayDisableKey,
-                   Extension::UserMayDisable(extension.location()));
-  info->SetBoolean(keys::kOfflineEnabledKey, extension.offline_enabled());
-  info->SetString(keys::kVersionKey, extension.VersionString());
-  info->SetString(keys::kDescriptionKey, extension.description());
-  info->SetString(keys::kOptionsUrlKey,
-                  extension.options_url().possibly_invalid_spec());
-  info->SetString(keys::kHomepageUrlKey,
-                  extension.GetHomepageURL().possibly_invalid_spec());
-  if (!extension.update_url().is_empty())
-    info->SetString(keys::kUpdateUrlKey,
-                    extension.update_url().possibly_invalid_spec());
   if (extension.is_app())
-    info->SetString(keys::kAppLaunchUrlKey,
+    info->SetString(kAppLaunchUrlKey,
                     extension.GetFullLaunchURL().possibly_invalid_spec());
 
   const ExtensionIconSet::IconMap& icons = extension.icons().map();
   if (!icons.empty()) {
     ListValue* icon_list = new ListValue();
     std::map<int, std::string>::const_iterator icon_iter;
     for (icon_iter = icons.begin(); icon_iter != icons.end(); ++icon_iter) {
       DictionaryValue* icon_info = new DictionaryValue();
       Extension::Icons size = static_cast<Extension::Icons>(icon_iter->first);
       GURL url = ExtensionIconSource::GetIconURL(
           &extension, size, ExtensionIconSet::MATCH_EXACTLY, false, NULL);
-      icon_info->SetInteger(keys::kSizeKey, icon_iter->first);
-      icon_info->SetString(keys::kUrlKey, url.spec());
+      icon_info->SetInteger(kSizeKey, icon_iter->first);
+      icon_info->SetString(kUrlKey, url.spec());
       icon_list->Append(icon_info);
     }
     info->Set("icons", icon_list);
   }
 
   const std::set<std::string> perms =
       extension.GetActivePermissions()->GetAPIsAsStrings();
   ListValue* permission_list = new ListValue();
   if (!perms.empty()) {
     std::set<std::string>::const_iterator perms_iter;
@@ skipping 19 matching lines @@
       }
     }
   }
   info->Set("hostPermissions", host_permission_list);
 
   return info;
 }
 
 static void AddExtensionInfo(ListValue* list,
                              const ExtensionList& extensions,
-                             bool enabled,
-                             ExtensionPrefs* prefs) {
+                             bool enabled) {
   for (ExtensionList::const_iterator i = extensions.begin();
        i != extensions.end(); ++i) {
     const Extension& extension = **i;
 
     if (extension.location() == Extension::COMPONENT)
       continue;  // Skip built-in extensions.
 
-    bool escalated =
-        prefs->DidExtensionEscalatePermissions(extension.id());
-    list->Append(CreateExtensionInfo(extension, enabled, escalated));
+    list->Append(CreateExtensionInfo(extension, enabled));
   }
 }
 
 bool GetAllExtensionsFunction::RunImpl() {
   ListValue* result = new ListValue();
   result_.reset(result);
 
-  ExtensionPrefs* prefs = service()->extension_prefs();
-  AddExtensionInfo(result, *service()->extensions(), true, prefs);
-  AddExtensionInfo(
-      result, *service()->disabled_extensions(), false, prefs);
+  AddExtensionInfo(result, *service()->extensions(), true);
+  AddExtensionInfo(result, *service()->disabled_extensions(), false);
 
   return true;
 }
 
 bool GetExtensionByIdFunction::RunImpl() {
   std::string extension_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
   const Extension* extension = service()->GetExtensionById(extension_id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNoExtensionError,
                                                      extension_id);
     return false;
   }
   bool enabled = service()->IsExtensionEnabled(extension_id);
-  ExtensionPrefs* prefs = service()->extension_prefs();
-  bool escalated = prefs->DidExtensionEscalatePermissions(extension_id);
-  DictionaryValue* result = CreateExtensionInfo(*extension, enabled, escalated);
+  DictionaryValue* result = CreateExtensionInfo(*extension, enabled);
   result_.reset(result);
 
   return true;
 }
 
 bool GetPermissionWarningsByIdFunction::RunImpl() {
   std::string ext_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &ext_id));
 
   const Extension* extension = service()->GetExtensionById(ext_id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNoExtensionError,
                                                        ext_id);
     return false;
   }
 
   ExtensionPermissionMessages warnings = extension->GetPermissionMessages();
   ListValue* result = new ListValue();
   for (ExtensionPermissionMessages::const_iterator i = warnings.begin();
        i < warnings.end(); ++i)
     result->Append(Value::CreateStringValue(i->message()));
   result_.reset(result);
@@ skipping 38 matching lines @@
     return handled;
   }
 
   void OnJSONParseSucceeded(const ListValue& wrapper) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     Value* value = NULL;
     CHECK(wrapper.Get(0, &value));
     if (value->IsType(Value::TYPE_DICTIONARY))
       parsed_manifest_.reset(static_cast<DictionaryValue*>(value)->DeepCopy());
     else
-      error_ = keys::kManifestParseError;
+      error_ = kManifestParseError;
 
     utility_host_ = NULL; // has already deleted itself
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::ReportResultFromUIThread, this));
   }
 
   void OnJSONParseFailed(const std::string& error) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 47 matching lines @@
 }
 
 void GetPermissionWarningsByManifestFunction::OnParseSuccess(
     DictionaryValue* parsed_manifest) {
   CHECK(parsed_manifest);
 
   scoped_refptr<Extension> extension = Extension::Create(
       FilePath(), Extension::INVALID, *parsed_manifest,
       Extension::STRICT_ERROR_CHECKS, &error_);
   if (!extension.get()) {
-    OnParseFailure(keys::kExtensionCreateError);
+    OnParseFailure(kExtensionCreateError);
     return;
   }
 
   ExtensionPermissionMessages warnings = extension->GetPermissionMessages();
   ListValue* result = new ListValue();
   for (ExtensionPermissionMessages::const_iterator i = warnings.begin();
        i < warnings.end(); ++i)
     result->Append(Value::CreateStringValue(i->message()));
   result_.reset(result);
   SendResponse(true);
 
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
 void GetPermissionWarningsByManifestFunction::OnParseFailure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
 bool LaunchAppFunction::RunImpl() {
   std::string extension_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
   const Extension* extension = service()->GetExtensionById(extension_id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNoExtensionError,
                                                      extension_id);
     return false;
   }
   if (!extension->is_app()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNotAnAppError,
+    error_ = ExtensionErrorUtils::FormatErrorMessage(kNotAnAppError,
                                                      extension_id);
     return false;
   }
 
   // Look at prefs to find the right launch container.
   // |default_pref_value| is set to LAUNCH_REGULAR so that if
   // the user has not set a preference, we open the app in a tab.
   extension_misc::LaunchContainer launch_container =
       service()->extension_prefs()->GetLaunchContainer(
           extension, ExtensionPrefs::LAUNCH_DEFAULT);
   Browser::OpenApplication(profile(), extension, launch_container, GURL(),
                            NEW_FOREGROUND_TAB);
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram,
                             extension_misc::APP_LAUNCH_EXTENSION_API,
                             extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
 
   return true;
 }
 
-SetEnabledFunction::SetEnabledFunction() {}
-
-SetEnabledFunction::~SetEnabledFunction() {}
-
 bool SetEnabledFunction::RunImpl() {
+  std::string extension_id;
   bool enable;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id_));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &enable));
 
-  const Extension* extension = service()->GetExtensionById(extension_id_, true);
+  const Extension* extension = service()->GetExtensionById(extension_id, true);
   if (!extension) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kNoExtensionError, extension_id_);
+        kNoExtensionError, extension_id);
     return false;
   }
 
   if (!Extension::UserMayDisable(extension->location())) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id_);
+        kUserCantDisableError, extension_id);
     return false;
   }
 
-  bool currently_enabled = service()->IsExtensionEnabled(extension_id_);
-
-  if (!currently_enabled && enable) {
-    ExtensionPrefs* prefs = service()->extension_prefs();
-    if (prefs->DidExtensionEscalatePermissions(extension_id_)) {
-      if (!user_gesture()) {
-        error_ = keys::kGestureNeededForEscalationError;
-        return false;
-      }
-      AddRef(); // Matched in InstallUIProceed/InstallUIAbort
-      install_ui_.reset(new ExtensionInstallUI(profile_));
-      install_ui_->ConfirmReEnable(this, extension);
-      return true;
-    }
-    service()->EnableExtension(extension_id_);
-  } else if (currently_enabled && !enable) {
-    service()->DisableExtension(extension_id_);
-  }
-
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&SetEnabledFunction::SendResponse, this, true));
+  if (!service()->IsExtensionEnabled(extension_id) && enable)
+    service()->EnableExtension(extension_id);
+  else if (service()->IsExtensionEnabled(extension_id) && !enable)
+    service()->DisableExtension(extension_id);
 
   return true;
 }
 
-void SetEnabledFunction::InstallUIProceed() {
-  service()->EnableExtension(extension_id_);
-  SendResponse(true);
-  Release();
-}
-
-void SetEnabledFunction::InstallUIAbort(bool user_initiated) {
-  error_ = keys::kUserDidNotReEnableError;
-  SendResponse(false);
-  Release();
-}
-
 bool UninstallFunction::RunImpl() {
   std::string extension_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
 
   if (!service()->GetExtensionById(extension_id, true)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kNoExtensionError, extension_id);
+        kNoExtensionError, extension_id);
     return false;
   }
 
   ExtensionPrefs* prefs = service()->extension_prefs();
 
   if (!Extension::UserMayDisable(
       prefs->GetInstalledExtensionInfo(extension_id)->extension_location)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id);
+        kUserCantDisableError, extension_id);
     return false;
   }
 
   service()->UninstallExtension(extension_id, false /* external_uninstall */,
                                 NULL);
   return true;
 }
 
 ExtensionManagementEventRouter::ExtensionManagementEventRouter(Profile* profile)
     : profile_(profile) {}
@@ skipping 49 matching lines @@
         *content::Details<const std::string>(details).ptr()));
   } else {
     const Extension* extension = NULL;
     if (event_name == events::kOnExtensionDisabled) {
       extension = content::Details<UnloadedExtensionInfo>(details)->extension;
     } else {
       extension = content::Details<const Extension>(details).ptr();
     }
     CHECK(extension);
     ExtensionService* service = profile->GetExtensionService();
-    ExtensionPrefs* prefs = service->extension_prefs();
     bool enabled = service->GetExtensionById(extension->id(), false) != NULL;
-    bool escalated = prefs ->DidExtensionEscalatePermissions(extension->id());
-    args.Append(CreateExtensionInfo(*extension, enabled, escalated));
+    args.Append(CreateExtensionInfo(*extension, enabled));
   }
 
   std::string args_json;
   base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name, args_json, NULL, GURL());
 }