Convert render thread idle delays from seconds to milliseconds.

chrome/renderer/extensions/extension_dispatcher.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 "chrome/renderer/extensions/extension_dispatcher.h"
 
 #include "base/command_line.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 14 matching lines @@
 #include "content/public/renderer/render_thread.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "v8/include/v8.h"
 
 namespace {
-static const double kInitialExtensionIdleHandlerDelayS = 5.0 /* seconds */;
-static const int64 kMaxExtensionIdleHandlerDelayS = 5*60 /* seconds */;
+static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000 /* ms */;

[jam, 2011/11/11 18:10:10]

nit, the "/* ms */" is redundant since Ms is in the constant's name

+static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000 /* ms */;
 }
 
 using WebKit::WebDataSource;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using content::RenderThread;
 
 ExtensionDispatcher::ExtensionDispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
       webrequest_other_(false) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(switches::kSingleProcess);
 
   if (is_extension_process_) {
-    RenderThread::Get()->SetIdleNotificationDelayInS(
-        kInitialExtensionIdleHandlerDelayS);
+    RenderThread::Get()->SetIdleNotificationDelayInMs(
+        kInitialExtensionIdleHandlerDelayMs);
   }
 
   user_script_slave_.reset(new UserScriptSlave(&extensions_));
 }
 
 ExtensionDispatcher::~ExtensionDispatcher() {
 }
 
 bool ExtensionDispatcher::OnControlMessageReceived(
     const IPC::Message& message) {
@@ skipping 15 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void ExtensionDispatcher::WebKitInitialized() {
   // 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(FROM_HERE,
-        base::TimeDelta::FromSeconds(kMaxExtensionIdleHandlerDelayS),
+        base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
         RenderThread::Get(), &RenderThread::IdleHandler);
   }
 
   RegisterExtension(new AppBindings(this), false);
   RegisterExtension(ChromeWebstoreExtension::Get(), false);
 
   // Add v8 extensions related to chrome extensions.
   RegisterExtension(new ChromeV8Extension(
       "extensions/json_schema.js", IDR_JSON_SCHEMA_JS, NULL), true);
   RegisterExtension(EventBindings::Get(this), true);
@@ skipping 12 matching lines @@
       InitOriginPermissions(extension);
   }
 
   is_webkit_initialized_ = true;
 }
 
 void ExtensionDispatcher::IdleNotification() {
   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>(
-        RenderThread::Get()->GetIdleNotificationDelayInS()),
-        kMaxExtensionIdleHandlerDelayS);
+    int64 forced_delay_ms = std::max(
+        RenderThread::Get()->GetIdleNotificationDelayInMs(),
+        kMaxExtensionIdleHandlerDelayMs);
     forced_idle_timer_.Stop();
     forced_idle_timer_.Start(FROM_HERE,
-        base::TimeDelta::FromSeconds(forced_delay_s),
+        base::TimeDelta::FromMilliseconds(forced_delay_ms),
         RenderThread::Get(), &RenderThread::IdleHandler);
   }
 }
 
 void ExtensionDispatcher::OnSetFunctionNames(
     const std::vector<std::string>& names) {
   function_names_.clear();
   for (size_t i = 0; i < names.size(); ++i)
     function_names_.insert(names[i]);
 }
 
 void ExtensionDispatcher::OnMessageInvoke(const std::string& extension_id,
                                           const std::string& function_name,
                                           const ListValue& args,
                                           const GURL& event_url) {
   v8_context_set_.DispatchChromeHiddenMethod(
       extension_id, function_name, args, NULL, event_url);
 
   // 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_) {
     RenderThread::Get()->ScheduleIdleHandler(
-        kInitialExtensionIdleHandlerDelayS);
+        kInitialExtensionIdleHandlerDelayMs);
   }
 
   // Tell the browser process that the event is dispatched and we're idle.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableLazyBackgroundPages) &&
       function_name == "Event.dispatchJSON") { // may always be true
     RenderThread::Get()->Send(
         new ExtensionHostMsg_ExtensionEventAck(extension_id));
     CheckIdleStatus(extension_id);
   }
@@ skipping 127 matching lines @@
     const std::string& extension_id) {
   active_application_ids_.insert(extension_id);
 }
 
 void ExtensionDispatcher::OnActivateExtension(
     const std::string& extension_id) {
   active_extension_ids_.insert(extension_id);
 
   // This is called when starting a new extension page, so start the idle
   // handler ticking.
-  RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayS);
+  RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
   UpdateActiveExtensions();
 
   const Extension* extension = extensions_.GetByID(extension_id);
   if (!extension)
     return;
 
   if (is_webkit_initialized_)
     InitOriginPermissions(extension);
 }
@@ skipping 94 matching lines @@
 
   RenderThread::Get()->RegisterExtension(extension);
 }
 
 void ExtensionDispatcher::OnUsingWebRequestAPI(
     bool adblock, bool adblock_plus, bool other) {
   webrequest_adblock_ = adblock;
   webrequest_adblock_plus_ = adblock_plus;
   webrequest_other_ = other;
 }