gpu: Refactor GpuMemoryBuffer framework for multi-process support.

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 GPU_COMMAND_BUFFER_CLIENT_GPU_MEMORY_BUFFER_H_
-#define GPU_COMMAND_BUFFER_CLIENT_GPU_MEMORY_BUFFER_H_
+#ifndef GPU_UI_GFX_GPU_MEMORY_BUFFER_H_
+#define GPU_UI_GFX_GPU_MEMORY_BUFFER_H_
 
-#include "base/basictypes.h"
-#include "base/memory/scoped_ptr.h"
-#include "gles2_impl_export.h"
+#include "base/logging.h"
+#include "base/memory/shared_memory.h"
+#include "ui/base/ui_export.h"
 
-namespace gpu {
+#if defined(OS_ANDROID)
+#include <third_party/khronos/EGL/egl.h>

[kaanb, 2013/07/24 03:31:23]

I had added a define for EGL_NATIVE_BUFFER_ANDROID in gl_bindings.h, it may be
possible to remove it now that you're adding this include, can you check?

[reveman, 2013/07/24 05:47:12]

Oh, would it be more appropriate to include gl_bindings.h instead? Why was it
added to that file instead of including third_party/khronos/EGL/egl.h?

[reveman, 2013/07/25 19:50:25]

Removed your EGL_NATIVE_BUFFER_ANDROID define from latest patch.

+#endif
+
+namespace gfx {
+
+enum GpuMemoryBufferType {
+  EMPTY_BUFFER,
+  SHARED_MEMORY_BUFFER,
+  EGL_CLIENT_BUFFER
+};
+
+struct GpuMemoryBufferHandle {
+  GpuMemoryBufferHandle() : type(EMPTY_BUFFER) {}
+  GpuMemoryBufferHandle(
+      base::SharedMemoryHandle handle_, GpuMemoryBufferType type_)
+      : type(type_),
+        handle(handle_) {
+    DCHECK(!is_null());
+  }
+  bool is_null() const { return type == EMPTY_BUFFER; }
+  GpuMemoryBufferType type;
+  base::SharedMemoryHandle handle;
+#if defined(OS_ANDROID)
+  EGLClientBuffer native_buffer;
+#endif
+};
 
 // Interface for creating and accessing a zero-copy GPU memory buffer.
 // This design evolved from the generalization of GraphicBuffer API
 // of Android framework.
 //
 // THREADING CONSIDERATIONS:
 //
 // This interface is thread-safe. However, multiple threads mapping
 // a buffer for Write or ReadOrWrite simultaneously may result in undefined
 // behavior and is not allowed.
-class GLES2_IMPL_EXPORT GpuMemoryBuffer {
+class UI_EXPORT GpuMemoryBuffer {
  public:
   enum AccessMode {
     READ_ONLY,
     WRITE_ONLY,
     READ_WRITE,
   };
 
   // Frees a previously allocated buffer. Freeing a buffer that is still
   // mapped in any process is undefined behavior.
   virtual ~GpuMemoryBuffer() {}
 
   // Maps the buffer so the client can write the bitmap data in |*vaddr|
   // subsequently. This call may block, for instance if the hardware needs
   // to finish rendering or if CPU caches need to be synchronized.
   virtual void Map(AccessMode mode, void** vaddr) = 0;
 
   // Unmaps the buffer. Called after all changes to the buffer are
   // completed.
   virtual void Unmap() = 0;
 
   // Returns true iff the buffer is mapped.
-  virtual bool IsMapped() = 0;
-
-  // Returns the native pointer for the buffer.
-  virtual void* GetNativeBuffer() = 0;
+  virtual bool IsMapped() const = 0;
 
   // Returns the stride in bytes for the buffer.
-  virtual uint32 GetStride() = 0;
+  virtual uint32 GetStride() const = 0;
+
+  // Returns a platform specific handle for this buffer.
+  virtual GpuMemoryBufferHandle GetHandle() const = 0;
 };
 
-}  // namespace gpu
+}  // namespace gfx
 
-#endif  // GPU_COMMAND_BUFFER_CLIENT_GPU_MEMORY_BUFFER_H_
+#endif  // UI_GFX_GPU_MEMORY_BUFFER_H_