Convert render thread idle delays from seconds to milliseconds.

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 82 matching lines @@
 using WebKit::WebFrame;
 using WebKit::WebNetworkStateNotifier;
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebScriptController;
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 using content::RenderProcessObserver;
 
 namespace {
-static const double kInitialIdleHandlerDelayS = 1.0 /* seconds */;
+static const int64 kInitialIdleHandlerDelayMs = 1000 /* ms */;
 
 #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(
     base::LINKER_INITIALIZED);
 
@@ skipping 71 matching lines @@
   if (RenderProcessImpl::InProcessPlugins())
     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_s_ = kInitialIdleHandlerDelayS;
+  idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
   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 191 matching lines @@
 void RenderThreadImpl::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
 
   if (!content::GetContentClient()->renderer()->
           RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   if (widget_count_ && hidden_widget_count_ == widget_count_)
-    ScheduleIdleHandler(kInitialIdleHandlerDelayS);
+    ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
   if (!content::GetContentClient()->renderer()->
           RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
@@ skipping 124 matching lines @@
 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
   v8_extensions_.insert(extension->name());
 }
 
 bool RenderThreadImpl::IsRegisteredExtension(
     const std::string& v8_extension_name) const {
   return v8_extensions_.find(v8_extension_name) != v8_extensions_.end();
 }
 
-void RenderThreadImpl::ScheduleIdleHandler(double initial_delay_s) {
-  idle_notification_delay_in_s_ = initial_delay_s;
+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::FromSeconds(static_cast<int64>(initial_delay_s)),
+      base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {
   #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
   MallocExtension::instance()->ReleaseFreeMemory();
 #endif
 
   v8::V8::IdleNotification();
 
   // Schedule next invocation.
-  // Dampen the delay using the algorithm:
+  // 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, ...
-  // Note that idle_notification_delay_in_s_ would be reset to
-  // kInitialIdleHandlerDelayS in RenderThreadImpl::WidgetHidden.
-  ScheduleIdleHandler(idle_notification_delay_in_s_ +
-                      1.0 / (idle_notification_delay_in_s_ + 2.0));
+  // 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));

[ulan, 2011/11/11 17:10:03]

Since this computation is in integers, it is not exactly equivalent to the old
version in doubles. The error however is negligible: after a year of running the
error will be less than 40 seconds as demonstrated by the following program:

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int main() {
  double s = 1.0;
  long long ms = 1000;
  double error_s = 0;
  double total_time_s = s;
  for (int i = 0; i < 100000; ++i) {
    s = s + 1.0 / (s + 2.0);
    ms = ms + 1000000 / (ms + 2000);
    error_s = max(error_s, fabs(s - ms / 1000.0));
    total_time_s += s;
  }
  printf("%.3lf - %.3lf = %.3lf\n", s, ms / 1000.0, s - ms / 1000.0);
  printf("error %.3lf after %.lf days\n", error_s, total_time_s / 3600 / 24);
  return 0;
}

 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 }
 
-double RenderThreadImpl::GetIdleNotificationDelayInS() const {
-  return idle_notification_delay_in_s_;
+int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
+  return idle_notification_delay_in_ms_;
 }
 
-void RenderThreadImpl::SetIdleNotificationDelayInS(
-    double idle_notification_delay_in_s) {
-  idle_notification_delay_in_s_ = idle_notification_delay_in_s;
+void RenderThreadImpl::SetIdleNotificationDelayInMs(
+    int64 idle_notification_delay_in_ms) {
+  idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
 }
 
 #if defined(OS_WIN)
 void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
 void RenderThreadImpl::ReleaseCachedFonts() {
   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
@@ skipping 185 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();
 }