chrome/browser/extensions/webstore_installer.h

   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 #ifndef CHROME_BROWSER_EXTENSIONS_WEBSTORE_INSTALLER_H_
   6 #define CHROME_BROWSER_EXTENSIONS_WEBSTORE_INSTALLER_H_
   7
   8 #include <list>
   9 #include <string>
  10
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/supports_user_data.h"
  15 #include "base/values.h"
  16 #include "base/version.h"
  17 #include "chrome/browser/extensions/extension_install_prompt.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/download_interrupt_reasons.h"
  20 #include "content/public/browser/download_item.h"
  21 #include "content/public/browser/notification_observer.h"
  22 #include "content/public/browser/notification_registrar.h"
  23 #include "extensions/common/manifest_handlers/shared_module_info.h"
  24 #include "ui/gfx/image/image_skia.h"
  25 #include "url/gurl.h"
  26
  27 class Profile;
  28
  29 namespace base {
  30 class FilePath;
  31 }
  32
  33 namespace content {
  34 class NavigationController;
  35 }
  36
  37 namespace extensions {
  38
  39 class Extension;
  40 class Manifest;
  41
  42 // Downloads and installs extensions from the web store.
  43 class WebstoreInstaller :public content::NotificationObserver,
  44                          public content::DownloadItem::Observer,
  45                          public base::RefCountedThreadSafe<
  46   WebstoreInstaller, content::BrowserThread::DeleteOnUIThread> {
  47  public:
  48   enum InstallSource {
  49     // Inline installs trigger slightly different behavior (install source
  50     // is different, download referrers are the item's page in the gallery).
  51     INSTALL_SOURCE_INLINE,
  52     INSTALL_SOURCE_APP_LAUNCHER,
  53     INSTALL_SOURCE_OTHER
  54   };
  55
  56   enum FailureReason {
  57     FAILURE_REASON_CANCELLED,
  58     FAILURE_REASON_DEPENDENCY_NOT_FOUND,
  59     FAILURE_REASON_DEPENDENCY_NOT_SHARED_MODULE,
  60     FAILURE_REASON_OTHER
  61   };
  62
  63   enum ManifestCheckLevel {
  64     // Do not check for any manifest equality.
  65     MANIFEST_CHECK_LEVEL_NONE,
  66
  67     // Only check that the expected and actual permissions have the same
  68     // effective permissions.
  69     MANIFEST_CHECK_LEVEL_LOOSE,
  70
  71     // All data in the expected and actual manifests must match.
  72     MANIFEST_CHECK_LEVEL_STRICT,
  73   };
  74
  75   class Delegate {
  76    public:
  77     virtual void OnExtensionDownloadStarted(const std::string& id,
  78                                             content::DownloadItem* item);
  79     virtual void OnExtensionDownloadProgress(const std::string& id,
  80                                              content::DownloadItem* item);
  81     virtual void OnExtensionInstallSuccess(const std::string& id) = 0;
  82     virtual void OnExtensionInstallFailure(const std::string& id,
  83                                            const std::string& error,
  84                                            FailureReason reason) = 0;
  85
  86    protected:
  87     virtual ~Delegate() {}
  88   };
  89
  90   // Contains information about what parts of the extension install process can
  91   // be skipped or modified. If one of these is present, it means that a CRX
  92   // download was initiated by WebstoreInstaller. The Approval instance should
  93   // be checked further for additional details.
  94   struct Approval : public base::SupportsUserData::Data {
  95     static scoped_ptr<Approval> CreateWithInstallPrompt(Profile* profile);
  96
  97     // Creates an Approval for installing a shared module.
  98     static scoped_ptr<Approval> CreateForSharedModule(Profile* profile);
  99
 100     // Creates an Approval that will skip putting up an install confirmation
 101     // prompt if the actual manifest from the extension to be installed matches
 102     // |parsed_manifest|. The |strict_manifest_check| controls whether we want
 103     // to require an exact manifest match, or are willing to tolerate a looser
 104     // check just that the effective permissions are the same.
 105     static scoped_ptr<Approval> CreateWithNoInstallPrompt(
 106         Profile* profile,
 107         const std::string& extension_id,
 108         scoped_ptr<base::DictionaryValue> parsed_manifest,
 109         bool strict_manifest_check);
 110
 111     virtual ~Approval();
 112
 113     // The extension id that was approved for installation.
 114     std::string extension_id;
 115
 116     // The profile the extension should be installed into.
 117     Profile* profile;
 118
 119     // The expected manifest, before localization.
 120     scoped_ptr<Manifest> manifest;
 121
 122     // Whether to use a bubble notification when an app is installed, instead of
 123     // the default behavior of transitioning to the new tab page.
 124     bool use_app_installed_bubble;
 125
 126     // Whether to skip the post install UI like the extension installed bubble.
 127     bool skip_post_install_ui;
 128
 129     // Whether to skip the install dialog once the extension has been downloaded
 130     // and unpacked. One reason this can be true is that in the normal webstore
 131     // installation, the dialog is shown earlier, before any download is done,
 132     // so there's no need to show it again.
 133     bool skip_install_dialog;
 134
 135     // Whether we should enable the launcher before installing the app.
 136     bool enable_launcher;
 137
 138     // Manifest check level for checking actual manifest against expected
 139     // manifest.
 140     ManifestCheckLevel manifest_check_level;
 141
 142     // Used to show the install dialog.
 143     ExtensionInstallPrompt::ShowDialogCallback show_dialog_callback;
 144
 145     // The icon to use to display the extension while it is installing.
 146     gfx::ImageSkia installing_icon;
 147
 148     // A dummy extension created from |manifest|;
 149     scoped_refptr<Extension> dummy_extension;
 150
 151     // Required minimum version.
 152     scoped_ptr<Version> minimum_version;
 153
 154     // Ephemeral apps (experimental) are not permanently installed in Chrome.
 155     bool is_ephemeral;
 156
 157    private:
 158     Approval();
 159   };
 160
 161   // Gets the Approval associated with the |download|, or NULL if there's none.
 162   // Note that the Approval is owned by |download|.
 163   static const Approval* GetAssociatedApproval(
 164       const content::DownloadItem& download);
 165
 166   // Creates a WebstoreInstaller for downloading and installing the extension
 167   // with the given |id| from the Chrome Web Store. If |delegate| is not NULL,
 168   // it will be notified when the install succeeds or fails. The installer will
 169   // use the specified |controller| to download the extension. Only one
 170   // WebstoreInstaller can use a specific controller at any given time. This
 171   // also associates the |approval| with this install.
 172   // Note: the delegate should stay alive until being called back.
 173   WebstoreInstaller(Profile* profile,
 174                     Delegate* delegate,
 175                     content::NavigationController* controller,
 176                     const std::string& id,
 177                     scoped_ptr<Approval> approval,
 178                     InstallSource source);
 179
 180   // Starts downloading and installing the extension.
 181   void Start();
 182
 183   // content::NotificationObserver
 184   virtual void Observe(int type,
 185                        const content::NotificationSource& source,
 186                        const content::NotificationDetails& details) OVERRIDE;
 187
 188   // Removes the reference to the delegate passed in the constructor. Used when
 189   // the delegate object must be deleted before this object.
 190   void InvalidateDelegate();
 191
 192   // Instead of using the default download directory, use |directory| instead.
 193   // This does *not* transfer ownership of |directory|.
 194   static void SetDownloadDirectoryForTests(base::FilePath* directory);
 195
 196  private:
 197   FRIEND_TEST_ALL_PREFIXES(WebstoreInstallerTest, PlatformParams);
 198   friend struct content::BrowserThread::DeleteOnThread<
 199    content::BrowserThread::UI>;
 200   friend class base::DeleteHelper<WebstoreInstaller>;
 201   virtual ~WebstoreInstaller();
 202
 203   // Helper to get install URL.
 204   static GURL GetWebstoreInstallURL(const std::string& extension_id,
 205                                     InstallSource source);
 206
 207   // DownloadManager::DownloadUrl callback.
 208   void OnDownloadStarted(content::DownloadItem* item,
 209                          content::DownloadInterruptReason interrupt_reason);
 210
 211   // DownloadItem::Observer implementation:
 212   virtual void OnDownloadUpdated(content::DownloadItem* download) OVERRIDE;
 213   virtual void OnDownloadDestroyed(content::DownloadItem* download) OVERRIDE;
 214
 215   // Downloads next pending module in |pending_modules_|.
 216   void DownloadNextPendingModule();
 217
 218   // Downloads and installs a single Crx with the given |extension_id|.
 219   // This function is used for both the extension Crx and dependences.
 220   void DownloadCrx(const std::string& extension_id, InstallSource source);
 221
 222   // Starts downloading the extension to |file_path|.
 223   void StartDownload(const base::FilePath& file_path);
 224
 225   // Reports an install |error| to the delegate for the given extension if this
 226   // managed its installation. This also removes the associated PendingInstall.
 227   void ReportFailure(const std::string& error, FailureReason reason);
 228
 229   // Reports a successful install to the delegate for the given extension if
 230   // this managed its installation. This also removes the associated
 231   // PendingInstall.
 232   void ReportSuccess();
 233
 234   // Records stats regarding an interrupted webstore download item.
 235   void RecordInterrupt(const content::DownloadItem* download) const;
 236
 237   content::NotificationRegistrar registrar_;
 238   Profile* profile_;
 239   Delegate* delegate_;
 240   content::NavigationController* controller_;
 241   std::string id_;
 242   InstallSource install_source_;
 243   // The DownloadItem is owned by the DownloadManager and is valid from when
 244   // OnDownloadStarted is called (with no error) until OnDownloadDestroyed().
 245   content::DownloadItem* download_item_;
 246   scoped_ptr<Approval> approval_;
 247   GURL download_url_;
 248
 249   // Pending modules.
 250   std::list<SharedModuleInfo::ImportInfo> pending_modules_;
 251   // Total extension modules we need download and install (the main module and
 252   // depedences).
 253   int total_modules_;
 254   bool download_started_;
 255 };
 256
 257 }  // namespace extensions
 258
 259 #endif  // CHROME_BROWSER_EXTENSIONS_WEBSTORE_INSTALLER_H_