Moved creation of GPU transfer buffers into the browser process....

chrome/browser/gpu_process_host_ui_shim.h

 // 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.
 
 #ifndef CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_
 #define CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_
 #pragma once
 
 // This class lives on the UI thread and supports classes like the
 // BackingStoreProxy, which must live on the UI thread. The IO thread
 // portion of this class, the GpuProcessHost, is responsible for
 // shuttling messages between the browser and GPU processes.
 
 #include <map>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/linked_ptr.h"
+#include "base/process.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/values.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/message_router.h"
 #include "ipc/ipc_channel.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ skipping 22 matching lines @@
   // Returns null on failure. It is not safe to store the pointer once control
   // has returned to the message loop as it can be destroyed. Instead store the
   // associated GPU host ID. A renderer ID of zero means the browser process.
   static GpuProcessHostUIShim* GetForRenderer(int renderer_id);
 
   // Destroy the GpuProcessHostUIShim with the given host ID. This can only
   // be called on the UI thread. Only the GpuProcessHost should destroy the
   // UI shim.
   static void Destroy(int host_id);
 
+  // The GPU process is launched asynchronously. If it launches successfully,
+  // this function is called on the UI thread with the process handle. On
+  // Windows, the UI shim takes ownership of the handle.
+  static void NotifyGpuProcessLaunched(int host_id,
+                                       base::ProcessHandle gpu_process);
+
   static GpuProcessHostUIShim* FromID(int host_id);
   int host_id() const { return host_id_; }
 
   // IPC::Channel::Sender implementation.
   virtual bool Send(IPC::Message* msg);
 
   // Sends outstanding replies. This is only called
   // in error situations like the GPU process crashing -- but is necessary
   // to prevent the blocked clients from hanging.
   void SendOutstandingReplies();
 
   // IPC::Channel::Listener implementation.
   // The GpuProcessHost causes this to be called on the UI thread to
   // dispatch the incoming messages from the GPU process, which are
   // actually received on the IO thread.
   virtual bool OnMessageReceived(const IPC::Message& message);
 
-  typedef Callback2<const IPC::ChannelHandle&, const GPUInfo&>::Type
+  typedef Callback3<const IPC::ChannelHandle&,
+                    base::ProcessHandle,
+                    const GPUInfo&>::Type
     EstablishChannelCallback;
 
   // Tells the GPU process to create a new channel for communication with a
   // renderer. Once the GPU process responds asynchronously with the IPC handle
   // and GPUInfo, we call the callback.
   void EstablishGpuChannel(
       int renderer_id, EstablishChannelCallback* callback);
 
   typedef Callback0::Type SynchronizeCallback;
 
@@ skipping 71 matching lines @@
       const GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params& params);
   void OnAcceleratedSurfaceBuffersSwapped(
       const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
 #elif defined(OS_WIN)
   void OnScheduleComposite(int32 renderer_id, int32 render_view_id);
 #endif
 
   // The serial number of the GpuProcessHost / GpuProcessHostUIShim pair.
   int host_id_;
 
+  // The handle for the GPU process or null if it is not known to be launched.
+  base::ProcessHandle gpu_process_;
+
   GPUInfo gpu_info_;
   ListValue log_messages_;
 
   // Used only in testing. If set, the callback is invoked when the GPU info
   // has been collected.
   scoped_ptr<Callback0::Type> gpu_info_collected_callback_;
 
   // These are the channel requests that we have already sent to
   // the GPU process, but haven't heard back about yet.
   std::queue<linked_ptr<EstablishChannelCallback> > channel_requests_;
@@ skipping 14 matching lines @@
   class ViewSurface;
   std::map<ViewID, linked_ptr<ViewSurface> > acquired_surfaces_;
 
   bool gpu_feature_flags_set_;
   scoped_ptr<GpuBlacklist> gpu_blacklist_;
   GpuFeatureFlags gpu_feature_flags_;
 };
 
 #endif  // CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_