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 81 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_