Create interface "EventPageTracker" for checking an extension's

extensions/browser/process_manager.h

 // Copyright 2013 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.
 
 #ifndef EXTENSIONS_BROWSER_PROCESS_MANAGER_H_
 #define EXTENSIONS_BROWSER_PROCESS_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "extensions/browser/event_page_tracker.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/view_type.h"
 
 class GURL;
 
 namespace content {
 class BrowserContext;
 class DevToolsAgentHost;
 class RenderFrameHost;
 class SiteInstance;
 class WebContents;
 };
 
 namespace extensions {
 
 class Extension;
 class ExtensionHost;
 class ExtensionRegistry;
 class ProcessManagerObserver;
 
 // Manages dynamic state of running Chromium extensions. There is one instance
 // of this class per Profile. OTR Profiles have a separate instance that keeps
 // track of split-mode extensions only.
 class ProcessManager : public KeyedService,
                        public content::NotificationObserver,
-                       public ExtensionRegistryObserver {
+                       public ExtensionRegistryObserver,
+                       public EventPageTracker {
  public:
   using ExtensionHostSet = std::set<extensions::ExtensionHost*>;
 
   static ProcessManager* Get(content::BrowserContext* context);
   ~ProcessManager() override;
 
   void RegisterRenderFrameHost(content::WebContents* web_contents,
                                content::RenderFrameHost* render_frame_host,
                                const Extension* extension);
   void UnregisterRenderFrameHost(content::RenderFrameHost* render_frame_host);
@@ skipping 21 matching lines @@
   // Incognito.
   virtual bool CreateBackgroundHost(const Extension* extension,
                                     const GURL& url);
 
   // Creates background hosts if the embedder is ready and they are not already
   // loaded.
   void MaybeCreateStartupBackgroundHosts();
 
   // Gets the ExtensionHost for the background page for an extension, or null if
   // the extension isn't running or doesn't have a background page.
-  ExtensionHost* GetBackgroundHostForExtension(const std::string& extension_id);
+  virtual ExtensionHost* GetBackgroundHostForExtension(

[not at google - send to devlin, 2015/04/28 21:35:11]

Doesn't need to be virtual anymore.

+      const std::string& extension_id);
 
   // Returns true if the (lazy) background host for the given extension has
   // already been sent the unload event and is shutting down.
   bool IsBackgroundHostClosing(const std::string& extension_id);
 
   // Returns the extension associated with the specified RenderFrameHost/
   // WebContents, or null.
   const Extension* GetExtensionForRenderFrameHost(
       content::RenderFrameHost* render_frame_host);
   const Extension* GetExtensionForWebContents(
@@ skipping 39 matching lines @@
   void CloseBackgroundHosts();
 
   // Sets callbacks for testing keepalive impulse behavior.
   using ImpulseCallbackForTesting =
       base::Callback<void(const std::string& extension_id)>;
   void SetKeepaliveImpulseCallbackForTesting(
       const ImpulseCallbackForTesting& callback);
   void SetKeepaliveImpulseDecrementCallbackForTesting(
       const ImpulseCallbackForTesting& callback);
 
+  // EventPageTracker implementation.
+  bool IsEventPageSuspended(const std::string& extension_id) override;
+  bool WakeEventPage(const std::string& extension_id,
+                     const base::Callback<void(bool)>& callback) override;
+
   // Sets the time in milliseconds that an extension event page can
   // be idle before it is shut down; must be > 0.
   static void SetEventPageIdleTimeForTesting(unsigned idle_time_msec);
 
   // Sets the time in milliseconds that an extension event page has
   // between being notified of its impending unload and that unload
   // happening.
   static void SetEventPageSuspendingTimeForTesting(
       unsigned suspending_time_msec);
 
@@ skipping 146 matching lines @@
 
   // Must be last member, see doc on WeakPtrFactory.
   base::WeakPtrFactory<ProcessManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessManager);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_PROCESS_MANAGER_H_