Plumb GpuMemoryBuffer allocation to GPU process.

ui/gfx/gpu_memory_buffer.h

 // Copyright 2013 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 UI_GFX_GPU_MEMORY_BUFFER_H_
 #define UI_GFX_GPU_MEMORY_BUFFER_H_
 
 #include "base/memory/shared_memory.h"
 #include "build/build_config.h"
 #include "ui/gfx/gfx_export.h"
+#include "ui/gfx/native_widget_types.h"
 
 #if defined(OS_ANDROID)
 #include <third_party/khronos/EGL/egl.h>
 #endif
 
 namespace gfx {
 
 enum GpuMemoryBufferType {
   EMPTY_BUFFER,
   SHARED_MEMORY_BUFFER,
   IO_SURFACE_BUFFER,
   ANDROID_NATIVE_BUFFER,
   SURFACE_TEXTURE_BUFFER,
   GPU_MEMORY_BUFFER_TYPE_LAST = SURFACE_TEXTURE_BUFFER
 };
 
-#if defined(OS_ANDROID)
-struct SurfaceTextureId {
-  SurfaceTextureId() : primary_id(0), secondary_id(0) {}
-  SurfaceTextureId(int32 primary_id, int32 secondary_id)
+struct GpuMemoryBufferId {
+  GpuMemoryBufferId() : primary_id(0), secondary_id(base::kNullProcessId) {}
+  GpuMemoryBufferId(int32 primary_id, base::ProcessId secondary_id)
       : primary_id(primary_id), secondary_id(secondary_id) {}
   int32 primary_id;
-  int32 secondary_id;
+  base::ProcessId secondary_id;

[alexst (slow to review), 2014/05/30 22:41:47]

I'm thinking we can utilize this generically and with current API for
AllocateForChildProcess, we can obtain pid from process_handle.

GPU channel doesn't deal with process handles, and on windows the handle means
more than just pid and requires opening and closing the it, so I think pid is a
better choice here. Or we could plumb client_id like you did on android into
AllocateForChildProcess.

[reveman, 2014/05/31 00:34:02]

Let's keep this a client id. The client id is controlled by chrome and we know
it's unlikely to wrap around and cause a security issue. If it's a ProcessId,
then we have to worry about an old id being reused by the system for a new
renderer process.

We'll end up sharing this when surface texture creation switches over to this
new API. You can keep SurfaceTextureId and GpuMemoryBufferId separate for now
and SurfaceTextureId will simply be eliminated as part of the switch to the new
API.

 };
-#endif
 
 struct GpuMemoryBufferHandle {
   GpuMemoryBufferHandle()
       : type(EMPTY_BUFFER),
-        handle(base::SharedMemory::NULLHandle())
+        handle(base::SharedMemory::NULLHandle()),
+        window(kNullPluginWindow)
 #if defined(OS_MACOSX)
         ,
         io_surface_id(0u)
 #endif
 #if defined(OS_ANDROID)
         ,
         native_buffer(NULL)
 #endif
   {
   }
   bool is_null() const { return type == EMPTY_BUFFER; }
   GpuMemoryBufferType type;
   base::SharedMemoryHandle handle;
+  gfx::PluginWindowHandle window;
 #if defined(OS_MACOSX)
   uint32 io_surface_id;
 #endif
 #if defined(OS_ANDROID)
   EGLClientBuffer native_buffer;
-  SurfaceTextureId surface_texture_id;
 #endif
+  GpuMemoryBufferId gpu_memory_id;
 };
 
 // This interface typically correspond to a type of shared memory that is also
 // shared with the GPU. A GPU memory buffer can be written to directly by
 // regular CPU code, but can also be read by the GPU.
 class GFX_EXPORT GpuMemoryBuffer {
  public:
   GpuMemoryBuffer();
   virtual ~GpuMemoryBuffer();
 
@@ skipping 13 matching lines @@
   // Returns the stride in bytes for the buffer.
   virtual uint32 GetStride() const = 0;
 
   // Returns a platform specific handle for this buffer.
   virtual GpuMemoryBufferHandle GetHandle() const = 0;
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_GPU_MEMORY_BUFFER_H_