Added uninstall option to notification of high disk usage by an extension

chrome/browser/extensions/extension_storage_monitor.cc

 // Copyright 2014 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_storage_monitor.h"
 
 #include <map>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_storage_monitor_factory.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/image_loader.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notifier_settings.h"
 #include "ui/message_center/views/constants.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/storage_observer.h"
 
@@ skipping 29 matching lines @@
 // extension or app consumes excessive disk space.
 const char kPrefDisableStorageNotifications[] = "disable_storage_notifications";
 
 bool ShouldMonitorStorageFor(const Extension* extension) {
   // Only monitor storage for extensions that are granted unlimited storage.
   // Do not monitor storage for component extensions.
   return extension->HasAPIPermission(APIPermission::kUnlimitedStorage) &&
          extension->location() != Manifest::COMPONENT;
 }
 
+const Extension* GetExtensionById(content::BrowserContext* context,
+                                  const std::string& extension_id) {
+  return ExtensionRegistry::Get(context)->GetExtensionById(
+      extension_id, ExtensionRegistry::EVERYTHING);
+}
+
 }  // namespace
 
 // StorageEventObserver monitors the storage usage of extensions and lives on
 // the IO thread. When a threshold is exceeded, a message will be posted to the
 // UI thread, which displays the notification.
 class StorageEventObserver
     : public base::RefCountedThreadSafe<
           StorageEventObserver,
           BrowserThread::DeleteOnIOThread>,
       public quota::StorageObserver {
@@ skipping 206 matching lines @@
     }
   }
 }
 
 void ExtensionStorageMonitor::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   RemoveNotificationForExtension(extension->id());
 }
 
+void ExtensionStorageMonitor::ExtensionUninstallAccepted() {
+  DCHECK(!uninstall_extension_id_.empty());
+
+  const Extension* extension = GetExtensionById(context_,
+                                                uninstall_extension_id_);
+  uninstall_extension_id_.clear();
+  if (!extension)
+    return;
+
+  ExtensionService* service =
+      ExtensionSystem::Get(context_)->extension_service();
+  DCHECK(service);
+  service->UninstallExtension(extension->id(), false, NULL);
+}
+
+void ExtensionStorageMonitor::ExtensionUninstallCanceled() {
+  uninstall_extension_id_.clear();
+}
+
 std::string ExtensionStorageMonitor::GetNotificationId(
     const std::string& extension_id) {
   std::vector<std::string> placeholders;
   placeholders.push_back(context_->GetPath().BaseName().MaybeAsASCII());
   placeholders.push_back(extension_id);
 
   return ReplaceStringPlaceholders(kNotificationIdFormat, placeholders, NULL);
 }
 
 void ExtensionStorageMonitor::OnStorageThresholdExceeded(
     const std::string& extension_id,
     int64 next_threshold,
     int64 current_usage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const Extension* extension = ExtensionRegistry::Get(context_)->
-      GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
+  const Extension* extension = GetExtensionById(context_, extension_id);
   if (!extension)
     return;
 
   if (GetNextStorageThreshold(extension->id()) < next_threshold)
     SetNextStorageThreshold(extension->id(), next_threshold);
 
   const int kIconSize = message_center::kNotificationIconSize;
   ExtensionResource resource =  IconsInfo::GetIconResource(
       extension, kIconSize, ExtensionIconSet::MATCH_BIGGER);
   ImageLoader::Get(context_)->LoadImageAsync(
       extension, resource, gfx::Size(kIconSize, kIconSize),
       base::Bind(&ExtensionStorageMonitor::OnImageLoaded,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id,
                  current_usage));
 }
 
 void ExtensionStorageMonitor::OnImageLoaded(
     const std::string& extension_id,
     int64 current_usage,
     const gfx::Image& image) {
-  const Extension* extension = ExtensionRegistry::Get(context_)->
-      GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
+  const Extension* extension = GetExtensionById(context_, extension_id);
   if (!extension)
     return;
 
   // Remove any existing notifications to force a new notification to pop up.
   std::string notification_id(GetNotificationId(extension_id));
   message_center::MessageCenter::Get()->RemoveNotification(
       notification_id, false);
 
   message_center::RichNotificationData notification_data;
   notification_data.buttons.push_back(message_center::ButtonInfo(
       l10n_util::GetStringUTF16(extension->is_app() ?
           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_DISMISS_APP :
           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_DISMISS_EXTENSION)));
+  notification_data.buttons.push_back(message_center::ButtonInfo(
+      l10n_util::GetStringUTF16(extension->is_app() ?
+          IDS_EXTENSION_STORAGE_MONITOR_BUTTON_UNINSTALL_APP :
+          IDS_EXTENSION_STORAGE_MONITOR_BUTTON_UNINSTALL_EXTENSION)));
 
   gfx::Image notification_image(image);
   if (notification_image.IsEmpty()) {
     notification_image =
         extension->is_app() ? gfx::Image(util::GetDefaultAppIcon())
                             : gfx::Image(util::GetDefaultExtensionIcon());
   }
 
   scoped_ptr<message_center::Notification> notification;
   notification.reset(new message_center::Notification(
@@ skipping 19 matching lines @@
   notified_extension_ids_.insert(extension_id);
 }
 
 void ExtensionStorageMonitor::OnNotificationButtonClick(
     const std::string& extension_id, int button_index) {
   switch (button_index) {
     case BUTTON_DISABLE_NOTIFICATION: {
       DisableStorageMonitoring(extension_id);
       break;
     }
+    case BUTTON_UNINSTALL: {
+      ShowUninstallPrompt(extension_id);
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionStorageMonitor::DisableStorageMonitoring(
     const std::string& extension_id) {
   StopMonitoringStorage(extension_id);
 
   SetStorageNotificationEnabled(extension_id, false);
@@ skipping 93 matching lines @@
 
   message_center::MessageCenter* center = message_center::MessageCenter::Get();
   DCHECK(center);
   for (std::set<std::string>::iterator it = notified_extension_ids_.begin();
        it != notified_extension_ids_.end(); ++it) {
     center->RemoveNotification(GetNotificationId(*it), false);
   }
   notified_extension_ids_.clear();
 }
 
+void ExtensionStorageMonitor::ShowUninstallPrompt(
+    const std::string& extension_id) {
+  const Extension* extension = GetExtensionById(context_, extension_id);
+  if (!extension)
+    return;
+
+  if (!uninstall_dialog_.get()) {
+    uninstall_dialog_.reset(ExtensionUninstallDialog::Create(
+        Profile::FromBrowserContext(context_), NULL, this));
+  }
+
+  uninstall_extension_id_ = extension->id();
+  uninstall_dialog_->ConfirmUninstall(extension);
+}
+
 int64 ExtensionStorageMonitor::GetNextStorageThreshold(
     const std::string& extension_id) const {
   int next_threshold = GetNextStorageThresholdFromPrefs(extension_id);
   if (next_threshold == 0) {
     // The next threshold is written to the prefs after the initial threshold is
     // exceeded.
     next_threshold = extension_prefs_->IsEphemeralApp(extension_id)
                          ? initial_ephemeral_threshold_
                          : initial_extension_threshold_;
   }
@@ skipping 41 matching lines @@
 void ExtensionStorageMonitor::SetStorageNotificationEnabled(
     const std::string& extension_id,
     bool enable_notifications) {
   extension_prefs_->UpdateExtensionPref(
       extension_id,
       kPrefDisableStorageNotifications,
       enable_notifications ? NULL : new base::FundamentalValue(true));
 }
 
 }  // namespace extensions