Change glimage to accept a type.

gpu/command_buffer/tests/gl_gpu_memory_buffer_unittest.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 <GLES2/gl2.h>
 #include <GLES2/gl2chromium.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 static const int kImageHeight = 32;
 static const int kImageBytesPerPixel = 4;
 
 class MockGpuMemoryBuffer : public gfx::GpuMemoryBuffer {
  public:
   MockGpuMemoryBuffer(int width, int height) {}
   virtual ~MockGpuMemoryBuffer() {
     Die();
   }
 
-  MOCK_METHOD1(Map, void*(gfx::GpuMemoryBuffer::AccessMode));
+  MOCK_METHOD0(Map, void*());
   MOCK_METHOD0(Unmap, void());
   MOCK_CONST_METHOD0(IsMapped, bool());
   MOCK_CONST_METHOD0(GetStride, uint32());
   MOCK_CONST_METHOD0(GetHandle, gfx::GpuMemoryBufferHandle());
   MOCK_METHOD0(Die, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockGpuMemoryBuffer);
 };
 
 class MockGpuMemoryBufferFactory : public GpuMemoryBufferFactory {
  public:
   MockGpuMemoryBufferFactory() {}
   virtual ~MockGpuMemoryBufferFactory() {}
 
-  MOCK_METHOD3(CreateGpuMemoryBuffer,
-               gfx::GpuMemoryBuffer*(size_t, size_t, unsigned));
+  MOCK_METHOD4(CreateGpuMemoryBuffer,
+               gfx::GpuMemoryBuffer*(size_t, size_t, unsigned, unsigned));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockGpuMemoryBufferFactory);
 };
 
 class MockGpuMemoryBufferTest : public testing::Test {
  protected:
   virtual void SetUp() {
     GLManager::Options options;
     image_manager_ = new ImageManager;
@@ skipping 46 matching lines @@
   base::SharedMemory shared_memory;
   shared_memory.CreateAnonymous(bytes);
 
   base::SharedMemoryHandle duped_shared_memory_handle;
   shared_memory.ShareToProcess(base::GetCurrentProcessHandle(),
                                &duped_shared_memory_handle);
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.handle = duped_shared_memory_handle;
 
-  EXPECT_CALL(*gpu_memory_buffer_factory_.get(), CreateGpuMemoryBuffer(
-      kImageWidth, kImageHeight, GL_RGBA8_OES))
+  EXPECT_CALL(*gpu_memory_buffer_factory_.get(),
+              CreateGpuMemoryBuffer(kImageWidth,
+                                    kImageHeight,
+                                    GL_RGBA8_OES,
+                                    GL_IMAGE_CPU_READ_WRITE_CHROMIUM))
       .Times(1)
       .WillOnce(Return(gpu_memory_buffer))
       .RetiresOnSaturation();
   EXPECT_CALL(*gpu_memory_buffer, GetHandle())
       .Times(1)
       .WillOnce(Return(handle))
       .RetiresOnSaturation();
 
   // Create the image. This should add the image ID to the ImageManager.
-  GLuint image_id = glCreateImageCHROMIUM(
-      kImageWidth, kImageHeight, GL_RGBA8_OES);
+  GLuint image_id = glCreateImageCHROMIUM(kImageWidth,
+                                          kImageHeight,
+                                          GL_RGBA8_OES,
+                                          GL_IMAGE_CPU_READ_WRITE_CHROMIUM);
   EXPECT_NE(0u, image_id);
   EXPECT_TRUE(image_manager_->LookupImage(image_id) != NULL);
 
   EXPECT_CALL(*gpu_memory_buffer, IsMapped())
       .WillOnce(Return(false))
       .RetiresOnSaturation();
 
   shared_memory.Map(bytes);
   EXPECT_TRUE(shared_memory.memory());
 
-  EXPECT_CALL(*gpu_memory_buffer, Map(gfx::GpuMemoryBuffer::READ_WRITE))
+  EXPECT_CALL(*gpu_memory_buffer, Map())
       .Times(1)
       .WillOnce(Return(shared_memory.memory()))
       .RetiresOnSaturation();
-  uint8* mapped_buffer = static_cast<uint8*>(
-      glMapImageCHROMIUM(image_id, GL_READ_WRITE));
+  uint8* mapped_buffer = static_cast<uint8*>(glMapImageCHROMIUM(image_id));
   ASSERT_TRUE(mapped_buffer != NULL);
 
   // Assign a value to each pixel.
   int stride = kImageWidth * kImageBytesPerPixel;
   for (int x = 0; x < kImageWidth; ++x) {
     for (int y = 0; y < kImageHeight; ++y) {
       mapped_buffer[y * stride + x * kImageBytesPerPixel + 0] = pixels[0];
       mapped_buffer[y * stride + x * kImageBytesPerPixel + 1] = pixels[1];
       mapped_buffer[y * stride + x * kImageBytesPerPixel + 2] = pixels[2];
       mapped_buffer[y * stride + x * kImageBytesPerPixel + 3] = pixels[3];
@@ skipping 32 matching lines @@
 
   // Destroy the image.
   EXPECT_CALL(*gpu_memory_buffer, Die())
       .Times(1)
       .RetiresOnSaturation();
   glDestroyImageCHROMIUM(image_id);
 }
 
 }  // namespace gles2
 }  // namespace gpu