Remove the --event-page-idle-time and --event-page-suspending-time switches.

extensions/browser/process_manager.cc

 // 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.
 
 #include "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager_delegate.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/one_shot_event.h"
-#include "extensions/common/switches.h"
 
 using content::BrowserContext;
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
 
 namespace extensions {
 class RenderViewHostDestructionObserver;
 }
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     extensions::RenderViewHostDestructionObserver);
 
 namespace extensions {
 
 namespace {
 
+// The time to delay between an extension becoming idle and
+// sending a ShouldSuspend message.
+// Note: Must be sufficiently larger (e.g. 2x) than
+// kKeepaliveThrottleIntervalInSeconds in ppapi/proxy/plugin_globals.
+unsigned g_event_page_idle_time_msec = 10000;
+
+// The time to delay between sending a ShouldSuspend message and
+// sending a Suspend message.
+unsigned g_event_page_suspending_time_msec = 5000;
+
 std::string GetExtensionID(RenderViewHost* render_view_host) {
   // This works for both apps and extensions because the site has been
   // normalized to the extension URL for hosted apps.
   content::SiteInstance* site_instance = render_view_host->GetSiteInstance();
   if (!site_instance)
     return std::string();
 
   const GURL& site_url = site_instance->GetSiteURL();
 
   if (!site_url.SchemeIs(kExtensionScheme) &&
@@ skipping 189 matching lines @@
                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  content::Source<BrowserContext>(context));
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllSources());
 
-  // Note: event_page_idle_time_ must be sufficiently larger (e.g. 2x) than
-  // kKeepaliveThrottleIntervalInSeconds in ppapi/proxy/plugin_globals.
-  event_page_idle_time_ = base::TimeDelta::FromSeconds(10);
-  unsigned idle_time_msec = 0;
-  if (base::StringToUint(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          extensions::switches::kEventPageIdleTime), &idle_time_msec)) {
-    CHECK_GT(idle_time_msec, 0u);  // OnKeepaliveImpulseCheck requires non zero.
-    event_page_idle_time_ = base::TimeDelta::FromMilliseconds(idle_time_msec);
-  }
-  event_page_suspending_time_ = base::TimeDelta::FromSeconds(5);
-  unsigned suspending_time_msec = 0;
-  if (base::StringToUint(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-                             extensions::switches::kEventPageSuspendingTime),
-                         &suspending_time_msec)) {
-    event_page_suspending_time_ =
-        base::TimeDelta::FromMilliseconds(suspending_time_msec);
-  }
-
   content::DevToolsAgentHost::AddAgentStateCallback(devtools_callback_);
 
   OnKeepaliveImpulseCheck();
 }
 
 ProcessManager::~ProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
   content::DevToolsAgentHost::RemoveAgentStateCallback(devtools_callback_);
 }
@@ skipping 160 matching lines @@
   // before initiating another close sequence.
   if (--count == 0 && !background_page_data_[extension_id].is_closing) {
     background_page_data_[extension_id].close_sequence_id =
         ++last_background_close_sequence_id_;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ProcessManager::OnLazyBackgroundPageIdle,
                    weak_ptr_factory_.GetWeakPtr(),
                    extension_id,
                    last_background_close_sequence_id_),
