Rename RenderThread to RenderThreadImpl

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.h"
+#include "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 82 matching lines @@
 using WebKit::WebView;
 using content::RenderProcessObserver;
 
 namespace {
 static const double kInitialIdleHandlerDelayS = 1.0 /* seconds */;
 
 #if defined(TOUCH_UI)
 static const int kPopupListBoxMinimumRowHeight = 60;
 #endif
 
-// Keep the global RenderThread in a TLS slot so it is impossible to access
+// Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
-static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
+static base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> > lazy_tls(
     base::LINKER_INITIALIZED);
 
 class RenderViewZoomer : public content::RenderViewVisitor {
  public:
   RenderViewZoomer(const GURL& url, double zoom_level)
       : zoom_level_(zoom_level) {
     host_ = net::GetHostOrSpecFromURL(url);
   }
 
   virtual bool Visit(RenderView* render_view) {
@@ skipping 12 matching lines @@
 
  private:
   std::string host_;
   double zoom_level_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
 };
 
 }  // 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)
     min = 1;
   base::Histogram* histogram = base::Histogram::FactoryGet(
       name, min, max, buckets, base::Histogram::kUmaTargetedHistogramFlag);
   return histogram;
 }
 
 static void AddHistogramSample(void* hist, int sample) {
   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
   histogram->Add(sample);
 }
 
