Rename RenderThread to RenderThreadImpl

content/renderer/gpu/gpu_channel_host.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/gpu/gpu_channel_host.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/transport_texture_service.h"
 #include "content/renderer/render_process.h"
-#include "content/renderer/render_thread.h"
+#include "content/renderer/render_thread_impl.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_sync_message_filter.h"
 
 using base::AutoLock;
 using base::MessageLoopProxy;
 
 GpuChannelHost::Listener::Listener(
     base::WeakPtr<IPC::Channel::Listener> listener,
     scoped_refptr<base::MessageLoopProxy> loop)
     : listener_(listener),
@@ skipping 91 matching lines @@
     : state_(kUnconnected),
       transport_texture_service_(new TransportTextureService()) {
 }
 
 GpuChannelHost::~GpuChannelHost() {
 }
 
 void GpuChannelHost::Connect(
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu) {
-  DCHECK(RenderThread::current());
+  DCHECK(RenderThreadImpl::current());
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   channel_.reset(new IPC::SyncChannel(
       channel_handle, IPC::Channel::MODE_CLIENT, NULL,
       ChildProcess::current()->io_message_loop_proxy(), true,
       ChildProcess::current()->GetShutDownEvent()));
 
   sync_filter_ = new IPC::SyncMessageFilter(
       ChildProcess::current()->GetShutDownEvent());
 
@@ skipping 38 matching lines @@
 }
 
 bool GpuChannelHost::Send(IPC::Message* message) {
   // The GPU process never sends synchronous IPCs so clear the unblock flag to
   // preserve order.
   message->set_unblock(false);
 
   // Currently we need to choose between two different mechanisms for sending.
   // On the main thread we use the regular channel Send() method, on another
   // thread we use SyncMessageFilter. We also have to be careful interpreting
-  // RenderThread::current() since it might return NULL during shutdown, while
-  // we are actually calling from the main thread (discard message then).
+  // RenderThreadImpl::current() since it might return NULL during shutdown,
+  // impl we are actually calling from the main thread (discard message then).
   //
   // TODO: Can we just always use sync_filter_ since we setup the channel
   //       without a main listener?
-  if (RenderThread::current()) {
+  if (RenderThreadImpl::current()) {
     if (channel_.get())
       return channel_->Send(message);
   } else if (MessageLoop::current()) {
     return sync_filter_->Send(message);
   }
 
   // Callee takes ownership of message, regardless of whether Send is
   // successful. See IPC::Message::Sender.
   delete message;
   return false;
@@ skipping 114 matching lines @@
 }
 
 void GpuChannelHost::RemoveRoute(int route_id) {
   MessageLoopProxy* io_loop = RenderProcess::current()->io_message_loop_proxy();
   io_loop->PostTask(FROM_HERE,
                     NewRunnableMethod(
                         channel_filter_.get(),
                         &GpuChannelHost::MessageFilter::RemoveRoute,
                         route_id));
 }