chrome/browser/ui/extensions/extension_enable_flow.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
   6
   7 #include "chrome/browser/chrome_notification_types.h"
   8 #include "chrome/browser/extensions/extension_service.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "chrome/browser/ui/browser.h"
  11 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
  12 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
  13 #include "content/public/browser/notification_details.h"
  14 #include "content/public/browser/notification_source.h"
  15 #include "extensions/browser/extension_prefs.h"
  16 #include "extensions/browser/extension_registry.h"
  17 #include "extensions/browser/extension_system.h"
  18
  19 using extensions::Extension;
  20
  21 ExtensionEnableFlow::ExtensionEnableFlow(Profile* profile,
  22                                          const std::string& extension_id,
  23                                          ExtensionEnableFlowDelegate* delegate)
  24     : profile_(profile),
  25       extension_id_(extension_id),
  26       delegate_(delegate),
  27       parent_contents_(NULL),
  28       parent_window_(NULL),
  29       extension_registry_observer_(this) {
  30 }
  31
  32 ExtensionEnableFlow::~ExtensionEnableFlow() {
  33 }
  34
  35 void ExtensionEnableFlow::StartForWebContents(
  36     content::WebContents* parent_contents) {
  37   parent_contents_ = parent_contents;
  38   parent_window_ = NULL;
  39   Run();
  40 }
  41
  42 void ExtensionEnableFlow::StartForNativeWindow(
  43     gfx::NativeWindow parent_window) {
  44   parent_contents_ = NULL;
  45   parent_window_ = parent_window;
  46   Run();
  47 }
  48
  49 void ExtensionEnableFlow::StartForCurrentlyNonexistentWindow(
  50     base::Callback<gfx::NativeWindow(void)> window_getter) {
  51   window_getter_ = window_getter;
  52   Run();
  53 }
  54
  55 void ExtensionEnableFlow::Run() {
  56   ExtensionService* service =
  57       extensions::ExtensionSystem::Get(profile_)->extension_service();
  58   const Extension* extension = service->GetExtensionById(extension_id_, true);
  59   if (!extension) {
  60     extension = extensions::ExtensionRegistry::Get(profile_)->GetExtensionById(
  61         extension_id_, extensions::ExtensionRegistry::TERMINATED);
  62     // It's possible (though unlikely) the app could have been uninstalled since
  63     // the user clicked on it.
  64     if (!extension)
  65       return;
  66     // If the app was terminated, reload it first.
  67     service->ReloadExtension(extension_id_);
  68
  69     // ReloadExtension reallocates the Extension object.
  70     extension = service->GetExtensionById(extension_id_, true);
  71
  72     // |extension| could be NULL for asynchronous load, such as the case of
  73     // an unpacked extension. Wait for the load to continue the flow.
  74     if (!extension) {
  75       StartObserving();
  76       return;
  77     }
  78   }
  79
  80   CheckPermissionAndMaybePromptUser();
  81 }
  82
  83 void ExtensionEnableFlow::CheckPermissionAndMaybePromptUser() {
  84   ExtensionService* service =
  85       extensions::ExtensionSystem::Get(profile_)->extension_service();
  86   const Extension* extension = service->GetExtensionById(extension_id_, true);
  87   if (!extension) {
  88     delegate_->ExtensionEnableFlowAborted(false);  // |delegate_| may delete us.
  89     return;
  90   }
  91
  92   extensions::ExtensionPrefs* prefs = extensions::ExtensionPrefs::Get(profile_);
  93   if (!prefs->DidExtensionEscalatePermissions(extension_id_)) {
  94     // Enable the extension immediately if its privileges weren't escalated.
  95     // This is a no-op if the extension was previously terminated.
  96     service->EnableExtension(extension_id_);
  97
  98     delegate_->ExtensionEnableFlowFinished();  // |delegate_| may delete us.
  99     return;
 100   }
 101
 102   CreatePrompt();
 103   prompt_->ConfirmReEnable(this, extension);
 104 }
 105
 106 void ExtensionEnableFlow::CreatePrompt() {
 107   if (!window_getter_.is_null())
 108     parent_window_ = window_getter_.Run();
 109   prompt_.reset(parent_contents_ ?
 110       new ExtensionInstallPrompt(parent_contents_) :
 111       new ExtensionInstallPrompt(profile_, parent_window_, this));
 112 }
 113
 114 void ExtensionEnableFlow::StartObserving() {
 115   extension_registry_observer_.Add(
 116       extensions::ExtensionRegistry::Get(profile_));
 117   registrar_.Add(this,
 118                  extensions::NOTIFICATION_EXTENSION_LOAD_ERROR,
 119                  content::Source<Profile>(profile_));
 120 }
 121
 122 void ExtensionEnableFlow::StopObserving() {
 123   registrar_.RemoveAll();
 124   extension_registry_observer_.RemoveAll();
 125 }
 126
 127 void ExtensionEnableFlow::Observe(int type,
 128                                   const content::NotificationSource& source,
 129                                   const content::NotificationDetails& details) {
 130   DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_LOAD_ERROR, type);
 131   StopObserving();
 132   delegate_->ExtensionEnableFlowAborted(false);
 133 }
 134
 135 void ExtensionEnableFlow::OnExtensionLoaded(
 136     content::BrowserContext* browser_context,
 137     const Extension* extension) {
 138   if (extension->id() == extension_id_) {
 139     StopObserving();
 140     CheckPermissionAndMaybePromptUser();
 141   }
 142 }
 143
 144 void ExtensionEnableFlow::OnExtensionUninstalled(
 145     content::BrowserContext* browser_context,
 146     const Extension* extension,
 147     extensions::UninstallReason reason) {
 148   if (extension->id() == extension_id_) {
 149     StopObserving();
 150     delegate_->ExtensionEnableFlowAborted(false);
 151   }
 152 }
 153
 154 void ExtensionEnableFlow::InstallUIProceed() {
 155   ExtensionService* service =
 156       extensions::ExtensionSystem::Get(profile_)->extension_service();
 157
 158   // The extension can be uninstalled in another window while the UI was
 159   // showing. Treat it as a cancellation and notify |delegate_|.
 160   const Extension* extension = service->GetExtensionById(extension_id_, true);
 161   if (!extension) {
 162     delegate_->ExtensionEnableFlowAborted(true);
 163     return;
 164   }
 165
 166   service->GrantPermissionsAndEnableExtension(extension);
 167   delegate_->ExtensionEnableFlowFinished();  // |delegate_| may delete us.
 168 }
 169
 170 void ExtensionEnableFlow::InstallUIAbort(bool user_initiated) {
 171   delegate_->ExtensionEnableFlowAborted(user_initiated);
 172   // |delegate_| may delete us.
 173 }
 174
 175 content::WebContents* ExtensionEnableFlow::OpenURL(
 176     const content::OpenURLParams& params) {
 177   chrome::ScopedTabbedBrowserDisplayer displayer(
 178       profile_, chrome::GetActiveDesktop());
 179   return displayer.browser()->OpenURL(params);
 180 }