-RenderThread* RenderThread::current() {
+RenderThreadImpl* RenderThreadImpl::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() {
+RenderThreadImpl::RenderThreadImpl() {
   Init();
 }
 
-RenderThread::RenderThread(const std::string& channel_name)
+RenderThreadImpl::RenderThreadImpl(const std::string& channel_name)
     : ChildThread(channel_name) {
   Init();
 }
 
-void RenderThread::Init() {
-  TRACE_EVENT_BEGIN_ETW("RenderThread::Init", 0, "");
+void RenderThreadImpl::Init() {
+  TRACE_EVENT_BEGIN_ETW("RenderThreadImpl::Init", 0, "");
 
 #if defined(OS_MACOSX)
   // On Mac, the select popups are rendered by the browser.
   WebKit::WebView::setUseExternalPopupMenus(true);
 #endif
 
   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 (RenderProcessImpl::InProcessPlugins())
     CoInitialize(0);
 #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;
-  task_factory_.reset(new ScopedRunnableMethodFactory<RenderThread>(this));
+  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());
 
   audio_input_message_filter_ = new AudioInputMessageFilter();
   AddFilter(audio_input_message_filter_.get());
 
   audio_message_filter_ = new AudioMessageFilter();
   AddFilter(audio_message_filter_.get());
 
   devtools_agent_message_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_message_filter_.get());
 
   content::GetContentClient()->renderer()->RenderThreadStarted();
 
-  TRACE_EVENT_END_ETW("RenderThread::Init", 0, "");
+  TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 }
 
-RenderThread::~RenderThread() {
+RenderThreadImpl::~RenderThreadImpl() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
   // Wait for all databases to be closed.
   if (web_database_observer_impl_.get())
     web_database_observer_impl_->WaitForAllDatabasesToClose();
 
   // Shutdown in reverse of the initialization order.
   RemoveFilter(devtools_agent_message_filter_.get());
   devtools_agent_message_filter_ = NULL;
@@ skipping 26 matching lines @@
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   NPChannelBase::CleanupChannels();
   // Don't call COM if the renderer is in the sandbox.
   if (RenderProcessImpl::InProcessPlugins())
     CoUninitialize();
 #endif
 }
 
-bool RenderThread::Send(IPC::Message* msg) {
+bool RenderThreadImpl::Send(IPC::Message* msg) {
   // Certain synchronous messages cannot always be processed synchronously by
   // the browser, e.g., Chrome frame communicating with the embedding browser.
   // This could cause a complete hang of Chrome if a windowed plug-in is trying
   // to communicate with the renderer thread since the browser's UI thread
   // could be stuck (within a Windows API call) trying to synchronously
   // communicate with the plug-in.  The remedy is to pump messages on this
   // thread while the browser is processing this request. This creates an
   // opportunity for re-entrancy into WebKit, so we need to take care to disable
   // callbacks, timers, and pending network loads that could trigger such
   // callbacks.
@@ skipping 47 matching lines @@
     if (notify_webkit_of_modal_loop)
       WebView::didExitModalLoop();
 
     if (suspend_webkit_shared_timer)
       webkit_platform_support_->ResumeSharedTimer();
   }
 
   return rv;
 }
 
-MessageLoop* RenderThread::GetMessageLoop() {
+MessageLoop* RenderThreadImpl::GetMessageLoop() {
   return message_loop();
 }
 
-IPC::SyncChannel* RenderThread::GetChannel() {
+IPC::SyncChannel* RenderThreadImpl::GetChannel() {
   return channel();
 }
 
-ResourceDispatcher* RenderThread::GetResourceDispatcher() {
+ResourceDispatcher* RenderThreadImpl::GetResourceDispatcher() {
   return resource_dispatcher();
 }
 
-std::string RenderThread::GetLocale() {
+std::string RenderThreadImpl::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) {
+void RenderThreadImpl::AddRoute(int32 routing_id,
+                                IPC::Channel::Listener* listener) {
   widget_count_++;
   return ChildThread::AddRoute(routing_id, listener);
 }
 
-void RenderThread::RemoveRoute(int32 routing_id) {
+void RenderThreadImpl::RemoveRoute(int32 routing_id) {
   widget_count_--;
   return ChildThread::RemoveRoute(routing_id);
 }
 
-void RenderThread::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
+void RenderThreadImpl::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->AddFilter(filter);
 }
 
-void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
+void RenderThreadImpl::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
-void RenderThread::SetOutgoingMessageFilter(
+void RenderThreadImpl::SetOutgoingMessageFilter(
     IPC::ChannelProxy::OutgoingMessageFilter* filter) {
 }
 
-void RenderThread::AddObserver(content::RenderProcessObserver* observer) {
+void RenderThreadImpl::AddObserver(content::RenderProcessObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void RenderThread::RemoveObserver(content::RenderProcessObserver* observer) {
+void RenderThreadImpl::RemoveObserver(
+    content::RenderProcessObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void RenderThread::WidgetHidden() {
+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);
 }
 
-void RenderThread::WidgetRestored() {
+void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
   if (!content::GetContentClient()->renderer()->
           RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   idle_timer_.Stop();
 }
 
-void RenderThread::EnsureWebKitInitialized() {
+void RenderThreadImpl::EnsureWebKitInitialized() {
   if (webkit_platform_support_.get())
     return;
 
   v8::V8::SetCounterFunction(base::StatsTable::FindLocation);
   v8::V8::SetCreateHistogramFunction(CreateHistogram);
   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 
   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
   WebKit::initialize(webkit_platform_support_.get());
 
@@ skipping 79 matching lines @@
       !command_line.HasSwitch(switches::kDisableFileSystem));
 
   WebRuntimeFeatures::enableJavaScriptI18NAPI(
       !command_line.HasSwitch(switches::kDisableJavaScriptI18NAPI));
 
   WebRuntimeFeatures::enableQuota(true);
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 }
 
-void RenderThread::RecordUserMetrics(const std::string& action) {
+void RenderThreadImpl::RecordUserMetrics(const std::string& action) {
   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 }
 
-void RenderThread::RegisterExtension(v8::Extension* extension) {
+void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
   v8_extensions_.insert(extension->name());
 }
 
-bool RenderThread::IsRegisteredExtension(
+bool RenderThreadImpl::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) {
+void RenderThreadImpl::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);
+      this, &RenderThreadImpl::IdleHandler);
 }
 
-void RenderThread::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:
   //    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.
+  // kInitialIdleHandlerDelayS in RenderThreadImpl::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 {
+double RenderThreadImpl::GetIdleNotificationDelayInS() const {
   return idle_notification_delay_in_s_;
 }
 
-void RenderThread::SetIdleNotificationDelayInS(
+void RenderThreadImpl::SetIdleNotificationDelayInS(
     double idle_notification_delay_in_s) {
   idle_notification_delay_in_s_ = idle_notification_delay_in_s;
 }
 
 #if defined(OS_WIN)
-void RenderThread::PreCacheFont(const LOGFONT& log_font) {
+void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
-void RenderThread::ReleaseCachedFonts() {
+void RenderThreadImpl::ReleaseCachedFonts() {
   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
 
 #endif  // OS_WIN
 
-int32 RenderThread::RoutingIDForCurrentContext() {
+int32 RenderThreadImpl::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() {
+void RenderThreadImpl::DoNotSuspendWebKitSharedTimer() {
   suspend_webkit_shared_timer_ = false;
 }
 
-void RenderThread::DoNotNotifyWebKitOfModalLoop() {
+void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
   notify_webkit_of_modal_loop_ = false;
 }
 
-void RenderThread::OnSetZoomLevelForCurrentURL(const GURL& url,
-                                               double zoom_level) {
+void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const GURL& url,
+                                                   double zoom_level) {
   RenderViewZoomer zoomer(url, zoom_level);
   RenderView::ForEach(&zoomer);
 }
 
-void RenderThread::OnDOMStorageEvent(
+void RenderThreadImpl::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) {
+bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
   ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
   RenderProcessObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     if (observer->OnControlMessageReceived(msg))
       return true;
   }
 
   // Some messages are handled by delegates.
   if (appcache_dispatcher_->OnMessageReceived(msg))
     return true;
   if (indexed_db_dispatcher_->OnMessageReceived(msg))
     return true;
 
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(RenderThread, msg)
+  IPC_BEGIN_MESSAGE_MAP(RenderThreadImpl, msg)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForCurrentURL,
                         OnSetZoomLevelForCurrentURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetNextPageID, OnSetNextPageID)
     IPC_MESSAGE_HANDLER(ViewMsg_SetCSSColors, OnSetCSSColors)
     // TODO(port): removed from render_messages_internal.h;
     // is there a new non-windows message I should add here?
     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
     IPC_MESSAGE_HANDLER(ViewMsg_NetworkStateChanged, OnNetworkStateChanged)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_Event, OnDOMStorageEvent)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void RenderThread::OnSetNextPageID(int32 next_page_id) {
+void RenderThreadImpl::OnSetNextPageID(int32 next_page_id) {
   // This should only be called at process initialization time, so we shouldn't
   // have to worry about thread-safety.
   RenderView::SetNextPageID(next_page_id);
 }
 
 // Called when to register CSS Color name->system color mappings.
 // We update the colors one by one and then tell WebKit to refresh all render
 // views.
-void RenderThread::OnSetCSSColors(
+void RenderThreadImpl::OnSetCSSColors(
     const std::vector<CSSColors::CSSColorMapping>& colors) {
   EnsureWebKitInitialized();
   size_t num_colors = colors.size();
   scoped_array<WebKit::WebColorName> color_names(
       new WebKit::WebColorName[num_colors]);
   scoped_array<WebKit::WebColor> web_colors(new WebKit::WebColor[num_colors]);
   size_t i = 0;
   for (std::vector<CSSColors::CSSColorMapping>::const_iterator it =
           colors.begin();
        it != colors.end();
        ++it, ++i) {
     color_names[i] = it->first;
     web_colors[i] = it->second;
   }
   WebKit::setNamedColors(color_names.get(), web_colors.get(), num_colors);
 }
 
-void RenderThread::OnCreateNewView(const ViewMsg_New_Params& params) {
+void RenderThreadImpl::OnCreateNewView(const ViewMsg_New_Params& params) {
   EnsureWebKitInitialized();
   // When bringing in render_view, also bring in webkit's glue and jsbindings.
   RenderView::Create(
       this,
       params.parent_window,
       MSG_ROUTING_NONE,
       params.renderer_preferences,
       params.web_preferences,
       new SharedRenderViewCounter(0),
       params.view_id,
       params.session_storage_namespace_id,
       params.frame_name);
 }
 
-GpuChannelHost* RenderThread::EstablishGpuChannelSync(
+GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
     content::CauseForGpuLaunch cause_for_gpu_launch) {
   if (gpu_channel_.get()) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (gpu_channel_->state() == GpuChannelHost::kUnconnected ||
         gpu_channel_->state() == GpuChannelHost::kConnected)
       return GetGpuChannel();
 
     // Recreate the channel if it has been lost.
     if (gpu_channel_->state() == GpuChannelHost::kLost)
@@ skipping 20 matching lines @@
 
   gpu_channel_->set_gpu_info(gpu_info);
   content::GetContentClient()->SetGpuInfo(gpu_info);
 
   // Connect to the GPU process if a channel name was received.
   gpu_channel_->Connect(channel_handle, renderer_process_for_gpu);
 
   return GetGpuChannel();
 }
 
-GpuChannelHost* RenderThread::GetGpuChannel() {
+GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
   if (!gpu_channel_.get())
     return NULL;
 
   if (gpu_channel_->state() != GpuChannelHost::kConnected)
     return NULL;
 
   return gpu_channel_.get();
 }
 
-void RenderThread::OnPurgePluginListCache(bool reload_pages) {
+void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
   EnsureWebKitInitialized();
   // 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(reload_pages);
   plugin_refresh_allowed_ = true;
 }
 
-void RenderThread::OnNetworkStateChanged(bool online) {
+void RenderThreadImpl::OnNetworkStateChanged(bool online) {
   EnsureWebKitInitialized();
   WebNetworkStateNotifier::setOnLine(online);
 }
 
 scoped_refptr<base::MessageLoopProxy>
-RenderThread::GetFileThreadMessageLoopProxy() {
+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();
 }