Remove keep-alive impulse IPCs from NaCl modules.

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 <stdint.h>
 
 #include <map>
@@ skipping 104 matching lines @@
 
   // Getter and setter for the lazy background page's keepalive count. This is
   // the count of how many outstanding "things" are keeping the page alive.
   // When this reaches 0, we will begin the process of shutting down the page.
   // "Things" include pending events, resource loads, and API calls.
   // Returns -1 if |extension| does not have a lazy background page.
   int GetLazyKeepaliveCount(const Extension* extension);
   void IncrementLazyKeepaliveCount(const Extension* extension);
   void DecrementLazyKeepaliveCount(const Extension* extension);
 
-  // Keeps a background page alive. Unlike IncrementLazyKeepaliveCount, these
-  // impulses will only keep the page alive for a limited amount of time unless
-  // called regularly.
-  void KeepaliveImpulse(const Extension* extension);
-
-  // Triggers a keepalive impulse for a plugin (e.g NaCl).
-  static void OnKeepaliveFromPlugin(int render_process_id,
-                                    int render_frame_id,
-                                    const std::string& extension_id);
-
   // Handles a response to the ShouldSuspend message, used for lazy background
   // pages.
   void OnShouldSuspendAck(const std::string& extension_id,
                           uint64_t sequence_id);
 
   // Same as above, for the Suspend message.
   void OnSuspendAck(const std::string& extension_id);
 
   // Tracks network requests for a given RenderFrameHost, used to know
   // when network activity is idle for lazy background pages.
   void OnNetworkRequestStarted(content::RenderFrameHost* render_frame_host,
                                uint64_t request_id);
   void OnNetworkRequestDone(content::RenderFrameHost* render_frame_host,
                             uint64_t request_id);
 
   // Prevents |extension|'s background page from being closed and sends the
   // onSuspendCanceled() event to it.
   void CancelSuspend(const Extension* extension);
 
   // Called on shutdown to close our extension hosts.
   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
@@ skipping 77 matching lines @@
 
   // If the frame is keeping the lazy background page alive, decrements the
   // keepalive count to stop doing it.
   void ReleaseLazyKeepaliveCountForFrame(
       content::RenderFrameHost* render_frame_host);
 
   // Internal implementation of DecrementLazyKeepaliveCount with an
   // |extension_id| known to have a lazy background page.
   void DecrementLazyKeepaliveCount(const std::string& extension_id);
 
-  // Checks if keepalive impulses have occured, and adjusts keep alive count.
-  void OnKeepaliveImpulseCheck();
-
   // These are called when the extension transitions between idle and active.
   // They control the process of closing the background page when idle.
   void OnLazyBackgroundPageIdle(const std::string& extension_id,
                                 uint64_t sequence_id);
   void OnLazyBackgroundPageActive(const std::string& extension_id);
   void CloseLazyBackgroundPageNow(const std::string& extension_id,
                                   uint64_t sequence_id);
 
   const Extension* GetExtensionForAgentHost(
       content::DevToolsAgentHost* agent_host);
@@ skipping 27 matching lines @@
   // Contains all active extension-related RenderFrameHost instances for all
   // extensions. We also keep a cache of the host's view type, because that
   // information is not accessible at registration/deregistration time.
   ExtensionRenderFrames all_extension_frames_;
 
   BackgroundPageDataMap background_page_data_;
 
   // True if we have created the startup set of background hosts.
   bool startup_background_hosts_created_;
 
-  ImpulseCallbackForTesting keepalive_impulse_callback_for_testing_;
-  ImpulseCallbackForTesting keepalive_impulse_decrement_callback_for_testing_;
-
   base::ObserverList<ProcessManagerObserver> observer_list_;
 
   // ID Counter used to set ProcessManager::BackgroundPageData close_sequence_id
   // members. These IDs are tracked per extension in background_page_data_ and
   // are used to verify that nothing has interrupted the process of closing a
   // lazy background process.
   //
   // Any interruption obtains a new ID by incrementing
   // last_background_close_sequence_id_ and storing it in background_page_data_
   // for a particular extension. Callbacks and round-trip IPC messages store the
@@ skipping 13 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_