If compositor window already exists, then simply return it rather than compla...

chrome/browser/gpu_process_host.cc

 // Copyright (c) 2010 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 "chrome/browser/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/thread.h"
@@ skipping 168 matching lines @@
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_GetViewXID, OnGetViewXID)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ReleaseXID, OnReleaseXID)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_ResizeXID, OnResizeXID)
 #elif defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
                         OnAcceleratedSurfaceSetIOSurface)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                         OnAcceleratedSurfaceBuffersSwapped)
 #elif defined(OS_WIN)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_CreateCompositorHostWindow,
-                                    OnCreateCompositorHostWindow)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_GetCompositorHostWindow,
+                                    OnGetCompositorHostWindow)
 #endif
     // If the IO thread does not handle the message then automatically route it
     // to the UI thread. The UI thread will report an error if it does not
     // handle it.
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
@@ skipping 190 matching lines @@
 }
 
 #elif defined(OS_WIN)
 
 namespace {
 
 void SendDelayedReply(IPC::Message* reply_msg) {
   GpuProcessHost::Get()->Send(reply_msg);
 }
 
-void CreateCompositorHostWindowDispatcher(
+void GetCompositorHostWindowDispatcher(
     int renderer_id,
     int render_view_id,
     IPC::Message* reply_msg) {
   RenderViewHost* host = RenderViewHost::FromID(renderer_id,
                                                 render_view_id);
   if (!host) {
-    GpuHostMsg_CreateCompositorHostWindow::WriteReplyParams(reply_msg,
+    GpuHostMsg_GetCompositorHostWindow::WriteReplyParams(reply_msg,
         gfx::kNullPluginWindow);
     BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableFunction(&SendDelayedReply, reply_msg));
     return;
   }
 
   RenderWidgetHostView* view = host->view();
-  gfx::PluginWindowHandle id = view->CreateCompositorHostWindow();
+  gfx::PluginWindowHandle id = view->GetCompositorHostWindow();
 
 
-  GpuHostMsg_CreateCompositorHostWindow::WriteReplyParams(reply_msg, id);
+  GpuHostMsg_GetCompositorHostWindow::WriteReplyParams(reply_msg, id);
   BrowserThread::PostTask(
     BrowserThread::IO, FROM_HERE,
     NewRunnableFunction(&SendDelayedReply, reply_msg));
 }
 
 }  // namespace
 
-void GpuProcessHost::OnCreateCompositorHostWindow(
+void GpuProcessHost::OnGetCompositorHostWindow(
     int renderer_id,
     int render_view_id,
     IPC::Message* reply_message) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(&CreateCompositorHostWindowDispatcher,
+      NewRunnableFunction(&GetCompositorHostWindowDispatcher,
           renderer_id, render_view_id, reply_message));
 }
 
 #endif
 
 void GpuProcessHost::SendEstablishChannelReply(
     const IPC::ChannelHandle& channel,
     const GPUInfo& gpu_info,
     ResourceMessageFilter* filter) {
   ViewMsg_GpuChannelEstablished* message =
@@ skipping 85 matching lines @@
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
 #endif
       cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             kLaunched, kGPUProcessLifetimeEvent_Max);
   return true;
 }