Create content::RenderThread interface and make code in chrome use that.

BUG=98716,98375,10837
Review URL: http://codereview.chromium.org/8165013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@104358 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 346 insertions, 236 deletions

diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi
index bc68a41..e460e85 100644
--- a/content/content_renderer.gypi
+++ b/content/content_renderer.gypi
@@ -28,6 +28,8 @@
     'public/renderer/navigation_state.h',
     'public/renderer/render_process_observer.cc',
     'public/renderer/render_process_observer.h',
+    'public/renderer/render_thread.cc',
+    'public/renderer/render_thread.h',
     'public/renderer/render_view_observer.cc',
     'public/renderer/render_view_observer.h',
     'public/renderer/render_view_observer_tracker.h',
diff --git a/content/public/renderer/render_thread.cc b/content/public/renderer/render_thread.cc
new file mode 100644
index 0000000..3dc536f
--- /dev/null
+++ b/content/public/renderer/render_thread.cc
@@ -0,0 +1,8 @@
+// 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/public/renderer/render_thread.h"
+
+#include "base/lazy_instance.h"
+
diff --git a/content/public/renderer/render_thread.h b/content/public/renderer/render_thread.h
new file mode 100644
index 0000000..3f1e964
--- /dev/null
+++ b/content/public/renderer/render_thread.h
@@ -0,0 +1,101 @@
+// 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.
+
+#ifndef CONTENT_PUBLIC_RENDERER_RENDER_THREAD_H_
+#define CONTENT_PUBLIC_RENDERER_RENDER_THREAD_H_
+
+#include "base/basictypes.h"
+#include "content/common/content_export.h"
+#include "ipc/ipc_channel_proxy.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+class MessageLoop;
+class ResourceDispatcher;
+
+namespace IPC {
+class SyncChannel;
+}
+
+namespace v8 {
+class Extension;
+}
+
+namespace content {
+
+class RenderProcessObserver;
+
+class CONTENT_EXPORT RenderThread : public IPC::Message::Sender {
+ public:
+  // Returns the one render thread for this process.  Note that this can only
+  // be accessed when running on the render thread itself.
+  static RenderThread* Get();
+
+  RenderThread();
+  virtual ~RenderThread();
+
+  virtual MessageLoop* GetMessageLoop() = 0;
+  virtual IPC::SyncChannel* GetChannel() = 0;
+  virtual ResourceDispatcher* GetResourceDispatcher() = 0;
+  virtual std::string GetLocale() = 0;
+
+  // Called to add or remove a listener for a particular message routing ID.
+  // These methods normally get delegated to a MessageRouter.
+  virtual void AddRoute(int32 routing_id, IPC::Channel::Listener* listener) = 0;
+  virtual void RemoveRoute(int32 routing_id) = 0;
+
+  // These map to IPC::ChannelProxy methods.
+  virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
+  virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
+  virtual void SetOutgoingMessageFilter(
+      IPC::ChannelProxy::OutgoingMessageFilter* filter) = 0;
+
+  // Add/remove observers for the process.
+  virtual void AddObserver(content::RenderProcessObserver* observer) = 0;
+  virtual void RemoveObserver(content::RenderProcessObserver* observer) = 0;
+
+  // Called by a RenderWidget when it is hidden or restored.
+  virtual void WidgetHidden() = 0;
+  virtual void WidgetRestored() = 0;
+
+  // We initialize WebKit as late as possible. Call this to force
+  // initialization.
+  virtual void EnsureWebKitInitialized() = 0;
+
+  // Helper function to send over a string to be recorded by user metrics
+  virtual void RecordUserMetrics(const std::string& action) = 0;
+
+  // Registers the given V8 extension with WebKit.
+  virtual void RegisterExtension(v8::Extension* extension) = 0;
+
+  // Returns true iff the extension is registered.
+  virtual bool IsRegisteredExtension(
+      const std::string& v8_extension_name) const = 0;
+
+  // Schedule a call to IdleHandler with the given initial delay.
+  virtual void ScheduleIdleHandler(double initial_delay_s) = 0;
+
+  // A task we invoke periodically to assist with idle cleanup.
+  virtual void IdleHandler() = 0;
+
+  // Get/Set the delay for how often the idle handler is called.
+  virtual double GetIdleNotificationDelayInS() const = 0;
+  virtual void SetIdleNotificationDelayInS(
+      double idle_notification_delay_in_s) = 0;
+
+#if defined(OS_WIN)
+  // Request that the given font be loaded by the browser so it's cached by the
+  // OS. Please see ChildProcessHost::PreCacheFont for details.
+  virtual void PreCacheFont(const LOGFONT& log_font) = 0;
+
+  // Release cached font.
+  virtual void ReleaseCachedFonts() = 0;
+#endif
+};
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_RENDERER_RENDER_THREAD_H_
diff --git a/content/renderer/render_thread.cc b/content/renderer/render_thread.cc
index efd9d98..207236a 100644
--- a/content/renderer/render_thread.cc
+++ b/content/renderer/render_thread.cc
@@ -140,6 +140,29 @@ class RenderViewZoomer : public content::RenderViewVisitor {
 
 }  // namespace
 
+// TODO(jam): move this to content/public/renderer/render_thread.cc once this file is renamed
+namespace content {
+
+// Keep the global RenderThread in a TLS slot so it is impossible to access
+// incorrectly from the wrong thread.
+static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
+    base::LINKER_INITIALIZED);
+
+RenderThread* RenderThread::Get() {
+  return lazy_tls.Pointer()->Get();
+}
+
+RenderThread::RenderThread() {
+  lazy_tls.Pointer()->Set(this);
+}
+
+RenderThread::~RenderThread() {
+  lazy_tls.Pointer()->Set(NULL);
+}
+
+}  // namespace content
+
+
 static void* CreateHistogram(
     const char *name, int min, int max, size_t buckets) {
   if (min <= 0)
@@ -154,6 +177,10 @@ static void AddHistogramSample(void* hist, int sample) {
   histogram->Add(sample);
 }
 
+RenderThread* RenderThread::current() {
+  return lazy_tls.Pointer()->Get();
+}
+
 // When we run plugins in process, we actually run them on the render thread,
 // which means that we need to make the render thread pump UI events.
 RenderThread::RenderThread() {
@@ -190,7 +217,7 @@ void RenderThread::Init() {
   idle_notification_delay_in_s_ = kInitialIdleHandlerDelayS;
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThread>(this));
 
-  appcache_dispatcher_.reset(new AppCacheDispatcher(this));
+  appcache_dispatcher_.reset(new AppCacheDispatcher(Get()));
   indexed_db_dispatcher_.reset(new IndexedDBDispatcher());
 
   db_message_filter_ = new DBMessageFilter();
@@ -260,38 +287,6 @@ RenderThread::~RenderThread() {
 #endif
 }
 
-RenderThread* RenderThread::current() {
-  return lazy_tls.Pointer()->Get();
-}
-
-std::string RenderThread::GetLocale() {
-  // The browser process should have passed the locale to the renderer via the
-  // --lang command line flag.  In single process mode, this will return the
-  // wrong value.  TODO(tc): Fix this for single process mode.
-  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
-  const std::string& lang =
-      parsed_command_line.GetSwitchValueASCII(switches::kLang);
-  DCHECK(!lang.empty() ||
-      (!parsed_command_line.HasSwitch(switches::kRendererProcess) &&
-       !parsed_command_line.HasSwitch(switches::kPluginProcess)));
-  return lang;
-}
-
-int32 RenderThread::RoutingIDForCurrentContext() {
-  int32 routing_id = MSG_ROUTING_CONTROL;
-  if (v8::Context::InContext()) {
-    WebFrame* frame = WebFrame::frameForCurrentContext();
-    if (frame) {
-      RenderView* view = RenderView::FromWebView(frame->view());
-      if (view)
-        routing_id = view->routing_id();
-    }
-  } else {
-    DLOG(WARNING) << "Not called within a script context!";
-  }
-  return routing_id;
-}
-
 bool RenderThread::Send(IPC::Message* msg) {
   // Certain synchronous messages cannot always be processed synchronously by
   // the browser, e.g., Chrome frame communicating with the embedding browser.
@@ -360,6 +355,31 @@ bool RenderThread::Send(IPC::Message* msg) {
   return rv;
 }
 
+MessageLoop* RenderThread::GetMessageLoop() {
+  return message_loop();
+}
+
+IPC::SyncChannel* RenderThread::GetChannel() {
+  return channel();
+}
+
+ResourceDispatcher* RenderThread::GetResourceDispatcher() {
+  return resource_dispatcher();
+}
+
+std::string RenderThread::GetLocale() {
+  // The browser process should have passed the locale to the renderer via the
+  // --lang command line flag.  In single process mode, this will return the
+  // wrong value.  TODO(tc): Fix this for single process mode.
+  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+  const std::string& lang =
+      parsed_command_line.GetSwitchValueASCII(switches::kLang);
+  DCHECK(!lang.empty() ||
+      (!parsed_command_line.HasSwitch(switches::kRendererProcess) &&
+       !parsed_command_line.HasSwitch(switches::kPluginProcess)));
+  return lang;
+}
+
 void RenderThread::AddRoute(int32 routing_id,
                             IPC::Channel::Listener* listener) {
   widget_count_++;
@@ -379,6 +399,18 @@ void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
+void RenderThread::SetOutgoingMessageFilter(
+    IPC::ChannelProxy::OutgoingMessageFilter* filter) {
+}
+
+void RenderThread::AddObserver(content::RenderProcessObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void RenderThread::RemoveObserver(content::RenderProcessObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void RenderThread::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
@@ -403,37 +435,6 @@ void RenderThread::WidgetRestored() {
   idle_timer_.Stop();
 }
 
-void RenderThread::AddObserver(RenderProcessObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void RenderThread::RemoveObserver(RenderProcessObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void RenderThread::DoNotSuspendWebKitSharedTimer() {
-  suspend_webkit_shared_timer_ = false;
-}
-
-void RenderThread::DoNotNotifyWebKitOfModalLoop() {
-  notify_webkit_of_modal_loop_ = false;
-}
-
-void RenderThread::OnSetZoomLevelForCurrentURL(const GURL& url,
-                                               double zoom_level) {
-  RenderViewZoomer zoomer(url, zoom_level);
-  RenderView::ForEach(&zoomer);
-}
-
-void RenderThread::OnDOMStorageEvent(
-    const DOMStorageMsg_Event_Params& params) {
-  if (!dom_storage_event_dispatcher_.get())
-    dom_storage_event_dispatcher_.reset(WebStorageEventDispatcher::create());
-  dom_storage_event_dispatcher_->dispatchStorageEvent(params.key,
-      params.old_value, params.new_value, params.origin, params.url,
-      params.storage_type == DOM_STORAGE_LOCAL);
-}
-
 void RenderThread::EnsureWebKitInitialized() {
   if (webkit_platform_support_.get())
     return;
@@ -461,7 +462,7 @@ void RenderThread::EnsureWebKitInitialized() {
     RegisterExtension(extensions_v8::PlaybackExtension::Get());
   }
 
-  web_database_observer_impl_.reset(new WebDatabaseObserverImpl(this));
+  web_database_observer_impl_.reset(new WebDatabaseObserverImpl(Get()));
   WebKit::WebDatabase::setObserver(web_database_observer_impl_.get());
 
   WebRuntimeFeatures::enableSockets(
@@ -534,26 +535,106 @@ void RenderThread::EnsureWebKitInitialized() {
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 }
 
-// static
 void RenderThread::RecordUserMetrics(const std::string& action) {
-  RenderThread::current()->Send(
-      new ViewHostMsg_UserMetricsRecordAction(action));
+  Send(new ViewHostMsg_UserMetricsRecordAction(action));
+}
+
+void RenderThread::RegisterExtension(v8::Extension* extension) {
+  WebScriptController::registerExtension(extension);
+  v8_extensions_.insert(extension->name());
+}
+
+bool RenderThread::IsRegisteredExtension(
+    const std::string& v8_extension_name) const {
+  return v8_extensions_.find(v8_extension_name) != v8_extensions_.end();
+}
+
+void RenderThread::ScheduleIdleHandler(double initial_delay_s) {
+  idle_notification_delay_in_s_ = initial_delay_s;
+  idle_timer_.Stop();
+  idle_timer_.Start(FROM_HERE,
+      base::TimeDelta::FromSeconds(static_cast<int64>(initial_delay_s)),
+      this, &RenderThread::IdleHandler);
+}
+
+void RenderThread::IdleHandler() {
+  #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
+  MallocExtension::instance()->ReleaseFreeMemory();
+#endif
+
+  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.
+  ScheduleIdleHandler(idle_notification_delay_in_s_ +
+                      1.0 / (idle_notification_delay_in_s_ + 2.0));
+
+  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
+}
+
+double RenderThread::GetIdleNotificationDelayInS() const {
+  return idle_notification_delay_in_s_;
+}
+
+void RenderThread::SetIdleNotificationDelayInS(
+    double idle_notification_delay_in_s) {
+  idle_notification_delay_in_s_ = idle_notification_delay_in_s;
 }
 
 #if defined(OS_WIN)
-// static
-bool RenderThread::PreCacheFont(const LOGFONT& log_font) {
-  return RenderThread::current()->Send(
-      new ChildProcessHostMsg_PreCacheFont(log_font));
+void RenderThread::PreCacheFont(const LOGFONT& log_font) {
+  Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
-// static
-bool RenderThread::ReleaseCachedFonts() {
-  return RenderThread::current()->Send(
-      new ChildProcessHostMsg_ReleaseCachedFonts());
+void RenderThread::ReleaseCachedFonts() {
+  Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
+
 #endif  // OS_WIN
 
+int32 RenderThread::RoutingIDForCurrentContext() {
+  int32 routing_id = MSG_ROUTING_CONTROL;
+  if (v8::Context::InContext()) {
+    WebFrame* frame = WebFrame::frameForCurrentContext();
+    if (frame) {
+      RenderView* view = RenderView::FromWebView(frame->view());
+      if (view)
+        routing_id = view->routing_id();
+    }
+  } else {
+    DLOG(WARNING) << "Not called within a script context!";
+  }
+  return routing_id;
+}
+
+void RenderThread::DoNotSuspendWebKitSharedTimer() {
+  suspend_webkit_shared_timer_ = false;
+}
+
+void RenderThread::DoNotNotifyWebKitOfModalLoop() {
+  notify_webkit_of_modal_loop_ = false;
+}
+
+void RenderThread::OnSetZoomLevelForCurrentURL(const GURL& url,
+                                               double zoom_level) {
+  RenderViewZoomer zoomer(url, zoom_level);
+  RenderView::ForEach(&zoomer);
+}
+
+void RenderThread::OnDOMStorageEvent(
+    const DOMStorageMsg_Event_Params& params) {
+  if (!dom_storage_event_dispatcher_.get())
+    dom_storage_event_dispatcher_.reset(WebStorageEventDispatcher::create());
+  dom_storage_event_dispatcher_->dispatchStorageEvent(params.key,
+      params.old_value, params.new_value, params.origin, params.url,
+      params.storage_type == DOM_STORAGE_LOCAL);
+}
+
 bool RenderThread::OnControlMessageReceived(const IPC::Message& msg) {
   ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
   RenderProcessObserver* observer;
@@ -678,34 +759,6 @@ GpuChannelHost* RenderThread::GetGpuChannel() {
   return gpu_channel_.get();
 }
 
-void RenderThread::IdleHandler() {
-#if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
-  MallocExtension::instance()->ReleaseFreeMemory();
-#endif
-
-  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.
-  ScheduleIdleHandler(idle_notification_delay_in_s_ +
-                      1.0 / (idle_notification_delay_in_s_ + 2.0));
-
-  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
-}
-
-void RenderThread::ScheduleIdleHandler(double initial_delay_s) {
-  idle_notification_delay_in_s_ = initial_delay_s;
-  idle_timer_.Stop();
-  idle_timer_.Start(FROM_HERE,
-      base::TimeDelta::FromSeconds(static_cast<int64>(initial_delay_s)),
-      this, &RenderThread::IdleHandler);
-}
-
 void RenderThread::OnPurgePluginListCache(bool reload_pages) {
   EnsureWebKitInitialized();
   // The call below will cause a GetPlugins call with refresh=true, but at this
@@ -731,13 +784,3 @@ RenderThread::GetFileThreadMessageLoopProxy() {
   }
   return file_thread_->message_loop_proxy();
 }
-
-void RenderThread::RegisterExtension(v8::Extension* extension) {
-  WebScriptController::registerExtension(extension);
-  v8_extensions_.insert(extension->name());
-}
-
-bool RenderThread::IsRegisteredExtension(
-    const std::string& v8_extension_name) const {
-  return v8_extensions_.find(v8_extension_name) != v8_extensions_.end();
-}
diff --git a/content/renderer/render_thread.h b/content/renderer/render_thread.h
index 4520490..16ffc87 100644
--- a/content/renderer/render_thread.h
+++ b/content/renderer/render_thread.h
@@ -19,6 +19,7 @@
 #include "content/common/content_export.h"
 #include "content/common/css_colors.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
+#include "content/public/renderer/render_thread.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ -66,36 +67,6 @@ namespace v8 {
 class Extension;
 }
 
-// The RenderThreadBase is the minimal interface that a RenderView/Widget
-// expects from a render thread. The interface basically abstracts a way to send
-// and receive messages.
-//
-// TODO(brettw): This has two different and opposing usage patterns which
-// make it confusing. It can be accessed through RenderThread::current(), which
-// can be NULL during tests, or it can be passed as RenderThreadBase, which is
-// mocked during tests. It should be changed to RenderThread::current()
-// everywhere.
-//
-// See crbug.com/98375 for more details.
-class CONTENT_EXPORT RenderThreadBase {
- public:
-  virtual ~RenderThreadBase() {}
-
-  virtual bool Send(IPC::Message* msg) = 0;
-
-  // Called to add or remove a listener for a particular message routing ID.
-  // These methods normally get delegated to a MessageRouter.
-  virtual void AddRoute(int32 routing_id, IPC::Channel::Listener* listener) = 0;
-  virtual void RemoveRoute(int32 routing_id) = 0;
-
-  virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
-  virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
-
-  // Called by a RenderWidget when it is hidden or restored.
-  virtual void WidgetHidden() = 0;
-  virtual void WidgetRestored() = 0;
-};
-
 // The RenderThread class represents a background thread where RenderView
 // instances live.  The RenderThread supports an API that is used by its
 // consumer to talk indirectly to the RenderViews and supporting objects.
@@ -105,40 +76,52 @@ class CONTENT_EXPORT RenderThreadBase {
 // Most of the communication occurs in the form of IPC messages.  They are
 // routed to the RenderThread according to the routing IDs of the messages.
 // The routing IDs correspond to RenderView instances.
-class CONTENT_EXPORT RenderThread : public RenderThreadBase,
+class CONTENT_EXPORT RenderThread : public content::RenderThread,
                                     public ChildThread {
  public:
-  // Grabs the IPC channel name from the command line.
+  static RenderThread* current();
+
   RenderThread();
   // Constructor that's used when running in single process mode.
   explicit RenderThread(const std::string& channel_name);
   virtual ~RenderThread();
 
-  // Returns the one render thread for this process.  Note that this should only
-  // be accessed when running on the render thread itself
-  //
-  // TODO(brettw) this should be on the abstract base class instead of here,
-  // and return the base class' interface instead. See crbug.com/98375.
-  static RenderThread* current();
-
   // Returns the routing ID of the RenderWidget containing the current script
   // execution context (corresponding to WebFrame::frameForCurrentContext).
   static int32 RoutingIDForCurrentContext();
 
-  // Returns the locale string to be used in WebKit.
-  static std::string GetLocale();
-
-  // Overridden from RenderThreadBase.
-  virtual bool Send(IPC::Message* msg);
-  virtual void AddRoute(int32 routing_id, IPC::Channel::Listener* listener);
-  virtual void RemoveRoute(int32 routing_id);
-  virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter);
-  virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter);
-  virtual void WidgetHidden();
-  virtual void WidgetRestored();
-
-  void AddObserver(content::RenderProcessObserver* observer);
-  void RemoveObserver(content::RenderProcessObserver* observer);
+  // content::RenderThread implementation:
+  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual MessageLoop* GetMessageLoop() OVERRIDE;
+  virtual IPC::SyncChannel* GetChannel() OVERRIDE;
+  virtual ResourceDispatcher* GetResourceDispatcher() OVERRIDE;
+  virtual std::string GetLocale() OVERRIDE;
+  virtual void AddRoute(int32 routing_id,
+                        IPC::Channel::Listener* listener) OVERRIDE;
+  virtual void RemoveRoute(int32 routing_id) OVERRIDE;
+  virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter) OVERRIDE;
+  virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) OVERRIDE;
+  virtual void SetOutgoingMessageFilter(
+      IPC::ChannelProxy::OutgoingMessageFilter* filter) OVERRIDE;
+  virtual void AddObserver(content::RenderProcessObserver* observer) OVERRIDE;
+  virtual void RemoveObserver(
+      content::RenderProcessObserver* observer) OVERRIDE;
+  virtual void WidgetHidden() OVERRIDE;
+  virtual void WidgetRestored() OVERRIDE;
+  virtual void EnsureWebKitInitialized() OVERRIDE;
+  virtual void RecordUserMetrics(const std::string& action) OVERRIDE;
+  virtual void RegisterExtension(v8::Extension* extension) OVERRIDE;
+  virtual bool IsRegisteredExtension(
+      const std::string& v8_extension_name) const OVERRIDE;
+  virtual void ScheduleIdleHandler(double initial_delay_s) OVERRIDE;
+  virtual void IdleHandler() OVERRIDE;
+  virtual double GetIdleNotificationDelayInS() const OVERRIDE;
+  virtual void SetIdleNotificationDelayInS(
+      double idle_notification_delay_in_s) OVERRIDE;
+#if defined(OS_WIN)
+  virtual void PreCacheFont(const LOGFONT& log_font) OVERRIDE;
+  virtual void ReleaseCachedFonts() OVERRIDE;
+#endif
 
   // These methods modify how the next message is sent.  Normally, when sending
   // a synchronous message that runs a nested message loop, we need to suspend
@@ -174,13 +157,6 @@ class CONTENT_EXPORT RenderThread : public RenderThreadBase,
 
   bool plugin_refresh_allowed() const { return plugin_refresh_allowed_; }
 
-  double idle_notification_delay_in_s() const {
-    return idle_notification_delay_in_s_;
-  }
-  void set_idle_notification_delay_in_s(double idle_notification_delay_in_s) {
-    idle_notification_delay_in_s_ = idle_notification_delay_in_s;
-  }
-
   // Synchronously establish a channel to the GPU plugin if not previously
   // established or if it has been lost (for example if the GPU plugin crashed).
   // If there is a pending asynchronous request, it will be completed by the
@@ -196,33 +172,6 @@ class CONTENT_EXPORT RenderThread : public RenderThreadBase,
   // on the renderer's main thread.
   scoped_refptr<base::MessageLoopProxy> GetFileThreadMessageLoopProxy();
 
-  // Schedule a call to IdleHandler with the given initial delay.
-  void ScheduleIdleHandler(double initial_delay_s);
-
-  // A task we invoke periodically to assist with idle cleanup.
-  void IdleHandler();
-
-  // Registers the given V8 extension with WebKit.
-  void RegisterExtension(v8::Extension* extension);
-
-  // Returns true iff the extension is registered.
-  bool IsRegisteredExtension(const std::string& v8_extension_name) const;
-
-  // We initialize WebKit as late as possible.
-  void EnsureWebKitInitialized();
-
-  // Helper function to send over a string to be recorded by user metrics
-  static void RecordUserMetrics(const std::string& action);
-
-#if defined(OS_WIN)
-  // Request that the given font be loaded by the browser so it's cached by the
-  // OS. Please see ChildProcessHost::PreCacheFont for details.
-  static bool PreCacheFont(const LOGFONT& log_font);
-
-  // Release cached font.
-  static bool ReleaseCachedFonts();
-#endif  // OS_WIN
-
  private:
   virtual bool OnControlMessageReceived(const IPC::Message& msg);
 
diff --git a/content/renderer/render_view.cc b/content/renderer/render_view.cc
index c79c567..10ba01f 100644
--- a/content/renderer/render_view.cc
+++ b/content/renderer/render_view.cc
@@ -300,7 +300,7 @@ struct RenderView::PendingFileChooser {
   WebFileChooserCompletion* completion;  // MAY BE NULL to skip callback.
 };
 
-RenderView::RenderView(RenderThreadBase* render_thread,
+RenderView::RenderView(content::RenderThread* render_thread,
                        gfx::NativeViewId parent_hwnd,
                        int32 opener_id,
                        const RendererPreferences& renderer_prefs,
@@ -459,7 +459,7 @@ RenderView* RenderView::FromWebView(WebView* webview) {
 
 /*static*/
 RenderView* RenderView::Create(
-    RenderThreadBase* render_thread,
+    content::RenderThread* render_thread,
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
     const RendererPreferences& renderer_prefs,
@@ -1530,7 +1530,7 @@ void RenderView::didExecuteCommand(const WebString& command_name) {
       StartsWithASCII(name, "Insert", true) ||
       StartsWithASCII(name, "Delete", true))
     return;
-  RenderThread::RecordUserMetrics(name);
+  RenderThread::current()->RecordUserMetrics(name);
 }
 
 bool RenderView::handleCurrentKeyboardEvent() {
diff --git a/content/renderer/render_view.h b/content/renderer/render_view.h
index 2c16ac6..91d03ca 100644
--- a/content/renderer/render_view.h
+++ b/content/renderer/render_view.h
@@ -87,6 +87,7 @@ class WaitableEvent;
 namespace content {
 class NavigationState;
 class P2PSocketDispatcher;
+class RenderThread;
 class RenderViewObserver;
 class RenderViewVisitor;
 }  // namespace content
@@ -179,7 +180,7 @@ class RenderView : public RenderWidget,
   // |counter| is either a currently initialized counter, or NULL (in which case
   // we treat this RenderView as a top level window).
   CONTENT_EXPORT static RenderView* Create(
-      RenderThreadBase* render_thread,
+    content::RenderThread* render_thread,
       gfx::NativeViewId parent_hwnd,
       int32 opener_id,
       const RendererPreferences& renderer_prefs,
@@ -697,7 +698,7 @@ class RenderView : public RenderWidget,
     CONNECTION_ERROR,
   };
 
-  RenderView(RenderThreadBase* render_thread,
+  RenderView(content::RenderThread* render_thread,
              gfx::NativeViewId parent_hwnd,
              int32 opener_id,
              const RendererPreferences& renderer_prefs,
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 1378a8a..71e0a84 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -62,7 +62,7 @@ using WebKit::WebTouchEvent;
 using WebKit::WebVector;
 using WebKit::WebWidget;
 
-RenderWidget::RenderWidget(RenderThreadBase* render_thread,
+RenderWidget::RenderWidget(content::RenderThread* render_thread,
                            WebKit::WebPopupType popup_type)
     : routing_id_(MSG_ROUTING_NONE),
       webwidget_(NULL),
@@ -111,7 +111,7 @@ RenderWidget::~RenderWidget() {
 
 // static
 RenderWidget* RenderWidget::Create(int32 opener_id,
-                                   RenderThreadBase* render_thread,
+                                   content::RenderThread* render_thread,
                                    WebKit::WebPopupType popup_type) {
   DCHECK(opener_id != MSG_ROUTING_NONE);
   scoped_refptr<RenderWidget> widget(new RenderWidget(render_thread,
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index 17db0c2..fdd89ea 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -29,20 +29,10 @@
 #include "ui/gfx/surface/transport_dib.h"
 #include "webkit/glue/webcursor.h"
 
-class RenderThreadBase;
-
-namespace gfx {
-class Point;
-}
-
 namespace IPC {
 class SyncMessage;
 }
 
-namespace skia {
-class PlatformCanvas;
-}
-
 namespace WebKit {
 class WebInputEvent;
 class WebMouseEvent;
@@ -51,6 +41,18 @@ class WebWidget;
 struct WebPopupMenuInfo;
 }
 
+namespace content {
+class RenderThread;
+}
+
+namespace gfx {
+class Point;
+}
+
+namespace skia {
+class PlatformCanvas;
+}
+
 namespace webkit {
 namespace npapi {
 struct WebPluginGeometry;
@@ -71,9 +73,10 @@ class CONTENT_EXPORT RenderWidget
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside. The render_thread is any
-  // RenderThreadBase implementation, mostly commonly RenderThread::current().
+  // content::RenderThread implementation, mostly commonly
+  // RenderThread::current().
   static RenderWidget* Create(int32 opener_id,
-                              RenderThreadBase* render_thread,
+                              content::RenderThread* render_thread,
                               WebKit::WebPopupType popup_type);
 
   // Creates a WebWidget based on the popup type.
@@ -145,7 +148,7 @@ class CONTENT_EXPORT RenderWidget
   // For unit tests.
   friend class RenderWidgetTest;
 
-  RenderWidget(RenderThreadBase* render_thread,
+  RenderWidget(content::RenderThread* render_thread,
                WebKit::WebPopupType popup_type);
   virtual ~RenderWidget();
 
@@ -337,7 +340,7 @@ class CONTENT_EXPORT RenderWidget
   int32 opener_id_;
 
   // The thread that does our IPC.
-  RenderThreadBase* render_thread_;
+  content::RenderThread* render_thread_;
 
   // The position where this view should be initially shown.
   gfx::Rect initial_pos_;
diff --git a/content/renderer/render_widget_fullscreen.cc b/content/renderer/render_widget_fullscreen.cc
index c5e1b29..5a8ace6 100644
--- a/content/renderer/render_widget_fullscreen.cc
+++ b/content/renderer/render_widget_fullscreen.cc
@@ -12,7 +12,7 @@ using WebKit::WebWidget;
 
 // static
 RenderWidgetFullscreen* RenderWidgetFullscreen::Create(
-    int32 opener_id, RenderThreadBase* render_thread) {
+    int32 opener_id, content::RenderThread* render_thread) {
   DCHECK_NE(MSG_ROUTING_NONE, opener_id);
   scoped_refptr<RenderWidgetFullscreen> widget(
       new RenderWidgetFullscreen(render_thread));
@@ -46,6 +46,7 @@ void RenderWidgetFullscreen::show(WebKit::WebNavigationPolicy) {
   }
 }
 
-RenderWidgetFullscreen::RenderWidgetFullscreen(RenderThreadBase* render_thread)
+RenderWidgetFullscreen::RenderWidgetFullscreen(
+    content::RenderThread* render_thread)
     : RenderWidget(render_thread, WebKit::WebPopupTypeNone) {
 }
diff --git a/content/renderer/render_widget_fullscreen.h b/content/renderer/render_widget_fullscreen.h
index 7e18037..1b2c382 100644
--- a/content/renderer/render_widget_fullscreen.h
+++ b/content/renderer/render_widget_fullscreen.h
@@ -14,15 +14,16 @@ class RenderWidgetFullscreen : public RenderWidget {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside. The render_thread is any
-  // RenderThreadBase implementation, mostly commonly RenderThread::current().
+  // content::RenderThread implementation, mostly commonly
+   // RenderThread::current().
   static RenderWidgetFullscreen* Create(int32 opener_id,
-                                        RenderThreadBase* render_thread);
+                                        content::RenderThread* render_thread);
 
   virtual void show(WebKit::WebNavigationPolicy);
 
  protected:
   virtual WebKit::WebWidget* CreateWebWidget();
-  RenderWidgetFullscreen(RenderThreadBase* render_thread);
+  RenderWidgetFullscreen(content::RenderThread* render_thread);
 
   void Init(int32 opener_id);
 };
diff --git a/content/renderer/render_widget_fullscreen_pepper.cc b/content/renderer/render_widget_fullscreen_pepper.cc
index ece64b3..ed8a853 100644
--- a/content/renderer/render_widget_fullscreen_pepper.cc
+++ b/content/renderer/render_widget_fullscreen_pepper.cc
@@ -203,7 +203,7 @@ void DestroyContext(RendererGLContext* context, GLuint program, GLuint buffer) {
 
 // static
 RenderWidgetFullscreenPepper* RenderWidgetFullscreenPepper::Create(
-    int32 opener_id, RenderThreadBase* render_thread,
+    int32 opener_id, content::RenderThread* render_thread,
     webkit::ppapi::PluginInstance* plugin,
     const GURL& active_url) {
   DCHECK_NE(MSG_ROUTING_NONE, opener_id);
@@ -214,7 +214,7 @@ RenderWidgetFullscreenPepper* RenderWidgetFullscreenPepper::Create(
 }
 
 RenderWidgetFullscreenPepper::RenderWidgetFullscreenPepper(
-    RenderThreadBase* render_thread,
+    content::RenderThread* render_thread,
     webkit::ppapi::PluginInstance* plugin,
     const GURL& active_url)
     : RenderWidgetFullscreen(render_thread),
diff --git a/content/renderer/render_widget_fullscreen_pepper.h b/content/renderer/render_widget_fullscreen_pepper.h
index d804f85..e6d4d18 100644
--- a/content/renderer/render_widget_fullscreen_pepper.h
+++ b/content/renderer/render_widget_fullscreen_pepper.h
@@ -27,7 +27,7 @@ class RenderWidgetFullscreenPepper : public RenderWidgetFullscreen,
  public:
   static RenderWidgetFullscreenPepper* Create(
       int32 opener_id,
-      RenderThreadBase* render_thread,
+      content::RenderThread* render_thread,
       webkit::ppapi::PluginInstance* plugin,
       const GURL& active_url);
 
@@ -43,7 +43,7 @@ class RenderWidgetFullscreenPepper : public RenderWidgetFullscreen,
   void SwapBuffers();
 
  protected:
-  RenderWidgetFullscreenPepper(RenderThreadBase* render_thread,
+  RenderWidgetFullscreenPepper(content::RenderThread* render_thread,
                                webkit::ppapi::PluginInstance* plugin,
                                const GURL& active_url);
   virtual ~RenderWidgetFullscreenPepper();
diff --git a/content/renderer/renderer_webkitplatformsupport_impl.cc b/content/renderer/renderer_webkitplatformsupport_impl.cc
index 7800c08..24863e4 100644
--- a/content/renderer/renderer_webkitplatformsupport_impl.cc
+++ b/content/renderer/renderer_webkitplatformsupport_impl.cc
@@ -258,7 +258,7 @@ void RendererWebKitPlatformSupportImpl::cacheMetadata(
 }
 
 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
-  return ASCIIToUTF16(RenderThread::GetLocale());
+  return ASCIIToUTF16(RenderThread::Get()->GetLocale());
 }
 
 void RendererWebKitPlatformSupportImpl::suddenTerminationChanged(bool enabled) {
@@ -444,8 +444,8 @@ bool RendererWebKitPlatformSupportImpl::SandboxSupport::ensureFontLoaded(
     HFONT font) {
   LOGFONT logfont;
   GetObject(font, sizeof(LOGFONT), &logfont);
-  return RenderThread::current()->Send(
-      new ChildProcessHostMsg_PreCacheFont(logfont));
+  RenderThread::current()->PreCacheFont(logfont);
+  return true;
 }
 
 #elif defined(OS_MACOSX)
@@ -604,7 +604,8 @@ RendererWebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
 
 WebBlobRegistry* RendererWebKitPlatformSupportImpl::blobRegistry() {
   // RenderThread::current can be NULL when running some tests.
-  if (!blob_registry_.get() && RenderThread::current())
-    blob_registry_.reset(new WebBlobRegistryImpl(RenderThread::current()));
+  if (!blob_registry_.get() && RenderThread::current()) {
+    blob_registry_.reset(new WebBlobRegistryImpl(RenderThread::Get()));
+  }
   return blob_registry_.get();
 }