Rename RenderThread to RenderThreadImpl

content/renderer/render_view.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_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 43 matching lines @@
 #include "content/renderer/load_progress_tracker.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_impl.h"
 #include "content/renderer/media/media_stream_impl.h"
 #include "content/renderer/media/render_media_log.h"
 #include "content/renderer/mhtml_generator.h"
 #include "content/renderer/notification_provider.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "content/renderer/render_process.h"
-#include "content/renderer/render_thread.h"
+#include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/renderer_accessibility.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
 #include "content/renderer/renderer_webstoragenamespace_impl.h"
 #include "content/renderer/speech_input_dispatcher.h"
 #include "content/renderer/text_input_client_observer.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "content/renderer/web_ui_bindings.h"
 #include "content/renderer/webplugin_delegate_proxy.h"
 #include "content/renderer/websharedworker_proxy.h"
@@ skipping 317 matching lines @@
   new TextInputClientObserver(this);
 #endif  // defined(OS_MACOSX)
 
   devtools_agent_ = new DevToolsAgent(this);
 
   renderer_accessibility_ = new RendererAccessibility(this);
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableMediaStream)) {
     media_stream_impl_ = new MediaStreamImpl(
-        RenderThread::current()->video_capture_impl_manager());
+        RenderThreadImpl::current()->video_capture_impl_manager());
   }
 
   content::GetContentClient()->renderer()->RenderViewCreated(this);
 }
 
 RenderView::~RenderView() {
   history_page_ids_.clear();
 
   if (decrement_shared_popup_at_destruction_)
     shared_popup_counter_->data--;
@@ skipping 529 matching lines @@
 #if defined(OS_MACOSX)
 void RenderView::OnCopyToFindPboard() {
   if (!webview())
     return;
 
   // Since the find pasteboard supports only plain text, this can be simpler
   // than the |OnCopy()| case.
   WebFrame* frame = webview()->focusedFrame();
   if (frame->hasSelection()) {
     string16 selection = frame->selectionAsText();
-    RenderThread::current()->Send(
+    render_thread_->Send(
         new ClipboardHostMsg_FindPboardWriteStringAsync(selection));
   }
 }
 #endif
 
 void RenderView::OnPaste() {
   if (!webview())
     return;
 
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Paste"));
@@ skipping 330 matching lines @@
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunJavaScriptMessage(
       routing_id_, message, default_value, frame_url, type, &success, result));
   return success;
 }
 
 bool RenderView::SendAndRunNestedMessageLoop(IPC::SyncMessage* message) {
   // Before WebKit asks us to show an alert (etc.), it takes care of doing the
   // equivalent of WebView::willEnterModalLoop.  In the case of showModalDialog
   // it is particularly important that we do not call willEnterModalLoop as
   // that would defer resource loads for the dialog itself.
-  if (RenderThread::current())  // Will be NULL during unit tests.
-    RenderThread::current()->DoNotNotifyWebKitOfModalLoop();
+  if (RenderThreadImpl::current())  // Will be NULL during unit tests.
+    RenderThreadImpl::current()->DoNotNotifyWebKitOfModalLoop();
 
   message->EnableMessagePumping();  // Runs a nested message loop.
   return Send(message);
 }
 
 // WebKit::WebViewClient ------------------------------------------------------
 
 WebView* RenderView::createView(
     WebFrame* creator,
     const WebURLRequest& request,
@@ skipping 208 matching lines @@
   SyncSelectionIfRequired();
 #endif  // defined(OS_POSIX)
 }
 
 void RenderView::didExecuteCommand(const WebString& command_name) {
   const std::string& name = UTF16ToUTF8(command_name);
   if (StartsWithASCII(name, "Move", true) ||
       StartsWithASCII(name, "Insert", true) ||
       StartsWithASCII(name, "Delete", true))
     return;
-  RenderThread::current()->RecordUserMetrics(name);
+  RenderThreadImpl::current()->RecordUserMetrics(name);
 }
 
 bool RenderView::handleCurrentKeyboardEvent() {
   if (edit_commands_.empty())
     return false;
 
   WebFrame* frame = webview()->focusedFrame();
   if (!frame)
     return false;
 
@@ skipping 299 matching lines @@
 void RenderView::runModal() {
   DCHECK(did_show_) << "should already have shown the view";
 
   // We must keep WebKit's shared timer running in this case in order to allow
   // showModalDialog to function properly.
   //
   // TODO(darin): WebKit should really be smarter about suppressing events and
   // timers so that we do not need to manage the shared timer in such a heavy
   // handed manner.
   //
-  if (RenderThread::current())  // Will be NULL during unit tests.
-    RenderThread::current()->DoNotSuspendWebKitSharedTimer();
+  if (RenderThreadImpl::current())  // Will be NULL during unit tests.
+    RenderThreadImpl::current()->DoNotSuspendWebKitSharedTimer();
 
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunModal(routing_id_));
 }
 
 // WebKit::WebFrameClient -----------------------------------------------------
 
 WebPlugin* RenderView::createPlugin(WebFrame* frame,
                                     const WebPluginParams& params) {
   WebPlugin* plugin = NULL;
   if (content::GetContentClient()->renderer()->OverrideCreatePlugin(
           this, frame, params, &plugin)) {
     return plugin;
   }
 
   return CreatePluginNoCheck(frame, params);
 }
 
 WebWorker* RenderView::createWorker(WebFrame* frame, WebWorkerClient* client) {
   WebApplicationCacheHostImpl* appcache_host =
       WebApplicationCacheHostImpl::FromFrame(frame);
   int appcache_host_id = appcache_host ? appcache_host->host_id() : 0;
-  return new WebWorkerProxy(client, RenderThread::current(), routing_id_,
+  return new WebWorkerProxy(client, RenderThreadImpl::current(), routing_id_,
                             appcache_host_id);
 }
 
 WebSharedWorker* RenderView::createSharedWorker(
     WebFrame* frame, const WebURL& url, const WebString& name,
     unsigned long long document_id) {
 
   int route_id = MSG_ROUTING_NONE;
   bool exists = false;
   bool url_mismatch = false;
   ViewHostMsg_CreateWorker_Params params;
   params.url = url;
   params.is_shared = true;
   params.name = name;
   params.document_id = document_id;
   params.render_view_route_id = routing_id_;
   params.route_id = MSG_ROUTING_NONE;
   params.parent_appcache_host_id = 0;
   params.script_resource_appcache_id = 0;
   Send(new ViewHostMsg_LookupSharedWorker(
       params, &exists, &route_id, &url_mismatch));
   if (url_mismatch) {
     return NULL;
   } else {
-    return new WebSharedWorkerProxy(RenderThread::current(),
+    return new WebSharedWorkerProxy(RenderThreadImpl::current(),
                                     document_id,
                                     exists,
                                     route_id,
                                     routing_id_);
   }
 }
 
 WebMediaPlayer* RenderView::createMediaPlayer(
     WebFrame* frame, WebMediaPlayerClient* client) {
   FOR_EACH_OBSERVER(
@@ skipping 29 matching lines @@
                           video_renderer)) {
     return NULL;
   }
   return result.release();
 }
 
 WebApplicationCacheHost* RenderView::createApplicationCacheHost(
     WebFrame* frame, WebApplicationCacheHostClient* client) {
   return new RendererWebApplicationCacheHostImpl(
       FromWebView(frame->view()), client,
-      RenderThread::current()->appcache_dispatcher()->backend_proxy());
+      RenderThreadImpl::current()->appcache_dispatcher()->backend_proxy());
 }
 
 WebCookieJar* RenderView::cookieJar(WebFrame* frame) {
   return &cookie_jar_;
 }
 
 void RenderView::frameDetached(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
 }
 
@@ skipping 1004 matching lines @@
     NOTIMPLEMENTED();
     return NULL;
 #endif
   }
 
   return new WebPluginDelegateProxy(mime_type, AsWeakPtr());
 }
 
 void RenderView::CreatedPluginWindow(gfx::PluginWindowHandle window) {
 #if defined(USE_X11)
-  RenderThread::current()->Send(new ViewHostMsg_CreatePluginContainer(
+  render_thread_->Send(new ViewHostMsg_CreatePluginContainer(
       routing_id(), window));
 #endif
 }
 
 void RenderView::WillDestroyPluginWindow(gfx::PluginWindowHandle window) {
 #if defined(USE_X11)
-  RenderThread::current()->Send(new ViewHostMsg_DestroyPluginContainer(
+  render_thread_->Send(new ViewHostMsg_DestroyPluginContainer(
       routing_id(), window));
 #endif
   CleanupWindowInPluginMoves(window);
 }
 
 void RenderView::DidMovePlugin(const webkit::npapi::WebPluginGeometry& move) {
   SchedulePluginMove(move);
 }
 
 void RenderView::DidStartLoadingForPlugin() {
@@ skipping 1316 matching lines @@
 
 void RenderView::registerProtocolHandler(const WebString& scheme,
                                          const WebString& base_url,
                                          const WebString& url,
                                          const WebString& title) {
   GURL base(base_url);
   GURL absolute_url = base.Resolve(UTF16ToUTF8(url));
   if (base.GetOrigin() != absolute_url.GetOrigin()) {
     return;
   }
-  RenderThread::current()->Send(
-      new ViewHostMsg_RegisterProtocolHandler(routing_id_,
-                                              UTF16ToUTF8(scheme),
-                                              absolute_url,
-                                              title));
+  Send(new ViewHostMsg_RegisterProtocolHandler(routing_id_,
+                                               UTF16ToUTF8(scheme),
+                                               absolute_url,
+                                               title));
 }
 
 void RenderView::registerIntentHandler(const WebString& action,
                                        const WebString& type,
                                        const WebString& href,
                                        const WebString& title) {
-  RenderThread::current()->Send(
-      new ViewHostMsg_RegisterIntentHandler(routing_id_,
-                                            action,
-                                            type,
-                                            href,
-                                            title));
+  Send(new ViewHostMsg_RegisterIntentHandler(routing_id_,
+                                             action,
+                                             type,
+                                             href,
+                                             title));
 }
 
 WebKit::WebPageVisibilityState RenderView::visibilityState() const {
   WebKit::WebPageVisibilityState current_state = is_hidden() ?
       WebKit::WebPageVisibilityStateHidden :
       WebKit::WebPageVisibilityStateVisible;
   WebKit::WebPageVisibilityState override_state = current_state;
   if (content::GetContentClient()->renderer()->
           ShouldOverridePageVisibilityState(this,
                                             &override_state))
@@ skipping 112 matching lines @@
   main_frame->enableViewSourceMode(true);
 }
 
 void RenderView::OnLockMouseACK(bool succeeded) {
   pepper_delegate_.OnLockMouseACK(succeeded);
 }
 
 void RenderView::OnMouseLockLost() {
   pepper_delegate_.OnMouseLockLost();
 }