Hook up V8 idle notifications for extension prcoesses.

chrome/renderer/render_thread.cc

 // Copyright (c) 2009 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 "chrome/renderer/render_thread.h"
 
 #include <v8.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 75 matching lines @@
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebScriptController;
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 
 namespace {
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
 static const double kInitialIdleHandlerDelayS = 1.0 /* seconds */;
+static const double kInitialExtensionIdleHandlerDelayS = 5.0 /* seconds */;
+static const int64 kMaxExtensionIdleHandlerDelayS = 5*60 /* seconds */;
 
 static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
     base::LINKER_INITIALIZED);
 
 #if defined(OS_POSIX)
 class SuicideOnChannelErrorFilter : public IPC::ChannelProxy::MessageFilter {
   void OnChannelError() {
     // On POSIX, at least, one can install an unload handler which loops
     // forever and leave behind a renderer process which eats 100% CPU forever.
     //
@@ skipping 48 matching lines @@
 
 void RenderThread::Init() {
   lazy_tls.Pointer()->Set(this);
 #if defined(OS_WIN)
   // If you are running plugins in this thread you need COM active but in
   // the normal case you don't.
   if (RenderProcess::InProcessPlugins())
     CoInitialize(0);
 #endif
 
+  std::string type_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      switches::kProcessType);
+  is_extension_process_ = type_str == switches::kExtensionProcess;
   plugin_refresh_allowed_ = true;
   cache_stats_task_pending_ = false;
   widget_count_ = 0;
   hidden_widget_count_ = 0;
-  idle_notification_delay_in_s_ = kInitialIdleHandlerDelayS;
+  idle_notification_delay_in_s_ = is_extension_process_ ?
+      kInitialExtensionIdleHandlerDelayS : kInitialIdleHandlerDelayS;
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThread>(this));
 
   visited_link_slave_.reset(new VisitedLinkSlave());
   user_script_slave_.reset(new UserScriptSlave());
   dns_master_.reset(new RenderDnsMaster());
   histogram_snapshots_.reset(new RendererHistogramSnapshots());
   appcache_dispatcher_.reset(new AppCacheDispatcher(this));
   devtools_agent_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_filter_.get());
   db_message_filter_ = new DBMessageFilter();
@@ skipping 34 matching lines @@
   channel()->AddFilter(filter);
 }
 
 void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
 void RenderThread::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
-  if (widget_count_ && hidden_widget_count_ == widget_count_) {
-    // Reset the delay.
-    idle_notification_delay_in_s_ = kInitialIdleHandlerDelayS;
-
-    // Schedule the IdleHandler to wakeup in a bit.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        task_factory_->NewRunnableMethod(&RenderThread::IdleHandler),
-        static_cast<int64>(floor(idle_notification_delay_in_s_)) * 1000);
-  }
+  if (!is_extension_process() &&
+      widget_count_ && hidden_widget_count_ == widget_count_)
+    ScheduleIdleHandler(kInitialIdleHandlerDelayS);
 }
 
 void RenderThread::WidgetRestored() {
   DCHECK(hidden_widget_count_ > 0);
   hidden_widget_count_--;
-
-  // Note: we may have a timer pending to call the IdleHandler (see the
-  // WidgetHidden() code).  But we don't bother to cancel it as it is
-  // benign and won't do anything if the tab is un-hidden when it is
-  // called.
+  if (!is_extension_process())
+    idle_timer_.Stop();
 }
 
 void RenderThread::Resolve(const char* name, size_t length) {
   return dns_master_->Resolve(name, length);
 }
 
 void RenderThread::SendHistograms(int sequence_number) {
   return histogram_snapshots_->SendHistograms(sequence_number);
 }
 
