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

cc/test/test_gpu_memory_buffer_manager.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 "cc/test/test_gpu_memory_buffer_manager.h"
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace cc {
 namespace {
 
 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
   GpuMemoryBufferImpl(const gfx::Size& size,
                       gfx::BufferFormat format,
                       scoped_ptr<base::SharedMemory> shared_memory)
       : size_(size),
         format_(format),
         shared_memory_(shared_memory.Pass()),
         mapped_(false) {}
 
   // Overridden from gfx::GpuMemoryBuffer:
-  bool Map(void** data) override {
+  bool Map() override {
     DCHECK(!mapped_);
     if (!shared_memory_->Map(gfx::BufferSizeForBufferFormat(size_, format_)))
       return false;
     mapped_ = true;
-    size_t offset = 0;
-    int num_planes =
-        static_cast<int>(gfx::NumberOfPlanesForBufferFormat(format_));
-    for (int i = 0; i < num_planes; ++i) {
-      data[i] = reinterpret_cast<uint8*>(shared_memory_->memory()) + offset;
-      offset +=
-          gfx::RowSizeForBufferFormat(size_.width(), format_, i) *
-          (size_.height() / gfx::SubsamplingFactorForBufferFormat(format_, i));
-    }
     return true;
   }
+  void* memory(size_t plane) override {
+    DCHECK(mapped_);
+    DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
+    return reinterpret_cast<uint8_t*>(shared_memory_->memory()) +
+           gfx::BufferOffsetForBufferFormat(size_, format_, plane);
+  }
   void Unmap() override {
     DCHECK(mapped_);
     shared_memory_->Unmap();
     mapped_ = false;
   }
   gfx::Size GetSize() const override { return size_; }
   gfx::BufferFormat GetFormat() const override { return format_; }
-  void GetStride(int* stride) const override {
-    int num_planes =
-        static_cast<int>(gfx::NumberOfPlanesForBufferFormat(format_));
-    for (int i = 0; i < num_planes; ++i)
-      stride[i] = base::checked_cast<int>(
-          gfx::RowSizeForBufferFormat(size_.width(), format_, i));
+  int stride(size_t plane) const override {
+    DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
+    return base::checked_cast<int>(gfx::RowSizeForBufferFormat(
+        size_.width(), format_, static_cast<int>(plane)));
   }
   gfx::GpuMemoryBufferId GetId() const override {
     NOTREACHED();
     return gfx::GpuMemoryBufferId(0);
   }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     gfx::GpuMemoryBufferHandle handle;
     handle.type = gfx::SHARED_MEMORY_BUFFER;
     handle.handle = shared_memory_->handle();
     return handle;
@@ skipping 43 matching lines @@
     ClientBuffer buffer) {
   return reinterpret_cast<gfx::GpuMemoryBuffer*>(buffer);
 }
 
 void TestGpuMemoryBufferManager::SetDestructionSyncPoint(
     gfx::GpuMemoryBuffer* buffer,
     uint32 sync_point) {
 }
 
 }  // namespace cc