chrome/browser/background/background_contents_service.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_BACKGROUND_BACKGROUND_CONTENTS_SERVICE_H_
   6 #define CHROME_BROWSER_BACKGROUND_BACKGROUND_CONTENTS_SERVICE_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/gtest_prod_util.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/scoped_observer.h"
  15 #include "chrome/browser/tab_contents/background_contents.h"
  16 #include "components/keyed_service/core/keyed_service.h"
  17 #include "content/public/browser/notification_observer.h"
  18 #include "content/public/browser/notification_registrar.h"
  19 #include "content/public/common/window_container_type.h"
  20 #include "extensions/browser/extension_registry_observer.h"
  21 #include "ui/base/window_open_disposition.h"
  22 #include "url/gurl.h"
  23
  24 class PrefService;
  25 class Profile;
  26
  27 namespace base {
  28 class CommandLine;
  29 class DictionaryValue;
  30 }
  31
  32 namespace content {
  33 class SessionStorageNamespace;
  34 }
  35
  36 namespace extensions {
  37 class Extension;
  38 class ExtensionRegistry;
  39 }
  40
  41 namespace gfx {
  42 class Rect;
  43 }
  44
  45 struct BackgroundContentsOpenedDetails;
  46
  47 // BackgroundContentsService is owned by the profile, and is responsible for
  48 // managing the lifetime of BackgroundContents (tracking the set of background
  49 // urls, loading them at startup, and keeping the browser process alive as long
  50 // as there are BackgroundContents loaded).
  51 //
  52 // It is also responsible for tracking the association between
  53 // BackgroundContents and their parent app, and shutting them down when the
  54 // parent app is unloaded.
  55 class BackgroundContentsService : private content::NotificationObserver,
  56                                   public extensions::ExtensionRegistryObserver,
  57                                   public BackgroundContents::Delegate,
  58                                   public KeyedService {
  59  public:
  60   BackgroundContentsService(Profile* profile,
  61                             const base::CommandLine* command_line);
  62   virtual ~BackgroundContentsService();
  63
  64   // Allows tests to reduce the time between a force-installed app/extension
  65   // crashing and when we reload it.
  66   static void SetRestartDelayForForceInstalledAppsAndExtensionsForTesting(
  67       int restart_delay_in_ms);
  68
  69   // Get the crash notification's id for the extension.
  70   static std::string GetNotificationIdForExtensionForTesting(
  71       const std::string& extension_id);
  72
  73   // Show a popup notification balloon with a crash message for a given app/
  74   // extension.
  75   static void ShowBalloonForTesting(const extensions::Extension* extension,
  76                                     Profile* profile);
  77
  78   // Returns the BackgroundContents associated with the passed application id,
  79   // or NULL if none.
  80   BackgroundContents* GetAppBackgroundContents(const base::string16& appid);
  81
  82   // Returns true if there's a registered BackgroundContents for this app. It
  83   // is possible for this routine to return true when GetAppBackgroundContents()
  84   // returns false, if the BackgroundContents closed due to the render process
  85   // crashing.
  86   bool HasRegisteredBackgroundContents(const base::string16& appid);
  87
  88   // Returns all currently opened BackgroundContents (used by the task manager).
  89   std::vector<BackgroundContents*> GetBackgroundContents() const;
  90
  91   // BackgroundContents::Delegate implementation.
  92   virtual void AddWebContents(content::WebContents* new_contents,
  93                               WindowOpenDisposition disposition,
  94                               const gfx::Rect& initial_pos,
  95                               bool user_gesture,
  96                               bool* was_blocked) OVERRIDE;
  97
  98   // Gets the parent application id for the passed BackgroundContents. Returns
  99   // an empty string if no parent application found (e.g. passed
 100   // BackgroundContents has already shut down).
 101   const base::string16& GetParentApplicationId(BackgroundContents* contents) const;
 102
 103   // Creates a new BackgroundContents using the passed |site| and
 104   // the |route_id| and begins tracking the object internally so it can be
 105   // shutdown if the parent application is uninstalled.
 106   // A BACKGROUND_CONTENTS_OPENED notification will be generated with the passed
 107   // |frame_name| and |application_id| values, using the passed |profile| as the
 108   // Source..
 109   BackgroundContents* CreateBackgroundContents(
 110       content::SiteInstance* site,
 111       int route_id,
 112       Profile* profile,
 113       const base::string16& frame_name,
 114       const base::string16& application_id,
 115       const std::string& partition_id,
 116       content::SessionStorageNamespace* session_storage_namespace);
 117
 118   // Load the manifest-specified background page for the specified hosted app.
 119   // If the manifest doesn't specify one, then load the BackgroundContents
 120   // registered in the pref. This is typically used to reload a crashed
 121   // background page.
 122   void LoadBackgroundContentsForExtension(Profile* profile,
 123                                           const std::string& extension_id);
 124
 125  private:
 126   friend class BackgroundContentsServiceTest;
 127   friend class MockBackgroundContents;
 128   friend class TaskManagerNoShowBrowserTest;
 129
 130   FRIEND_TEST_ALL_PREFIXES(BackgroundContentsServiceTest,
 131                            BackgroundContentsCreateDestroy);
 132   FRIEND_TEST_ALL_PREFIXES(BackgroundContentsServiceTest,
 133                            TestApplicationIDLinkage);
 134   FRIEND_TEST_ALL_PREFIXES(TaskManagerNoShowBrowserTest,
 135                            NoticeBGContentsChanges);
 136   FRIEND_TEST_ALL_PREFIXES(TaskManagerNoShowBrowserTest,
 137                            KillBGContents);
 138
 139   // Registers for various notifications.
 140   void StartObserving(Profile* profile);
 141
 142   // content::NotificationObserver implementation.
 143   virtual void Observe(int type,
 144                        const content::NotificationSource& source,
 145                        const content::NotificationDetails& details) OVERRIDE;
 146
 147   // extensions::ExtensionRegistryObserver implementation.
 148   virtual void OnExtensionLoaded(
 149       content::BrowserContext* browser_context,
 150       const extensions::Extension* extension) OVERRIDE;
 151   virtual void OnExtensionUnloaded(
 152       content::BrowserContext* browser_context,
 153       const extensions::Extension* extension,
 154       extensions::UnloadedExtensionInfo::Reason reason) OVERRIDE;
 155   virtual void OnExtensionUninstalled(
 156       content::BrowserContext* browser_context,
 157       const extensions::Extension* extension,
 158       extensions::UninstallReason reason) OVERRIDE;
 159
 160   // Restarts a force-installed app/extension after a crash.
 161   void RestartForceInstalledExtensionOnCrash(
 162       const extensions::Extension* extension,
 163       Profile* profile);
 164
 165   // Loads all registered BackgroundContents at startup.
 166   void LoadBackgroundContentsFromPrefs(Profile* profile);
 167
 168   // Load a BackgroundContent; the settings are read from the provided
 169   // dictionary.
 170   void LoadBackgroundContentsFromDictionary(
 171       Profile* profile,
 172       const std::string& extension_id,
 173       const base::DictionaryValue* contents);
 174
 175   // Load the manifest-specified BackgroundContents for all apps for the
 176   // profile.
 177   void LoadBackgroundContentsFromManifests(Profile* profile);
 178
 179   // Creates a single BackgroundContents associated with the specified |appid|,
 180   // creates an associated RenderView with the name specified by |frame_name|,
 181   // and navigates to the passed |url|.
 182   void LoadBackgroundContents(Profile* profile,
 183                               const GURL& url,
 184                               const base::string16& frame_name,
 185                               const base::string16& appid);
 186
 187   // Invoked when a new BackgroundContents is opened.
 188   void BackgroundContentsOpened(BackgroundContentsOpenedDetails* details);
 189
 190   // Invoked when a BackgroundContents object is destroyed.
 191   void BackgroundContentsShutdown(BackgroundContents* contents);
 192
 193   // Registers the |contents->GetURL()| to be run at startup. Only happens for
 194   // the first navigation after window.open() (future calls to
 195   // RegisterBackgroundContents() for the same BackgroundContents will do
 196   // nothing).
 197   void RegisterBackgroundContents(BackgroundContents* contents);
 198
 199   // Stops loading the passed BackgroundContents on startup.
 200   void UnregisterBackgroundContents(BackgroundContents* contents);
 201
 202   // Unregisters and deletes the BackgroundContents associated with the
 203   // passed extension.
 204   void ShutdownAssociatedBackgroundContents(const base::string16& appid);
 205
 206   // Returns true if this BackgroundContents is in the contents_list_.
 207   bool IsTracked(BackgroundContents* contents) const;
 208
 209   // Sends out a notification when our association of background contents with
 210   // apps may have changed (used by BackgroundApplicationListModel to update the
 211   // set of background apps as new background contents are opened/closed).
 212   void SendChangeNotification(Profile* profile);
 213
 214   // Delay (in ms) before restarting a force-installed extension that crashed.
 215   static int restart_delay_in_ms_;
 216
 217   // PrefService used to store list of background pages (or NULL if this is
 218   // running under an incognito profile).
 219   PrefService* prefs_;
 220   content::NotificationRegistrar registrar_;
 221
 222   // Information we track about each BackgroundContents.
 223   struct BackgroundContentsInfo {
 224     // The BackgroundContents whose information we are tracking.
 225     BackgroundContents* contents;
 226     // The name of the top level frame for this BackgroundContents.
 227     base::string16 frame_name;
 228   };
 229
 230   // Map associating currently loaded BackgroundContents with their parent
 231   // applications.
 232   // Key: application id
 233   // Value: BackgroundContentsInfo for the BC associated with that application
 234   typedef std::map<base::string16, BackgroundContentsInfo>
 235       BackgroundContentsMap;
 236   BackgroundContentsMap contents_map_;
 237
 238   ScopedObserver<extensions::ExtensionRegistry,
 239                  extensions::ExtensionRegistryObserver>
 240       extension_registry_observer_;
 241
 242   DISALLOW_COPY_AND_ASSIGN(BackgroundContentsService);
 243 };
 244
 245 #endif  // CHROME_BROWSER_BACKGROUND_BACKGROUND_CONTENTS_SERVICE_H_