Make EstablishGpuChannel synchronous. Remove obsolete Synchronize msg.

content/browser/gpu/gpu_process_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/browser/gpu/gpu_process_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
@@ skipping 298 matching lines @@
     return true;
   }
 
   return BrowserChildProcessHost::Send(msg);
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
-    IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply, OnSynchronizeReply)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer, OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GraphicsInfoCollected,
                         OnGraphicsInfoCollected)
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
@@ skipping 21 matching lines @@
 
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     channel_requests_.push(wrapped_callback);
   } else {
     EstablishChannelError(
         wrapped_callback.release(), IPC::ChannelHandle(),
         base::kNullProcessHandle, GPUInfo());
   }
 }
 
-void GpuProcessHost::Synchronize(SynchronizeCallback* callback) {
-  DCHECK(CalledOnValidThread());
-  linked_ptr<SynchronizeCallback> wrapped_callback(callback);
-
-  if (Send(new GpuMsg_Synchronize())) {
-    synchronize_requests_.push(wrapped_callback);
-  } else {
-    SynchronizeError(wrapped_callback.release());
-  }
-}
-
 void GpuProcessHost::CreateViewCommandBuffer(
     gfx::PluginWindowHandle compositing_surface,
     int32 render_view_id,
     int32 renderer_id,
     const GPUCreateCommandBufferConfig& init_params,
     CreateCommandBufferCallback* callback) {
   DCHECK(CalledOnValidThread());
   linked_ptr<CreateCommandBufferCallback> wrapped_callback(callback);
 
 #if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI)
@@ skipping 46 matching lines @@
         logging::LOG_WARNING,
         "WARNING", 
         "Hardware acceleration is unavailable."));
     return;
   }
 
   callback->Run(
       channel_handle, gpu_process_, GpuDataManager::GetInstance()->gpu_info());
 }
 
-void GpuProcessHost::OnSynchronizeReply() {
-  // Guard against race conditions in abrupt GPU process termination.
-  if (!synchronize_requests_.empty()) {
-    linked_ptr<SynchronizeCallback> callback(synchronize_requests_.front());
-    synchronize_requests_.pop();
-    callback->Run();
-  }
-}
-
 void GpuProcessHost::OnCommandBufferCreated(const int32 route_id) {
   if (!create_command_buffer_requests_.empty()) {
     linked_ptr<CreateCommandBufferCallback> callback =
         create_command_buffer_requests_.front();
     create_command_buffer_requests_.pop();
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback.release(), route_id);
     else
       callback->Run(route_id);
   }
@@ skipping 128 matching lines @@
 void GpuProcessHost::SendOutstandingReplies() {
   // First send empty channel handles for all EstablishChannel requests.
   while (!channel_requests_.empty()) {
     linked_ptr<EstablishChannelCallback> callback = channel_requests_.front();
     channel_requests_.pop();
     EstablishChannelError(callback.release(),
                           IPC::ChannelHandle(),
                           base::kNullProcessHandle,
                           GPUInfo());
   }
-
-  // Now unblock all renderers waiting for synchronization replies.
-  while (!synchronize_requests_.empty()) {
-    linked_ptr<SynchronizeCallback> callback = synchronize_requests_.front();
-    synchronize_requests_.pop();
-    SynchronizeError(callback.release());
-  }
 }
 
 void GpuProcessHost::EstablishChannelError(
     EstablishChannelCallback* callback,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const GPUInfo& gpu_info) {
   scoped_ptr<EstablishChannelCallback> wrapped_callback(callback);
   wrapped_callback->Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }
-
-void GpuProcessHost::SynchronizeError(SynchronizeCallback* callback) {
-  scoped_ptr<SynchronizeCallback> wrapped_callback(callback);
-  wrapped_callback->Run();
-}