-        event_page_idle_time_);
+        base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
   }
 }
 
 void ProcessManager::IncrementLazyKeepaliveCountForView(
     RenderViewHost* render_view_host) {
   WebContents* web_contents =
       WebContents::FromRenderViewHost(render_view_host);
   ViewType view_type = GetViewType(web_contents);
   if (view_type != VIEW_TYPE_INVALID &&
       view_type != VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
@@ skipping 48 matching lines @@
     return;
 
   ProcessManager* pm = ExtensionSystem::Get(browser_context)->process_manager();
   if (!pm)
     return;
 
   pm->KeepaliveImpulse(extension);
 }
 
 // DecrementLazyKeepaliveCount is called when no calls to KeepaliveImpulse
-// have been made for at least event_page_idle_time_. In the best case an
+// have been made for at least g_event_page_idle_time_msec. In the best case an
 // impulse was made just before being cleared, and the decrement will occur
-// event_page_idle_time_ later, causing a 2 * event_page_idle_time_ total time
-// for extension to be shut down based on impulses. Worst case is an impulse
-// just after a clear, adding one check cycle and resulting in 3x total time.
+// g_event_page_idle_time_msec later, causing a 2 * g_event_page_idle_time_msec
+// total time for extension to be shut down based on impulses. Worst case is
+// an impulse just after a clear, adding one check cycle and resulting in 3x
+// total time.
 void ProcessManager::OnKeepaliveImpulseCheck() {
   for (BackgroundPageDataMap::iterator i = background_page_data_.begin();
        i != background_page_data_.end();
        ++i) {
     if (i->second.previous_keepalive_impulse && !i->second.keepalive_impulse) {
       DecrementLazyKeepaliveCount(i->first);
       if (!keepalive_impulse_decrement_callback_for_testing_.is_null()) {
         ImpulseCallbackForTesting callback_may_clear_callbacks_reentrantly =
           keepalive_impulse_decrement_callback_for_testing_;
         callback_may_clear_callbacks_reentrantly.Run(i->first);
       }
     }
 
     i->second.previous_keepalive_impulse = i->second.keepalive_impulse;
     i->second.keepalive_impulse = false;
   }
 
   // OnKeepaliveImpulseCheck() is always called in constructor, but in unit
   // tests there will be no message loop. In that event don't schedule tasks.
   if (base::MessageLoop::current()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ProcessManager::OnKeepaliveImpulseCheck,
                    weak_ptr_factory_.GetWeakPtr()),
-        event_page_idle_time_);
+        base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
   }
 }
 
 void ProcessManager::OnLazyBackgroundPageIdle(const std::string& extension_id,
                                               uint64 sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host && !background_page_data_[extension_id].is_closing &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     // Tell the renderer we are about to close. This is a simple ping that the
     // renderer will respond to. The purpose is to control sequencing: if the
@@ skipping 24 matching lines @@
     host->render_view_host()->Send(new ExtensionMsg_Suspend(extension_id));
   }
 }
 
 void ProcessManager::OnSuspendAck(const std::string& extension_id) {
   background_page_data_[extension_id].is_closing = true;
   uint64 sequence_id = background_page_data_[extension_id].close_sequence_id;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ProcessManager::CloseLazyBackgroundPageNow,
-                 weak_ptr_factory_.GetWeakPtr(), extension_id, sequence_id),
-      event_page_suspending_time_);
+                 weak_ptr_factory_.GetWeakPtr(),
+                 extension_id,
+                 sequence_id),
+      base::TimeDelta::FromMilliseconds(g_event_page_suspending_time_msec));
 }
 
 void ProcessManager::CloseLazyBackgroundPageNow(const std::string& extension_id,
                                                 uint64 sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
     if (host)
       CloseBackgroundHost(host);
@@ skipping 47 matching lines @@
 void ProcessManager::SetKeepaliveImpulseCallbackForTesting(
     const ImpulseCallbackForTesting& callback) {
   keepalive_impulse_callback_for_testing_ = callback;
 }
 
 void ProcessManager::SetKeepaliveImpulseDecrementCallbackForTesting(
     const ImpulseCallbackForTesting& callback) {
   keepalive_impulse_decrement_callback_for_testing_ = callback;
 }
 
+// static
+void ProcessManager::SetEventPageIdleTimeForTesting(unsigned idle_time_msec) {
+  CHECK_GT(idle_time_msec, 0u);  // OnKeepaliveImpulseCheck requires non zero.
+  g_event_page_idle_time_msec = idle_time_msec;
+}
+
+// static
+void ProcessManager::SetEventPageSuspendingTimeForTesting(
+    unsigned suspending_time_msec) {
+  g_event_page_suspending_time_msec = suspending_time_msec;
+}
+
 void ProcessManager::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED: {
       // TODO(jamescook): Convert this to use ExtensionSystem::ready() instead
       // of a notification.
       MaybeCreateStartupBackgroundHosts();
       break;
     }
@@ skipping 255 matching lines @@
 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
   const Extension* extension =
       extension_registry_->enabled_extensions().GetExtensionOrAppByURL(url);
   if (extension && !IncognitoInfo::IsSplitMode(extension))
     return original_manager_->GetSiteInstanceForURL(url);
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions