Relanding with v8 fix....

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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
+#include "base/logging.h"
 #include "base/shared_memory.h"
 #include "base/stats_table.h"
 #include "base/thread_local.h"
 #include "chrome/common/appcache/appcache_dispatcher.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/db_message_filter.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/renderer_preferences.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/plugin/npobject_util.h"
@@ skipping 29 matching lines @@
 #if defined(OS_WIN)
 #include <windows.h>
 #include <objbase.h>
 #endif
 
 using WebKit::WebCache;
 using WebKit::WebString;
 
 namespace {
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
+static const double kInitialIdleHandlerDelayS = 1.0 /* 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.
     //
     // This is because the terminate signals (ViewMsg_ShouldClose and the error
@@ skipping 27 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
 
   plugin_refresh_allowed_ = true;
-  cache_stats_factory_.reset(
-      new ScopedRunnableMethodFactory<RenderThread>(this));
+  cache_stats_task_pending_ = false;
+  widget_count_ = 0;
+  hidden_widget_count_ = 0;
+  idle_notification_delay_in_s_ = 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();
   AddFilter(db_message_filter_.get());
@@ skipping 29 matching lines @@
 }
 
 void RenderThread::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
   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);
+  }
+}
+
+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.
+}
+
 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);
 }
 
 void RenderThread::OnUpdateVisitedLinks(base::SharedMemoryHandle table) {
   DCHECK(base::SharedMemory::IsHandleValid(table)) << "Bad table handle";
@@ skipping 140 matching lines @@
 
 void RenderThread::OnGetRendererHistograms(int sequence_number) {
   SendHistograms(sequence_number);
 }
 
 void RenderThread::InformHostOfCacheStats() {
   EnsureWebKitInitialized();
   WebCache::UsageStats stats;
   WebCache::getUsageStats(&stats);
   Send(new ViewHostMsg_UpdatedCacheStats(stats));
+  cache_stats_task_pending_ = false;
 }
 
 void RenderThread::InformHostOfCacheStatsLater() {
   // Rate limit informing the host of our cache stats.
-  if (!cache_stats_factory_->empty())
+  if (cache_stats_task_pending_)
     return;
 
+  cache_stats_task_pending_ = true;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      cache_stats_factory_->NewRunnableMethod(
+      task_factory_->NewRunnableMethod(
           &RenderThread::InformHostOfCacheStats),
       kCacheStatsDelayMS);
 }
 
 void RenderThread::CloseIdleConnections() {
   Send(new ViewHostMsg_CloseIdleConnections());
 }
 
 void RenderThread::SetCacheMode(bool enabled) {
   Send(new ViewHostMsg_SetCacheMode(enabled));
@@ skipping 79 matching lines @@
     WebKit::enableMediaPlayer();
 
   // Note: We are forcing --enable-databases to on with --enable-extensions so
   // that extension developers can test databases.
   if (command_line.HasSwitch(switches::kEnableDatabases) ||
       command_line.HasSwitch(switches::kEnableExtensions)) {
     WebKit::enableDatabases();
   }
 }
 
+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 (v8::V8::IsDead())
+    return;
+
+  LOG(INFO) << "RenderThread calling v8 IdleNotification for " << this;
+
+  // When V8::IdleNotification returns true, it means that it has cleaned up
+  // as much as it can.  There is no point in continuing to call it.
+  if (!v8::V8::IdleNotification(false)) {
+    // 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, ...
+    idle_notification_delay_in_s_ +=
+        1.0 / (idle_notification_delay_in_s_ + 2.0);
+
+    // 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::OnExtensionMessageInvoke(const std::string& function_name,
                                             const ListValue& args) {
   RendererExtensionBindings::Invoke(function_name, args, NULL);
 }
 
 void RenderThread::OnPurgePluginListCache() {
   // The call below will cause a GetPlugins call with refresh=true, but at this
   // point we already know that the browser has refreshed its list, so disable
   // refresh temporarily to prevent each renderer process causing the list to be
   // regenerated.
   plugin_refresh_allowed_ = false;
   WebKit::resetPluginCache();
   plugin_refresh_allowed_ = true;
 }