Reland: GpuMemoryBuffer interface change: Map(**) to Map() and memory(plane); stride(plane)

content/common/gpu/client/gpu_memory_buffer_impl_surface_texture.cc

 // Copyright 2014 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/common/gpu/client/gpu_memory_buffer_impl_surface_texture.h"
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/android/surface_texture_manager.h"
 #include "content/common/gpu/gpu_memory_buffer_factory_surface_texture.h"
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 GpuMemoryBufferImplSurfaceTexture::GpuMemoryBufferImplSurfaceTexture(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     const DestructionCallback& callback,
     ANativeWindow* native_window)
     : GpuMemoryBufferImpl(id, size, format, callback),
-      native_window_(native_window),
-      stride_(0) {}
+      native_window_(native_window) {}
 
 GpuMemoryBufferImplSurfaceTexture::~GpuMemoryBufferImplSurfaceTexture() {
   ANativeWindow_release(native_window_);
 }
 
 // static
 scoped_ptr<GpuMemoryBufferImplSurfaceTexture>
 GpuMemoryBufferImplSurfaceTexture::CreateFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
@@ skipping 23 matching lines @@
 
 // static
 base::Closure GpuMemoryBufferImplSurfaceTexture::AllocateForTesting(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gfx::GpuMemoryBufferHandle* handle) {
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       gfx::SurfaceTexture::Create(0);
   DCHECK(surface_texture);
-  gfx::GpuMemoryBufferId kBufferId(1);
+  const gfx::GpuMemoryBufferId kBufferId(1);
   SurfaceTextureManager::GetInstance()->RegisterSurfaceTexture(
       kBufferId.id, 0, surface_texture.get());
   handle->type = gfx::SURFACE_TEXTURE_BUFFER;
   handle->id = kBufferId;
   return base::Bind(&FreeSurfaceTextureForTesting, surface_texture, kBufferId);
 }
 
-bool GpuMemoryBufferImplSurfaceTexture::Map(void** data) {
+bool GpuMemoryBufferImplSurfaceTexture::Map() {
   TRACE_EVENT0("gpu", "GpuMemoryBufferImplSurfaceTexture::Map");
-
   DCHECK(!mapped_);
   DCHECK(native_window_);
-  ANativeWindow_Buffer buffer;
-  int status = ANativeWindow_lock(native_window_, &buffer, NULL);
-  if (status) {
-    VLOG(1) << "ANativeWindow_lock failed with error code: " << status;
+  if (ANativeWindow_lock(native_window_, &buffer_, NULL)) {
+    DPLOG(ERROR) << "ANativeWindow_lock failed";
     return false;
   }
+  DCHECK_LE(size_.width(), buffer_.stride);
+  mapped_ = true;
+  return true;
+}
 
-  DCHECK_LE(size_.width(), buffer.stride);
-  stride_ = gfx::RowSizeForBufferFormat(buffer.stride, format_, 0);
-  mapped_ = true;
-  *data = buffer.bits;
-  return true;
+void* GpuMemoryBufferImplSurfaceTexture::memory(size_t plane) {
+  TRACE_EVENT0("gpu", "GpuMemoryBufferImplSurfaceTexture::memory");
+  DCHECK(mapped_);
+  DCHECK_EQ(0u, plane);
+  return buffer_.bits;
 }
 
 void GpuMemoryBufferImplSurfaceTexture::Unmap() {
   TRACE_EVENT0("gpu", "GpuMemoryBufferImplSurfaceTexture::Unmap");
-
   DCHECK(mapped_);
   ANativeWindow_unlockAndPost(native_window_);
   mapped_ = false;
 }
 
-void GpuMemoryBufferImplSurfaceTexture::GetStride(int* stride) const {
-  *stride = stride_;
+int GpuMemoryBufferImplSurfaceTexture::stride(size_t plane) const {
+  DCHECK(mapped_);
+  DCHECK_EQ(0u, plane);
+  return gfx::RowSizeForBufferFormat(buffer_.stride, format_, 0);
 }
 
-gfx::GpuMemoryBufferHandle GpuMemoryBufferImplSurfaceTexture::GetHandle()
-    const {
+gfx::GpuMemoryBufferHandle
+GpuMemoryBufferImplSurfaceTexture::GetHandle() const {
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SURFACE_TEXTURE_BUFFER;
   handle.id = id_;
   return handle;
 }
 
 }  // namespace content