@@ skipping 32 matching lines @@
 void RenderThread::OnPageActionsUpdated(
     const std::string& extension_id,
     const std::vector<std::string>& page_actions) {
   ExtensionProcessBindings::SetPageActions(extension_id, page_actions);
 }
 
 void RenderThread::OnExtensionSetAPIPermissions(
     const std::string& extension_id,
     const std::vector<std::string>& permissions) {
   ExtensionProcessBindings::SetAPIPermissions(extension_id, permissions);
+
+  // This is called when starting a new extension page, so start the idle
+  // handler ticking.
+  DCHECK(is_extension_process());
+  ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayS);
 }
 
 void RenderThread::OnExtensionSetHostPermissions(
     const GURL& extension_url, const std::vector<URLPattern>& permissions) {
   ExtensionProcessBindings::SetHostPermissions(extension_url, permissions);
 }
 
 void RenderThread::OnDOMStorageEvent(
     const ViewMsg_DOMStorageEvent_Params& params) {
   if (!dom_storage_event_dispatcher_.get())
@@ skipping 189 matching lines @@
 
 static void AddHistogramSample(void* hist, int sample) {
   Histogram* histogram = static_cast<Histogram *>(hist);
   histogram->Add(sample);
 }
 
 void RenderThread::EnsureWebKitInitialized() {
   if (webkit_client_.get())
     return;
 
+  // For extensions, we want to ensure we call the IdleHandler every so often,
+  // even if the extension keeps up activity.
+  if (is_extension_process()) {
+    forced_idle_timer_.Start(
+        base::TimeDelta::FromSeconds(kMaxExtensionIdleHandlerDelayS),
+        this, &RenderThread::IdleHandler);
+  }
+
   v8::V8::SetCounterFunction(StatsTable::FindLocation);
   v8::V8::SetCreateHistogramFunction(CreateHistogram);
   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 
   webkit_client_.reset(new RendererWebKitClientImpl);
   WebKit::initialize(webkit_client_.get());
 
   WebScriptController::enableV8SingleThreadMode();
 
   // chrome: pages should not be accessible by normal content, and should
@@ skipping 81 matching lines @@
       !command_line.HasSwitch(switches::kDisableDesktopNotifications));
 #endif
 
   WebRuntimeFeatures::enableLocalStorage(
       !command_line.HasSwitch(switches::kDisableLocalStorage));
   WebRuntimeFeatures::enableSessionStorage(
       command_line.HasSwitch(switches::kEnableSessionStorage));
 }
 
 void RenderThread::IdleHandler() {
-  // It is possible that the timer was set while the widgets were idle,
-  // but that they are no longer idle.  If so, just return.
-  if (!widget_count_ || hidden_widget_count_ < widget_count_)
-    return;
-
 #if defined(OS_WIN) && defined(USE_TCMALLOC)
   MallocExtension::instance()->ReleaseFreeMemory();
 #endif
 
   LOG(INFO) << "RenderThread calling v8 IdleNotification for " << this;
   v8::V8::IdleNotification();
 
   // Schedule next invocation.
   // Dampen the delay using the algorithm:
   //    delay = delay + 1 / (delay + 2)
   // Using floor(delay) has a dampening effect such as:
   //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
   // Note that idle_notification_delay_in_s_ would be reset to
   // kInitialIdleHandlerDelayS in RenderThread::WidgetHidden.
-  idle_notification_delay_in_s_ +=
-      1.0 / (idle_notification_delay_in_s_ + 2.0);
+  ScheduleIdleHandler(idle_notification_delay_in_s_ +
+                      1.0 / (idle_notification_delay_in_s_ + 2.0));
+  if (is_extension_process()) {
+    // Dampen the forced delay as well if the extension stays idle for long
+    // periods of time.
+    int64 forced_delay_s =
+        std::max(static_cast<int64>(idle_notification_delay_in_s_),
+                 kMaxExtensionIdleHandlerDelayS);
+    forced_idle_timer_.Stop();
+    forced_idle_timer_.Start(
+        base::TimeDelta::FromSeconds(forced_delay_s),
+        this, &RenderThread::IdleHandler);
+  }
+}
 
-  // Schedule the next timer.
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      task_factory_->NewRunnableMethod(&RenderThread::IdleHandler),
-      static_cast<int64>(floor(idle_notification_delay_in_s_)) * 1000);
+void RenderThread::ScheduleIdleHandler(double initial_delay_s) {
+  idle_notification_delay_in_s_ = initial_delay_s;
+  idle_timer_.Stop();
+  idle_timer_.Start(
+      base::TimeDelta::FromSeconds(static_cast<int64>(initial_delay_s)),
+      this, &RenderThread::IdleHandler);
 }
 
 void RenderThread::OnExtensionMessageInvoke(const std::string& function_name,
                                             const ListValue& args) {
   RendererExtensionBindings::Invoke(function_name, args, NULL);
+
+  // Reset the idle handler each time there's any activity like event or message
+  // dispatch, for which Invoke is the chokepoint.
+  if (is_extension_process())
+    ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayS);
 }
 
 void RenderThread::OnPurgeMemory() {
   spellchecker_.reset(new SpellCheck());
 
   EnsureWebKitInitialized();
 
   // Clear the object cache (as much as possible; some live objects cannot be
   // freed).
   WebCache::clear();
@@ skipping 43 matching lines @@
   spellchecker_->EnableAutoSpellCorrect(auto_spell_correct);
 }
 
 void RenderThread::OnSpellCheckWordAdded(const std::string& word) {
   spellchecker_->WordAdded(word);
 }
 
 void RenderThread::OnSpellCheckEnableAutoSpellCorrect(bool enable) {
   spellchecker_->EnableAutoSpellCorrect(enable);
 }