extensions/browser/api/runtime/runtime_api.h

   1 // Copyright 2014 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 EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_
   6 #define EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_
   7
   8 #include <string>
   9
  10 #include "content/public/browser/notification_observer.h"
  11 #include "content/public/browser/notification_registrar.h"
  12 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
  13 #include "extensions/browser/browser_context_keyed_api_factory.h"
  14 #include "extensions/browser/extension_function.h"
  15 #include "extensions/browser/process_manager_observer.h"
  16 #include "extensions/browser/update_observer.h"
  17 #include "extensions/common/api/runtime.h"
  18
  19 namespace base {
  20 class Version;
  21 }
  22
  23 namespace content {
  24 class BrowserContext;
  25 }
  26
  27 namespace extensions {
  28
  29 namespace core_api {
  30 namespace runtime {
  31 struct PlatformInfo;
  32 }
  33 }
  34
  35 class Extension;
  36 class ExtensionHost;
  37
  38 // Runtime API dispatches onStartup, onInstalled, and similar events to
  39 // extensions. There is one instance shared between a browser context and
  40 // its related incognito instance.
  41 class RuntimeAPI : public BrowserContextKeyedAPI,
  42                    public content::NotificationObserver,
  43                    public UpdateObserver,
  44                    public ProcessManagerObserver {
  45  public:
  46   static BrowserContextKeyedAPIFactory<RuntimeAPI>* GetFactoryInstance();
  47
  48   explicit RuntimeAPI(content::BrowserContext* context);
  49   virtual ~RuntimeAPI();
  50
  51   // content::NotificationObserver overrides:
  52   virtual void Observe(int type,
  53                        const content::NotificationSource& source,
  54                        const content::NotificationDetails& details) OVERRIDE;
  55
  56   void ReloadExtension(const std::string& extension_id);
  57   bool CheckForUpdates(const std::string& extension_id,
  58                        const RuntimeAPIDelegate::UpdateCheckCallback& callback);
  59   void OpenURL(const GURL& uninstall_url);
  60   bool GetPlatformInfo(core_api::runtime::PlatformInfo* info);
  61   bool RestartDevice(std::string* error_message);
  62
  63  private:
  64   friend class BrowserContextKeyedAPIFactory<RuntimeAPI>;
  65
  66   void OnExtensionsReady();
  67   void OnExtensionLoaded(const Extension* extension);
  68   void OnExtensionInstalled(const Extension* extension);
  69   void OnExtensionUninstalled(const Extension* extension);
  70
  71   // BrowserContextKeyedAPI implementation:
  72   static const char* service_name() { return "RuntimeAPI"; }
  73   static const bool kServiceRedirectedInIncognito = true;
  74   static const bool kServiceIsNULLWhileTesting = true;
  75   virtual void Shutdown() OVERRIDE;
  76
  77   // extensions::UpdateObserver overrides:
  78   virtual void OnAppUpdateAvailable(const Extension* extension) OVERRIDE;
  79   virtual void OnChromeUpdateAvailable() OVERRIDE;
  80
  81   // ProcessManagerObserver implementation:
  82   virtual void OnBackgroundHostStartup(const Extension* extension) OVERRIDE;
  83
  84   scoped_ptr<RuntimeAPIDelegate> delegate_;
  85
  86   content::BrowserContext* browser_context_;
  87
  88   // True if we should dispatch the chrome.runtime.onInstalled event with
  89   // reason "chrome_update" upon loading each extension.
  90   bool dispatch_chrome_updated_event_;
  91
  92   content::NotificationRegistrar registrar_;
  93
  94   DISALLOW_COPY_AND_ASSIGN(RuntimeAPI);
  95 };
  96
  97 class RuntimeEventRouter {
  98  public:
  99   // Dispatches the onStartup event to all currently-loaded extensions.
 100   static void DispatchOnStartupEvent(content::BrowserContext* context,
 101                                      const std::string& extension_id);
 102
 103   // Dispatches the onInstalled event to the given extension.
 104   static void DispatchOnInstalledEvent(content::BrowserContext* context,
 105                                        const std::string& extension_id,
 106                                        const base::Version& old_version,
 107                                        bool chrome_updated);
 108
 109   // Dispatches the onUpdateAvailable event to the given extension.
 110   static void DispatchOnUpdateAvailableEvent(
 111       content::BrowserContext* context,
 112       const std::string& extension_id,
 113       const base::DictionaryValue* manifest);
 114
 115   // Dispatches the onBrowserUpdateAvailable event to all extensions.
 116   static void DispatchOnBrowserUpdateAvailableEvent(
 117       content::BrowserContext* context);
 118
 119   // Dispatches the onRestartRequired event to the given app.
 120   static void DispatchOnRestartRequiredEvent(
 121       content::BrowserContext* context,
 122       const std::string& app_id,
 123       core_api::runtime::OnRestartRequired::Reason reason);
 124
 125   // Does any work needed at extension uninstall (e.g. load uninstall url).
 126   static void OnExtensionUninstalled(content::BrowserContext* context,
 127                                      const std::string& extension_id);
 128 };
 129
 130 class RuntimeGetBackgroundPageFunction : public UIThreadExtensionFunction {
 131  public:
 132   DECLARE_EXTENSION_FUNCTION("runtime.getBackgroundPage",
 133                              RUNTIME_GETBACKGROUNDPAGE)
 134
 135  protected:
 136   virtual ~RuntimeGetBackgroundPageFunction() {}
 137   virtual ResponseAction Run() OVERRIDE;
 138
 139  private:
 140   void OnPageLoaded(ExtensionHost*);
 141 };
 142
 143 class RuntimeSetUninstallURLFunction : public UIThreadExtensionFunction {
 144  public:
 145   DECLARE_EXTENSION_FUNCTION("runtime.setUninstallURL", RUNTIME_SETUNINSTALLURL)
 146
 147  protected:
 148   virtual ~RuntimeSetUninstallURLFunction() {}
 149   virtual ResponseAction Run() OVERRIDE;
 150 };
 151
 152 class RuntimeReloadFunction : public UIThreadExtensionFunction {
 153  public:
 154   DECLARE_EXTENSION_FUNCTION("runtime.reload", RUNTIME_RELOAD)
 155
 156  protected:
 157   virtual ~RuntimeReloadFunction() {}
 158   virtual ResponseAction Run() OVERRIDE;
 159 };
 160
 161 class RuntimeRequestUpdateCheckFunction : public UIThreadExtensionFunction {
 162  public:
 163   DECLARE_EXTENSION_FUNCTION("runtime.requestUpdateCheck",
 164                              RUNTIME_REQUESTUPDATECHECK)
 165
 166  protected:
 167   virtual ~RuntimeRequestUpdateCheckFunction() {}
 168   virtual ResponseAction Run() OVERRIDE;
 169
 170  private:
 171   void CheckComplete(const RuntimeAPIDelegate::UpdateCheckResult& result);
 172 };
 173
 174 class RuntimeRestartFunction : public UIThreadExtensionFunction {
 175  public:
 176   DECLARE_EXTENSION_FUNCTION("runtime.restart", RUNTIME_RESTART)
 177
 178  protected:
 179   virtual ~RuntimeRestartFunction() {}
 180   virtual ResponseAction Run() OVERRIDE;
 181 };
 182
 183 class RuntimeGetPlatformInfoFunction : public UIThreadExtensionFunction {
 184  public:
 185   DECLARE_EXTENSION_FUNCTION("runtime.getPlatformInfo",
 186                              RUNTIME_GETPLATFORMINFO);
 187
 188  protected:
 189   virtual ~RuntimeGetPlatformInfoFunction() {}
 190   virtual ResponseAction Run() OVERRIDE;
 191 };
 192
 193 class RuntimeGetPackageDirectoryEntryFunction
 194     : public UIThreadExtensionFunction {
 195  public:
 196   DECLARE_EXTENSION_FUNCTION("runtime.getPackageDirectoryEntry",
 197                              RUNTIME_GETPACKAGEDIRECTORYENTRY)
 198
 199  protected:
 200   virtual ~RuntimeGetPackageDirectoryEntryFunction() {}
 201   virtual ResponseAction Run() OVERRIDE;
 202 };
 203
 204 }  // namespace extensions
 205
 206 #endif  // EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_