Remove BrowserGpuChannelHostFactory usage of UnsafeGetMessageLoopForThread

content/common/gpu/client/gpu_channel_host.cc

 // Copyright (c) 2012 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/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 29 matching lines @@
 ProxyFlushInfo::~ProxyFlushInfo() {
 }
 
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
     base::WaitableEvent* shutdown_event,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
-  DCHECK(factory->IsMainThread());
+  DCHECK(factory->GetMainTaskRunner()->BelongsToCurrentThread());
   scoped_refptr<GpuChannelHost> host =
       new GpuChannelHost(factory, gpu_info, gpu_memory_buffer_manager);
   host->Connect(channel_handle, shutdown_event);
   return host;
 }
 
 GpuChannelHost::GpuChannelHost(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
@@ skipping 37 matching lines @@
   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
   // IsMainThread() since it might return false 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 (factory_->IsMainThread()) {
+  if (factory_->GetMainTaskRunner()->BelongsToCurrentThread()) {
     // http://crbug.com/125264
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     bool result = channel_->Send(message.release());
     if (!result)
       DVLOG(1) << "GpuChannelHost::Send failed: Channel::Send failed";
     return result;
   }
 
   bool result = sync_filter_->Send(message.release());
   return result;
@@ skipping 148 matching lines @@
   AutoLock lock(context_lock_);
   proxies_.erase(route_id);
   if (flush_info_.flush_pending && flush_info_.route_id == route_id)
     flush_info_.flush_pending = false;
 
   delete command_buffer;
 }
 
 void GpuChannelHost::DestroyChannel() {
   // channel_ must be destroyed on the main thread.
-  if (channel_.get() && !factory_->IsMainThread())
-    factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
+  if (channel_.get()) {
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
+        factory_->GetMainTaskRunner();
+    if (!main_task_runner->RunsTasksOnCurrentThread())
+      main_task_runner->DeleteSoon(FROM_HERE, channel_.release());
+  }
   channel_.reset();
 }
 
 void GpuChannelHost::AddRoute(
     int route_id, base::WeakPtr<IPC::Listener> listener) {
   DCHECK(MessageLoopProxy::current().get());
 
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   io_loop->PostTask(FROM_HERE,
                     base::Bind(&GpuChannelHost::MessageFilter::AddRoute,
@@ skipping 137 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content