Schedule idle handler in the foreground tab based on CPU usage and user activity.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2011 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 83 matching lines @@
 using WebKit::WebNetworkStateNotifier;
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebScriptController;
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 using content::RenderProcessObserver;
 
 namespace {
 static const int64 kInitialIdleHandlerDelayMs = 1000;
+static const int64 kShortIdleHandlerDelayMs = 1000;
+static const int64 kLongIdleHandlerDelayMs = 30*1000;
+static const int kIdleCPUUsageThresholdInPercents = 3;
 
 #if defined(TOUCH_UI)
 static const int kPopupListBoxMinimumRowHeight = 60;
 #endif
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 static base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> >
     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 72 matching lines @@
     initialize_com_.reset(new base::win::ScopedCOMInitializer());
 #endif
 
   // In single process the single process is all there is.
   suspend_webkit_shared_timer_ = true;
   notify_webkit_of_modal_loop_ = true;
   plugin_refresh_allowed_ = true;
   widget_count_ = 0;
   hidden_widget_count_ = 0;
   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
+  idle_notifications_to_skip_ = 0;
+  base::ProcessHandle handle = base::GetCurrentProcessHandle();
+#if defined(OS_MACOSX)
+  process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle,
+                                                                    NULL));
+#else
+  process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
+#endif
+  process_metrics_->GetCPUUsage(); // Initialize CPU usage counters.
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThreadImpl>(this));
 
   appcache_dispatcher_.reset(new AppCacheDispatcher(Get()));
   indexed_db_dispatcher_.reset(new IndexedDBDispatcher());
 
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
   vc_manager_ = new VideoCaptureImplManager();
   AddFilter(vc_manager_->video_capture_message_filter());
@@ skipping 202 matching lines @@
 }
 
 void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
   if (!content::GetContentClient()->renderer()->
           RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
-  idle_timer_.Stop();
+  ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {
   if (webkit_platform_support_.get())
     return;
 
   v8::V8::SetCounterFunction(base::StatsTable::FindLocation);
   v8::V8::SetCreateHistogramFunction(CreateHistogram);
   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 
@@ skipping 88 matching lines @@
 
   WebRuntimeFeatures::enableFileSystem(
       !command_line.HasSwitch(switches::kDisableFileSystem));
 
   WebRuntimeFeatures::enableJavaScriptI18NAPI(
       !command_line.HasSwitch(switches::kDisableJavaScriptI18NAPI));
 
   WebRuntimeFeatures::enableQuota(true);
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
+
+  if (content::GetContentClient()->renderer()->
+         RunIdleHandlerWhenWidgetsHidden()) {
+    ScheduleIdleHandler(kLongIdleHandlerDelayMs);
+  }
 }
 
 void RenderThreadImpl::RecordUserMetrics(const std::string& action) {
   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 }
 
 base::SharedMemoryHandle RenderThreadImpl::HostAllocateSharedMemoryBuffer(
     uint32 buffer_size) {
   base::SharedMemoryHandle mem_handle;
   Send(new ChildProcessHostMsg_SyncAllocateSharedMemory(
@@ skipping 13 matching lines @@
 
 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
   idle_notification_delay_in_ms_ = initial_delay_ms;
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {
-  #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
+  bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
+                               content::GetContentClient()->renderer()->
+                                   RunIdleHandlerWhenWidgetsHidden();
+  if (run_in_foreground_tab) {
+    IdleHandlerInForegroundTab();
+    return;
+  }
+#if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
   MallocExtension::instance()->ReleaseFreeMemory();
 #endif
 
   v8::V8::IdleNotification();
 
   // Schedule next invocation.
   // Dampen the delay using the algorithm (if delay is in seconds):
   //    delay = delay + 1 / (delay + 2)
   // Using floor(delay) has a dampening effect such as:
   //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
   // If the delay is in milliseconds, the above formula is equivalent to:
   //    delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
   // which is equivalent to
   //    delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
   // Note that idle_notification_delay_in_ms_ would be reset to
   // kInitialIdleHandlerDelayMs in RenderThreadImpl::WidgetHidden.
   ScheduleIdleHandler(idle_notification_delay_in_ms_ +
                       1000000 / (idle_notification_delay_in_ms_ + 2000));
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 }
 
+void RenderThreadImpl::IdleHandlerInForegroundTab() {
+  // Increase the delay in the same way as in IdleHandler,
+  // but make it periodic by reseting it once it is too big.
+  int64 new_delay_ms = idle_notification_delay_in_ms_ +
+                       1000000 / (idle_notification_delay_in_ms_ + 2000);
+  if (new_delay_ms >= kLongIdleHandlerDelayMs)
+    new_delay_ms = kShortIdleHandlerDelayMs;
+
+  // Sample the CPU usage on each timer event, so that it is more accurate.
+  double cpu_usage = process_metrics_->GetCPUUsage();
+
+  if (idle_notifications_to_skip_ > 0) {
+    idle_notifications_to_skip_--;
+  } else if (cpu_usage < kIdleCPUUsageThresholdInPercents) {
+    if (v8::V8::IdleNotification()) {
+      // V8 finished collecting garbage.
+      new_delay_ms = kLongIdleHandlerDelayMs;
+    }
+  }
+
+  ScheduleIdleHandler(new_delay_ms);
+}
+
 int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
   return idle_notification_delay_in_ms_;
 }
 
 void RenderThreadImpl::SetIdleNotificationDelayInMs(
     int64 idle_notification_delay_in_ms) {
   idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
 }
 
+void RenderThreadImpl::PostponeIdleNotification() {
+  idle_notifications_to_skip_ = 2;
+}
+
 #if defined(OS_WIN)
 void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
 void RenderThreadImpl::ReleaseCachedFonts() {
   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
 
 #endif  // OS_WIN
@@ skipping 183 matching lines @@
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }