Revert "content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs"

content/browser/gpu/browser_gpu_channel_host_factory.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/browser/gpu/browser_gpu_channel_host_factory.h"
 
 #include <set>
 
 #include "base/bind.h"
-#include "base/location.h"
 #include "base/profiler/scoped_tracker.h"
-#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 94 matching lines @@
   void FinishOnMain();
 
   base::WaitableEvent event_;
   CauseForGpuLaunch cause_for_gpu_launch_;
   const int gpu_client_id_;
   int gpu_host_id_;
   bool reused_gpu_process_;
   IPC::ChannelHandle channel_handle_;
   gpu::GPUInfo gpu_info_;
   bool finished_;
-  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  scoped_refptr<base::MessageLoopProxy> main_loop_;
 };
 
 scoped_refptr<BrowserGpuChannelHostFactory::EstablishRequest>
 BrowserGpuChannelHostFactory::EstablishRequest::Create(CauseForGpuLaunch cause,
                                                        int gpu_client_id,
                                                        int gpu_host_id) {
   scoped_refptr<EstablishRequest> establish_request =
       new EstablishRequest(cause, gpu_client_id, gpu_host_id);
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+  scoped_refptr<base::MessageLoopProxy> loop =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   // PostTask outside the constructor to ensure at least one reference exists.
-  task_runner->PostTask(
+  loop->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::EstablishRequest::EstablishOnIO,
                  establish_request));
   return establish_request;
 }
 
 BrowserGpuChannelHostFactory::EstablishRequest::EstablishRequest(
     CauseForGpuLaunch cause,
     int gpu_client_id,
     int gpu_host_id)
     : event_(false, false),
       cause_for_gpu_launch_(cause),
       gpu_client_id_(gpu_client_id),
       gpu_host_id_(gpu_host_id),
       reused_gpu_process_(false),
       finished_(false),
-      main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+      main_loop_(base::MessageLoopProxy::current()) {
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::EstablishOnIO() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 "
           "BrowserGpuChannelHostFactory::EstablishRequest::EstablishOnIO"));
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host) {
@@ skipping 39 matching lines @@
     EstablishOnIO();
   } else {
     channel_handle_ = channel_handle;
     gpu_info_ = gpu_info;
     FinishOnIO();
   }
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::FinishOnIO() {
   event_.Signal();
-  main_task_runner_->PostTask(
+  main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::EstablishRequest::FinishOnMain,
                  this));
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::FinishOnMain() {
   if (!finished_) {
     BrowserGpuChannelHostFactory* factory =
         BrowserGpuChannelHostFactory::instance();
     factory->GpuChannelEstablished();
     finished_ = true;
   }
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::Wait() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "125248 BrowserGpuChannelHostFactory::EstablishRequest::Wait"));
 
     // We're blocking the UI thread, which is generally undesirable.
     // In this case we need to wait for this before we can show any UI
     // /anyway/, so it won't cause additional jank.
     // TODO(piman): Make this asynchronous (http://crbug.com/125248).
     TRACE_EVENT0("browser",
                  "BrowserGpuChannelHostFactory::EstablishGpuChannelSync");
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     event_.Wait();
   }
   FinishOnMain();
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::Cancel() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  DCHECK(main_loop_->BelongsToCurrentThread());
   finished_ = true;
 }
 
 bool BrowserGpuChannelHostFactory::CanUseForTesting() {
   return GpuDataManager::GetInstance()->GpuAccessAllowed(NULL);
 }
 
 void BrowserGpuChannelHostFactory::Initialize(bool establish_gpu_channel) {
   DCHECK(!instance_);
   instance_ = new BrowserGpuChannelHostFactory();
@@ skipping 314 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CreateGpuMemoryBufferCallbackMap::iterator iter =
       create_gpu_memory_buffer_requests_.find(request_id);
   DCHECK(iter != create_gpu_memory_buffer_requests_.end());
   iter->second.Run(handle);
   create_gpu_memory_buffer_requests_.erase(iter);
 }
 
 }  // namespace content