ui: Rename gfx::BufferUsage enum values and add BufferUsage::GPU_READ.

The problem with the current usage modes is that we currently use
SCANOUT for anything that doesn't require CPU access. When importing
a buffer we typically don't care about anything but having the GPU
be able to read from it. SCANOUT is not a good description of that
and currently means GPU read/write support.

This patch attempts to make usage more explicit and it solves the
use case where a buffer type can only provide GPU read and not GPU
write support (e.g. SHM fallback). Here are the new usage modes:

- GPU_READ
- GPU_READ_WRITE
- GPU_READ_CPU_READ_WRITE

GPU_READ is useful when importing a buffer and all you care about is
being able to use it for sampling and optionally scanout.

GPU_READ_WRITE is useful for things like WebGL or GPU raster where
we want the ability to write to the buffer using GL and potentially
use it for scanout.

GPU_READ_CPU_READ_WRITE is the usage mode that allows CPU access and
is used for one-copy and zero-copy texture initialization. There's
nothing preventing this mode from also supporting scanout.

- GPU_READ_CPU_READ_WRITE_PERSISTENT

This usage mode indicates that the data will be persistent across
Unmap()/Map() calls but will likely become part of the normal
GPU_READ_CPU_READ_WRITE usage once all buffer types support this.

BUG=538325
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1420923005

Cr-Commit-Position: refs/heads/master@{#356108}

42 files changed, 153 insertions, 169 deletions

diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_tile_task_worker_pool.cc
index 94c8a8e..18be9c2 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_tile_task_worker_pool.cc
@@ -388,14 +388,15 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     base::AutoUnlock unlock(lock_);
 
     // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
-    // must allocate a buffer with BufferUsage PERSISTENT_MAP.
+    // must allocate a buffer with BufferUsage CPU_READ_WRITE_PERSISTENT.
     if (!staging_buffer->gpu_memory_buffer) {
       staging_buffer->gpu_memory_buffer =
           resource_provider_->gpu_memory_buffer_manager()
               ->AllocateGpuMemoryBuffer(
                   staging_buffer->size, BufferFormat(resource->format()),
-                  use_partial_raster_ ? gfx::BufferUsage::PERSISTENT_MAP
-                                      : gfx::BufferUsage::MAP);
+                  use_partial_raster_
+                      ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
+                      : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
       DCHECK_EQ(gfx::NumberOfPlanesForBufferFormat(
                     staging_buffer->gpu_memory_buffer->GetFormat()),
                 1u);
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 5bfacfe..15c4dee 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -913,7 +913,8 @@ ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
     return gpu_memory_buffer_;
   scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
-          size_, BufferFormat(format_), gfx::BufferUsage::MAP);
+          size_, BufferFormat(format_),
+          gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
   gpu_memory_buffer_ = gpu_memory_buffer.release();
   return gpu_memory_buffer_;
 }
diff --git a/chromecast/renderer/media/hole_frame_factory.cc b/chromecast/renderer/media/hole_frame_factory.cc
index 510b975..cd905d2 100644
--- a/chromecast/renderer/media/hole_frame_factory.cc
+++ b/chromecast/renderer/media/hole_frame_factory.cc
@@ -25,8 +25,8 @@ HoleFrameFactory::HoleFrameFactory(
 
     gl->GenTextures(1, &texture_);
     gl->BindTexture(GL_TEXTURE_2D, texture_);
-    image_id_ = gl->CreateGpuMemoryBufferImageCHROMIUM(
-        1, 1, GL_RGBA, GL_SCANOUT_CHROMIUM);
+    image_id_ = gl->CreateGpuMemoryBufferImageCHROMIUM(1, 1, GL_RGBA,
+                                                       GL_READ_WRITE_CHROMIUM);
     gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id_);
 
     gl->GenMailboxCHROMIUM(mailbox_.name);
diff --git a/components/mus/gles2/command_buffer_local.cc b/components/mus/gles2/command_buffer_local.cc
index 2c6f7ac..977207fc 100644
--- a/components/mus/gles2/command_buffer_local.cc
+++ b/components/mus/gles2/command_buffer_local.cc
@@ -25,7 +25,7 @@
 
 namespace mus {
 
-const unsigned int GL_MAP_CHROMIUM = 0x78F1;
+const unsigned int GL_READ_WRITE_CHROMIUM = 0x78F2;
 
 CommandBufferLocal::CommandBufferLocal(CommandBufferLocalClient* client,
                                        gfx::AcceleratedWidget widget,
@@ -164,11 +164,11 @@ int32_t CommandBufferLocal::CreateGpuMemoryBufferImage(size_t width,
                                                        size_t height,
                                                        unsigned internalformat,
                                                        unsigned usage) {
-  DCHECK_EQ(usage, static_cast<unsigned>(GL_MAP_CHROMIUM));
+  DCHECK_EQ(usage, static_cast<unsigned>(GL_READ_WRITE_CHROMIUM));
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(MojoGpuMemoryBufferImpl::Create(
       gfx::Size(static_cast<int>(width), static_cast<int>(height)),
       gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
-      gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
+      gfx::BufferUsage::GPU_READ_WRITE));
   if (!buffer)
     return -1;
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
index be1f8e2..099d050 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
@@ -112,16 +112,16 @@ GpuMemoryBufferConfigurationSet GetNativeGpuMemoryBufferConfigurations() {
 #endif
 
 #if defined(USE_OZONE) || defined(OS_MACOSX)
-  bool force_native_scanout_formats = true;
+  bool force_native_gpu_read_write_formats = true;
 #else
-  bool force_native_scanout_formats = false;
+  bool force_native_gpu_read_write_formats = false;
 #endif
 
   // Disable native buffers when using Mesa.
   if (base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kUseGL) == gfx::kGLImplementationOSMesaName) {
     enable_native_gpu_memory_buffers = false;
-    force_native_scanout_formats = false;
+    force_native_gpu_read_write_formats = false;
   }
 
   if (enable_native_gpu_memory_buffers) {
@@ -129,8 +129,10 @@ GpuMemoryBufferConfigurationSet GetNativeGpuMemoryBufferConfigurations() {
         gfx::BufferFormat::R_8,       gfx::BufferFormat::RGBA_4444,
         gfx::BufferFormat::RGBA_8888, gfx::BufferFormat::BGRA_8888,
         gfx::BufferFormat::UYVY_422,  gfx::BufferFormat::YUV_420_BIPLANAR};
-    const gfx::BufferUsage kNativeUsages[] = {gfx::BufferUsage::MAP,
-                                              gfx::BufferUsage::PERSISTENT_MAP};
+    const gfx::BufferUsage kNativeUsages[] = {
+        gfx::BufferUsage::GPU_READ, gfx::BufferUsage::GPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT};
     for (auto& format : kNativeFormats) {
       for (auto& usage : kNativeUsages) {
         if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(format, usage))
@@ -139,16 +141,16 @@ GpuMemoryBufferConfigurationSet GetNativeGpuMemoryBufferConfigurations() {
     }
   }
 
-  if (force_native_scanout_formats) {
-    const gfx::BufferFormat kScanoutFormats[] = {
+  if (force_native_gpu_read_write_formats) {
+    const gfx::BufferFormat kGPUReadWriteFormats[] = {
         gfx::BufferFormat::RGBA_8888, gfx::BufferFormat::RGBX_8888,
         gfx::BufferFormat::BGRA_8888, gfx::BufferFormat::BGRX_8888,
         gfx::BufferFormat::UYVY_422,  gfx::BufferFormat::YUV_420_BIPLANAR};
-    for (auto& format : kScanoutFormats) {
+    for (auto& format : kGPUReadWriteFormats) {
       if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(
-              format, gfx::BufferUsage::SCANOUT)) {
+              format, gfx::BufferUsage::GPU_READ_WRITE)) {
         configurations.insert(
-            std::make_pair(format, gfx::BufferUsage::SCANOUT));
+            std::make_pair(format, gfx::BufferUsage::GPU_READ_WRITE));
       }
     }
   }
@@ -191,7 +193,7 @@ struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandleRequest
       int client_id)
       : CreateGpuMemoryBufferRequest(size,
                                      format,
-                                     gfx::BufferUsage::SCANOUT,
+                                     gfx::BufferUsage::GPU_READ,
                                      client_id,
                                      0),
         handle(handle) {}
@@ -289,7 +291,7 @@ BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForScanout(
     int32 surface_id) {
   DCHECK_GT(surface_id, 0);
   return AllocateGpuMemoryBufferForSurface(
-      size, format, gfx::BufferUsage::SCANOUT, surface_id);
+      size, format, gfx::BufferUsage::GPU_READ_WRITE, surface_id);
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.h b/content/browser/gpu/browser_gpu_memory_buffer_manager.h
index 18eb7d9..05ae443 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.h
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.h
@@ -98,7 +98,7 @@ class CONTENT_EXPORT BrowserGpuMemoryBufferManager
     BufferInfo()
         : type(gfx::EMPTY_BUFFER),
           format(gfx::BufferFormat::RGBA_8888),
-          usage(gfx::BufferUsage::MAP),
+          usage(gfx::BufferUsage::GPU_READ),
           gpu_host_id(0) {}
     BufferInfo(const gfx::Size& size,
                gfx::GpuMemoryBufferType type,
diff --git a/content/browser/renderer_host/media/video_capture_buffer_pool.cc b/content/browser/renderer_host/media/video_capture_buffer_pool.cc
index 31fa7e7..c4843e3 100644
--- a/content/browser/renderer_host/media/video_capture_buffer_pool.cc
+++ b/content/browser/renderer_host/media/video_capture_buffer_pool.cc
@@ -219,9 +219,8 @@ bool VideoCaptureBufferPool::GpuMemoryBufferTracker::Init(
         media::VideoFrame::PlaneSize(pixel_format(), i, dimensions);
     gpu_memory_buffers_.push_back(
         BrowserGpuMemoryBufferManager::current()->AllocateGpuMemoryBuffer(
-            size,
-            gfx::BufferFormat::R_8,
-            gfx::BufferUsage::MAP));
+            size, gfx::BufferFormat::R_8,
+            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE));
 
     DLOG_IF(ERROR, !gpu_memory_buffers_[i]) << "Allocating GpuMemoryBuffer";
     if (!gpu_memory_buffers_[i] || !gpu_memory_buffers_[i]->Map())
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index bde103a..47f1064 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -1169,9 +1169,10 @@ static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   // Persistent buffers may come at a performance hit (not all platform specific
   // buffers support it), so only enable them if partial raster is enabled and
   // we are actually going to use them.
-  gfx::BufferUsage buffer_usage = IsPartialRasterEnabled()
-                                      ? gfx::BufferUsage::PERSISTENT_MAP
-                                      : gfx::BufferUsage::MAP;
+  gfx::BufferUsage buffer_usage =
+      IsPartialRasterEnabled()
+          ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
+          : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
   std::vector<unsigned> image_targets(
       static_cast<size_t>(gfx::BufferFormat::LAST) + 1, GL_TEXTURE_2D);
   for (size_t format = 0;
@@ -1186,7 +1187,7 @@ static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   command_line->AppendSwitchASCII(
       switches::kVideoImageTextureTarget,
       base::UintToString(BrowserGpuMemoryBufferManager::GetImageTextureTarget(
-          gfx::BufferFormat::R_8, gfx::BufferUsage::MAP)));
+          gfx::BufferFormat::R_8, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE)));
 
   // Appending disable-gpu-feature switches due to software rendering list.
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
diff --git a/content/child/child_thread_impl_browsertest.cc b/content/child/child_thread_impl_browsertest.cc
index 1fbf244..6b00c9e 100644
--- a/content/child/child_thread_impl_browsertest.cc
+++ b/content/child/child_thread_impl_browsertest.cc
@@ -154,7 +154,7 @@ IN_PROC_BROWSER_TEST_P(ChildThreadImplGpuMemoryBufferBrowserTest,
 
   scoped_ptr<gfx::GpuMemoryBuffer> buffer =
       child_gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
-          buffer_size, format, gfx::BufferUsage::MAP);
+          buffer_size, format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
   ASSERT_TRUE(buffer);
   EXPECT_EQ(format, buffer->GetFormat());
 
diff --git a/content/common/gpu/client/command_buffer_proxy_impl.cc b/content/common/gpu/client/command_buffer_proxy_impl.cc
index c1cc362..4ae3741 100644
--- a/content/common/gpu/client/command_buffer_proxy_impl.cc
+++ b/content/common/gpu/client/command_buffer_proxy_impl.cc
@@ -462,7 +462,7 @@ int32_t CommandBufferProxyImpl::CreateGpuMemoryBufferImage(
       channel_->gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
-          gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
+          gfx::BufferUsage::GPU_READ_WRITE));
   if (!buffer)
     return -1;
 
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_io_surface.cc b/content/common/gpu/client/gpu_memory_buffer_impl_io_surface.cc
index a65db1c..84312e6 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl_io_surface.cc
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_io_surface.cc
@@ -14,11 +14,11 @@ namespace {
 
 uint32_t LockFlags(gfx::BufferUsage usage) {
   switch (usage) {
-    case gfx::BufferUsage::MAP:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
       return kIOSurfaceLockAvoidSync;
-    case gfx::BufferUsage::PERSISTENT_MAP:
-      return 0;
-    case gfx::BufferUsage::SCANOUT:
+    case gfx::BufferUsage::GPU_READ:
+    case gfx::BufferUsage::GPU_READ_WRITE:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return 0;
   }
   NOTREACHED();
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
index 7296bca..a3e6110 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
@@ -95,10 +95,11 @@ GpuMemoryBufferImplSharedMemory::CreateFromHandle(
 // static
 bool GpuMemoryBufferImplSharedMemory::IsUsageSupported(gfx::BufferUsage usage) {
   switch (usage) {
-    case gfx::BufferUsage::MAP:
-    case gfx::BufferUsage::PERSISTENT_MAP:
+    case gfx::BufferUsage::GPU_READ:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return true;
-    case gfx::BufferUsage::SCANOUT:
+    case gfx::BufferUsage::GPU_READ_WRITE:
       return false;
   }
   NOTREACHED();
diff --git a/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc b/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
index bbcb19e..b44f714 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_io_surface.cc
@@ -98,10 +98,11 @@ bool GpuMemoryBufferFactoryIOSurface::IsGpuMemoryBufferConfigurationSupported(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   switch (usage) {
-    case gfx::BufferUsage::SCANOUT:
+    case gfx::BufferUsage::GPU_READ:
+    case gfx::BufferUsage::GPU_READ_WRITE:
       return format == gfx::BufferFormat::BGRA_8888;
-    case gfx::BufferUsage::MAP:
-    case gfx::BufferUsage::PERSISTENT_MAP:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return format == gfx::BufferFormat::R_8 ||
              format == gfx::BufferFormat::BGRA_8888 ||
              format == gfx::BufferFormat::UYVY_422 ||
diff --git a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
index e745e34..9fb631d 100644
--- a/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
+++ b/content/common/gpu/gpu_memory_buffer_factory_surface_texture.cc
@@ -21,10 +21,11 @@ bool GpuMemoryBufferFactorySurfaceTexture::
     IsGpuMemoryBufferConfigurationSupported(gfx::BufferFormat format,
                                             gfx::BufferUsage usage) {
   switch (usage) {
-    case gfx::BufferUsage::SCANOUT:
-    case gfx::BufferUsage::PERSISTENT_MAP:
+    case gfx::BufferUsage::GPU_READ:
+    case gfx::BufferUsage::GPU_READ_WRITE:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return false;
-    case gfx::BufferUsage::MAP:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
       return format == gfx::BufferFormat::RGBA_8888;
   }
   NOTREACHED();
diff --git a/content/common/gpu/media/vaapi_drm_picture.cc b/content/common/gpu/media/vaapi_drm_picture.cc
index 45cd8b3..6d16a0f 100644
--- a/content/common/gpu/media/vaapi_drm_picture.cc
+++ b/content/common/gpu/media/vaapi_drm_picture.cc
@@ -97,7 +97,7 @@ scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CreateNativePixmap(
   // Create a buffer from Ozone.
   return factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size,
                                      gfx::BufferFormat::BGRX_8888,
-                                     gfx::BufferUsage::SCANOUT);
+                                     gfx::BufferUsage::GPU_READ_WRITE);
 }
 
 bool VaapiDrmPicture::Initialize() {
diff --git a/content/renderer/media/video_capture_impl.cc b/content/renderer/media/video_capture_impl.cc
index df0ec54..46ab7c1 100644
--- a/content/renderer/media/video_capture_impl.cc
+++ b/content/renderer/media/video_capture_impl.cc
@@ -73,10 +73,8 @@ class VideoCaptureImpl::ClientBuffer2
       const size_t width = media::VideoFrame::Columns(i, format, size_.width());
       const size_t height = media::VideoFrame::Rows(i, format, size_.height());
       buffers_.push_back(GpuMemoryBufferImpl::CreateFromHandle(
-          handles_[i],
-          gfx::Size(width, height),
-          gfx::BufferFormat::R_8,
-          gfx::BufferUsage::MAP,
+          handles_[i], gfx::Size(width, height), gfx::BufferFormat::R_8,
+          gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
           base::Bind(&ClientBuffer2::DestroyGpuMemoryBuffer,
                      base::Unretained(this))));
       bool rv = buffers_[i]->Map();
diff --git a/content/test/gpu_memory_buffer_factory_test_template.h b/content/test/gpu_memory_buffer_factory_test_template.h
index b0b7725..205dcc1 100644
--- a/content/test/gpu_memory_buffer_factory_test_template.h
+++ b/content/test/gpu_memory_buffer_factory_test_template.h
@@ -29,9 +29,10 @@ TYPED_TEST_P(GpuMemoryBufferFactoryTest, CreateGpuMemoryBuffer) {
   gfx::Size buffer_size(2, 2);
 
   for (auto format : gfx::GetBufferFormatsForTesting()) {
-    gfx::BufferUsage usages[] = {gfx::BufferUsage::MAP,
-                                 gfx::BufferUsage::PERSISTENT_MAP,
-                                 gfx::BufferUsage::SCANOUT};
+    gfx::BufferUsage usages[] = {
+        gfx::BufferUsage::GPU_READ, gfx::BufferUsage::GPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT};
     for (auto usage : usages) {
       if (!TypeParam::IsGpuMemoryBufferConfigurationSupported(format, usage))
         continue;
@@ -64,14 +65,14 @@ TYPED_TEST_P(GpuMemoryBufferFactoryImportTest,
 
   for (auto format : gfx::GetBufferFormatsForTesting()) {
     if (!TypeParam::IsGpuMemoryBufferConfigurationSupported(
-            format, gfx::BufferUsage::SCANOUT)) {
+            format, gfx::BufferUsage::GPU_READ)) {
       continue;
     }
 
     const gfx::GpuMemoryBufferId kBufferId1(1);
     gfx::GpuMemoryBufferHandle handle1 =
         TestFixture::factory_.CreateGpuMemoryBuffer(
-            kBufferId1, buffer_size, format, gfx::BufferUsage::SCANOUT,
+            kBufferId1, buffer_size, format, gfx::BufferUsage::GPU_READ,
             kClientId, gfx::kNullPluginWindow);
     EXPECT_NE(handle1.type, gfx::EMPTY_BUFFER);
 
diff --git a/content/test/gpu_memory_buffer_impl_test_template.h b/content/test/gpu_memory_buffer_impl_test_template.h
index 354ae8c..9153d84 100644
--- a/content/test/gpu_memory_buffer_impl_test_template.h
+++ b/content/test/gpu_memory_buffer_impl_test_template.h
@@ -45,9 +45,10 @@ TYPED_TEST_P(GpuMemoryBufferImplTest, CreateFromHandle) {
   const gfx::Size kBufferSize(8, 8);
 
   for (auto format : gfx::GetBufferFormatsForTesting()) {
-    gfx::BufferUsage usages[] = {gfx::BufferUsage::MAP,
-                                 gfx::BufferUsage::PERSISTENT_MAP,
-                                 gfx::BufferUsage::SCANOUT};
+    gfx::BufferUsage usages[] = {
+        gfx::BufferUsage::GPU_READ, gfx::BufferUsage::GPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT};
     for (auto usage : usages) {
       if (!TypeParam::IsConfigurationSupported(format, usage))
         continue;
@@ -55,8 +56,8 @@ TYPED_TEST_P(GpuMemoryBufferImplTest, CreateFromHandle) {
       bool destroyed = false;
       gfx::GpuMemoryBufferHandle handle;
       GpuMemoryBufferImpl::DestructionCallback destroy_callback =
-          TestFixture::AllocateGpuMemoryBuffer(
-              kBufferSize, format, gfx::BufferUsage::MAP, &handle, &destroyed);
+          TestFixture::AllocateGpuMemoryBuffer(kBufferSize, format, usage,
+                                               &handle, &destroyed);
       scoped_ptr<TypeParam> buffer(TypeParam::CreateFromHandle(
           handle, kBufferSize, format, usage, destroy_callback));
       ASSERT_TRUE(buffer);
@@ -74,15 +75,19 @@ TYPED_TEST_P(GpuMemoryBufferImplTest, Map) {
   const gfx::Size kBufferSize(4, 4);
 
   for (auto format : gfx::GetBufferFormatsForTesting()) {
-    if (!TypeParam::IsConfigurationSupported(format, gfx::BufferUsage::MAP))
+    if (!TypeParam::IsConfigurationSupported(
+            format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE)) {
       continue;
+    }
 
     gfx::GpuMemoryBufferHandle handle;
     GpuMemoryBufferImpl::DestructionCallback destroy_callback =
         TestFixture::AllocateGpuMemoryBuffer(
-            kBufferSize, format, gfx::BufferUsage::MAP, &handle, nullptr);
+            kBufferSize, format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+            &handle, nullptr);
     scoped_ptr<TypeParam> buffer(TypeParam::CreateFromHandle(
-        handle, kBufferSize, format, gfx::BufferUsage::MAP, destroy_callback));
+        handle, kBufferSize, format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+        destroy_callback));
     ASSERT_TRUE(buffer);
 
     const size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
@@ -121,17 +126,19 @@ TYPED_TEST_P(GpuMemoryBufferImplTest, PersistentMap) {
 
   for (auto format : gfx::GetBufferFormatsForTesting()) {
     if (!TypeParam::IsConfigurationSupported(
-            format, gfx::BufferUsage::PERSISTENT_MAP)) {
+            format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT)) {
       continue;
     }
 
     gfx::GpuMemoryBufferHandle handle;
     GpuMemoryBufferImpl::DestructionCallback destroy_callback =
-        TestFixture::AllocateGpuMemoryBuffer(kBufferSize, format,
-                                             gfx::BufferUsage::PERSISTENT_MAP,
-                                             &handle, nullptr);
+        TestFixture::AllocateGpuMemoryBuffer(
+            kBufferSize, format,
+            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT, &handle,
+            nullptr);
     scoped_ptr<TypeParam> buffer(TypeParam::CreateFromHandle(
-        handle, kBufferSize, format, gfx::BufferUsage::PERSISTENT_MAP,
+        handle, kBufferSize, format,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT,
         destroy_callback));
     ASSERT_TRUE(buffer);
 
diff --git a/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_gpu_memory_buffer_image.txt b/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_gpu_memory_buffer_image.txt
index 9f4d09d..d185894 100644
--- a/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_gpu_memory_buffer_image.txt
+++ b/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_gpu_memory_buffer_image.txt
@@ -29,8 +29,7 @@ New Tokens
 
     Accepted by the <usage> parameter of CreateGpuMemoryBufferImageCHROMIUM:
 
-        MAP_CHROMIUM 0x78F1
-        SCANOUT_CHROMIUM 0x78F2
+        READ_WRITE_CHROMIUM 0x78F2
 
 New Procedures and Functions
 
@@ -50,8 +49,7 @@ New Procedures and Functions
     INVALID_ENUM is generated if <internalformat> is not one of
     RGB or RGBA.
 
-    INVALID_ENUM is generated if <usage> is not one of
-    MAP_CHROMIUM or SCANOUT_CHROMIUM.
+    INVALID_ENUM is generated if <usage> is not READ_WRTIE_CHROMIUM.
 
 Errors
 
diff --git a/gpu/GLES2/gl2extchromium.h b/gpu/GLES2/gl2extchromium.h
index a79b3e7..31958b3 100644
--- a/gpu/GLES2/gl2extchromium.h
+++ b/gpu/GLES2/gl2extchromium.h
@@ -111,12 +111,8 @@ typedef void (
 #ifndef GL_CHROMIUM_gpu_memory_buffer_image
 #define GL_CHROMIUM_gpu_memory_buffer_image 1
 
-#ifndef GL_MAP_CHROMIUM
-#define GL_MAP_CHROMIUM 0x78F1
-#endif
-
-#ifndef GL_SCANOUT_CHROMIUM
-#define GL_SCANOUT_CHROMIUM 0x78F2
+#ifndef GL_READ_WRITE_CHROMIUM
+#define GL_READ_WRITE_CHROMIUM 0x78F2
 #endif
 
 #ifndef GL_RGB_YUV_420_CHROMIUM
diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 6c1a705..a1071ab 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1861,8 +1861,7 @@ _NAMED_TYPE_INFO = {
   'ImageUsage': {
     'type': 'GLenum',
     'valid': [
-      'GL_MAP_CHROMIUM',
-      'GL_SCANOUT_CHROMIUM'
+      'GL_READ_WRITE_CHROMIUM',
     ],
   },
   'ValueBufferTarget': {
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 984c483..f0e4e9b 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -5484,13 +5484,7 @@ bool ValidImageFormat(GLenum internalformat,
 }
 
 bool ValidImageUsage(GLenum usage) {
-  switch (usage) {
-    case GL_MAP_CHROMIUM:
-    case GL_SCANOUT_CHROMIUM:
-      return true;
-    default:
-      return false;
-  }
+  return usage == GL_READ_WRITE_CHROMIUM;
 }
 
 }  // namespace
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest.cc b/gpu/command_buffer/client/gles2_implementation_unittest.cc
index 8ff533d..2eabd33 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest.cc
+++ b/gpu/command_buffer/client/gles2_implementation_unittest.cc
@@ -4111,7 +4111,8 @@ TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
   GLsizei max = std::numeric_limits<GLsizei>::max();
   EXPECT_CALL(*gpu_control_, CreateGpuMemoryBufferImage(max, max, _, _))
       .WillOnce(Return(-1));
-  gl_->CreateGpuMemoryBufferImageCHROMIUM(max, max, GL_RGBA, GL_MAP_CHROMIUM);
+  gl_->CreateGpuMemoryBufferImageCHROMIUM(max, max, GL_RGBA,
+                                          GL_READ_WRITE_CHROMIUM);
   // The context should be lost.
   Cmds expected;
   expected.cmd.Init(GL_GUILTY_CONTEXT_RESET_ARB, GL_UNKNOWN_CONTEXT_RESET_ARB);
@@ -4129,7 +4130,8 @@ TEST_F(GLES2ImplementationManualInitTest, NoLoseContextOnOOM) {
   GLsizei max = std::numeric_limits<GLsizei>::max();
   EXPECT_CALL(*gpu_control_, CreateGpuMemoryBufferImage(max, max, _, _))
       .WillOnce(Return(-1));
-  gl_->CreateGpuMemoryBufferImageCHROMIUM(max, max, GL_RGBA, GL_MAP_CHROMIUM);
+  gl_->CreateGpuMemoryBufferImageCHROMIUM(max, max, GL_RGBA,
+                                          GL_READ_WRITE_CHROMIUM);
   // The context should not be lost.
   EXPECT_TRUE(NoCommandsWritten());
 }
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index 82c83fa..ba69729 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -97,7 +97,7 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x9500, "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL",
     },
     {
-        0x78F2, "GL_SCANOUT_CHROMIUM",
+        0x78F2, "GL_READ_WRITE_CHROMIUM",
     },
     {
         0x9138, "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG",
@@ -1906,7 +1906,7 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x84CA, "GL_TEXTURE10",
     },
     {
-        0x78F1, "GL_MAP_CHROMIUM",
+        0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
     },
     {
         0x84CF, "GL_TEXTURE15",
@@ -2752,9 +2752,6 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x8A2A, "GL_UNIFORM_BUFFER_SIZE",
     },
     {
-        0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
-    },
-    {
         0x0DE1, "GL_TEXTURE_2D",
     },
     {
@@ -3925,8 +3922,7 @@ std::string GLES2Util::GetStringImageInternalFormat(uint32_t value) {
 
 std::string GLES2Util::GetStringImageUsage(uint32_t value) {
   static const EnumToString string_table[] = {
-      {GL_MAP_CHROMIUM, "GL_MAP_CHROMIUM"},
-      {GL_SCANOUT_CHROMIUM, "GL_SCANOUT_CHROMIUM"},
+      {GL_READ_WRITE_CHROMIUM, "GL_READ_WRITE_CHROMIUM"},
   };
   return GLES2Util::GetQualifiedEnumString(string_table,
                                            arraysize(string_table), value);
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index aa05581..4f75b7d 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -367,7 +367,7 @@ static const GLenum valid_image_internal_format_table[] = {
 };
 
 static const GLenum valid_image_usage_table[] = {
-    GL_MAP_CHROMIUM, GL_SCANOUT_CHROMIUM,
+    GL_READ_WRITE_CHROMIUM,
 };
 
 static const GLenum valid_index_type_table[] = {
diff --git a/gpu/command_buffer/service/image_factory.cc b/gpu/command_buffer/service/image_factory.cc
index 2a1257e..bcfd121 100644
--- a/gpu/command_buffer/service/image_factory.cc
+++ b/gpu/command_buffer/service/image_factory.cc
@@ -48,20 +48,6 @@ gfx::BufferFormat ImageFactory::DefaultBufferFormatForImageFormat(
 }
 
 // static
-gfx::BufferUsage ImageFactory::ImageUsageToGpuMemoryBufferUsage(
-    unsigned usage) {
-  switch (usage) {
-    case GL_MAP_CHROMIUM:
-      return gfx::BufferUsage::MAP;
-    case GL_SCANOUT_CHROMIUM:
-      return gfx::BufferUsage::SCANOUT;
-    default:
-      NOTREACHED();
-      return gfx::BufferUsage::MAP;
-  }
-}
-
-// static
 bool ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
     unsigned internalformat,
     gfx::BufferFormat format) {
diff --git a/gpu/command_buffer/service/image_factory.h b/gpu/command_buffer/service/image_factory.h
index c805db0..3746d56 100644
--- a/gpu/command_buffer/service/image_factory.h
+++ b/gpu/command_buffer/service/image_factory.h
@@ -26,10 +26,6 @@ class GPU_EXPORT ImageFactory {
   static gfx::BufferFormat DefaultBufferFormatForImageFormat(
       unsigned internalformat);
 
-  // Returns a valid GpuMemoryBuffer usage given a valid usage as defined by
-  // CHROMIUM_gpu_memory_buffer_image.
-  static gfx::BufferUsage ImageUsageToGpuMemoryBufferUsage(unsigned usage);
-
   // Returns true if |internalformat| is compatible with |format|.
   static bool IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       unsigned internalformat,
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index 51b0b0a..5493054 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -778,7 +778,7 @@ int32 InProcessCommandBuffer::CreateGpuMemoryBufferImage(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
-          gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
+          gfx::BufferUsage::GPU_READ_WRITE));
   if (!buffer)
     return -1;
 
diff --git a/gpu/command_buffer/tests/gl_manager.cc b/gpu/command_buffer/tests/gl_manager.cc
index 9bb2a68..4daa466 100644
--- a/gpu/command_buffer/tests/gl_manager.cc
+++ b/gpu/command_buffer/tests/gl_manager.cc
@@ -450,7 +450,7 @@ int32 GLManager::CreateGpuMemoryBufferImage(size_t width,
                                             size_t height,
                                             unsigned internalformat,
                                             unsigned usage) {
-  DCHECK_EQ(usage, static_cast<unsigned>(GL_MAP_CHROMIUM));
+  DCHECK_EQ(usage, static_cast<unsigned>(GL_READ_WRITE_CHROMIUM));
   scoped_ptr<gfx::GpuMemoryBuffer> buffer = GLManager::CreateGpuMemoryBuffer(
       gfx::Size(width, height), gfx::BufferFormat::RGBA_8888);
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
diff --git a/media/video/gpu_memory_buffer_video_frame_pool.cc b/media/video/gpu_memory_buffer_video_frame_pool.cc
index 9510c80..d1e3a3d 100644
--- a/media/video/gpu_memory_buffer_video_frame_pool.cc
+++ b/media/video/gpu_memory_buffer_video_frame_pool.cc
@@ -652,7 +652,8 @@ GpuMemoryBufferVideoFramePool::PoolImpl::GetOrCreateFrameResources(
 
     const gfx::BufferFormat buffer_format = GpuMemoryBufferFormat(format, i);
     plane_resource.gpu_memory_buffer = gpu_factories_->AllocateGpuMemoryBuffer(
-        plane_resource.size, buffer_format, gfx::BufferUsage::MAP);
+        plane_resource.size, buffer_format,
+        gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
 
     gles2->GenTextures(1, &plane_resource.texture_id);
     gles2->BindTexture(texture_target_, plane_resource.texture_id);
diff --git a/mojo/gles2/command_buffer_client_impl.cc b/mojo/gles2/command_buffer_client_impl.cc
index 2074de5..b348687 100644
--- a/mojo/gles2/command_buffer_client_impl.cc
+++ b/mojo/gles2/command_buffer_client_impl.cc
@@ -321,7 +321,7 @@ int32_t CommandBufferClientImpl::CreateGpuMemoryBufferImage(
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(mus::MojoGpuMemoryBufferImpl::Create(
       gfx::Size(static_cast<int>(width), static_cast<int>(height)),
       gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
-      gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
+      gfx::BufferUsage::GPU_READ_WRITE));
   if (!buffer)
     return -1;
 
diff --git a/third_party/mojo/src/mojo/public/c/gpu/GLES2/gl2extmojo.h b/third_party/mojo/src/mojo/public/c/gpu/GLES2/gl2extmojo.h
index 1aa9cdd..a330ed8 100644
--- a/third_party/mojo/src/mojo/public/c/gpu/GLES2/gl2extmojo.h
+++ b/third_party/mojo/src/mojo/public/c/gpu/GLES2/gl2extmojo.h
@@ -128,12 +128,8 @@ typedef void (
 #ifndef GL_CHROMIUM_gpu_memory_buffer_image
 #define GL_CHROMIUM_gpu_memory_buffer_image 1
 
-#ifndef GL_MAP_CHROMIUM
-#define GL_MAP_CHROMIUM 0x78F1
-#endif
-
-#ifndef GL_SCANOUT_CHROMIUM
-#define GL_SCANOUT_CHROMIUM 0x78F2
+#ifndef GL_READ_WRITE_CHROMIUM
+#define GL_READ_WRITE_CHROMIUM 0x78F2
 #endif
 
 #ifdef GL_GLEXT_PROTOTYPES
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index ed80f62..e278394 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -144,10 +144,12 @@ Compositor::Compositor(ui::ContextFactory* context_factory,
   // doesn't currently support partial raster.
   settings.use_partial_raster = !settings.use_zero_copy;
 
-  // Use PERSISTENT_MAP memory buffers to support partial tile raster if needed.
-  gfx::BufferUsage usage = settings.use_partial_raster
-                               ? gfx::BufferUsage::PERSISTENT_MAP
-                               : gfx::BufferUsage::MAP;
+  // Use CPU_READ_WRITE_PERSISTENT memory buffers to support partial tile
+  // raster if needed.
+  gfx::BufferUsage usage =
+      settings.use_partial_raster
+          ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
+          : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
 
   for (size_t format = 0;
       format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
diff --git a/ui/gfx/buffer_types.h b/ui/gfx/buffer_types.h
index aabfb41..2c87905 100644
--- a/ui/gfx/buffer_types.h
+++ b/ui/gfx/buffer_types.h
@@ -29,11 +29,20 @@ enum class BufferFormat {
 };
 
 // The usage mode affects how a buffer can be used. Only buffers created with
-// MAP can be mapped into the client's address space and accessed by the CPU.
-// PERSISTENT_MAP adds the additional condition that successive Map() calls
-// (with Unmap() calls between) will return a pointer to the same memory
-// contents.
-enum class BufferUsage { MAP, PERSISTENT_MAP, SCANOUT, LAST = SCANOUT };
+// *_CPU_READ_WRITE_* can be mapped into the client's address space and accessed
+// by the CPU. *_CPU_READ_WRITE_PERSISTENT adds the additional condition that
+// successive Map() calls (with Unmap() calls between) will return a pointer to
+// the same memory contents.
+enum class BufferUsage {
+  GPU_READ,
+  GPU_READ_WRITE,
+  GPU_READ_CPU_READ_WRITE,
+  // TODO(reveman): Merge this with GPU_READ_CPU_READ_WRITE when SurfaceTexture
+  // backed buffers are single buffered and support it.
+  GPU_READ_CPU_READ_WRITE_PERSISTENT,
+
+  LAST = GPU_READ_CPU_READ_WRITE_PERSISTENT
+};
 
 }  // namespace gfx
 
diff --git a/ui/gl/gl_bindings.h b/ui/gl/gl_bindings.h
index c1ad779..f043bef 100644
--- a/ui/gl/gl_bindings.h
+++ b/ui/gl/gl_bindings.h
@@ -127,8 +127,7 @@
 #define GL_COMMANDS_COMPLETED_CHROMIUM                   0x84F7
 
 // GL_CHROMIUM_gpu_memory_buffer_image
-#define GL_MAP_CHROMIUM                                  0x78F1
-#define GL_SCANOUT_CHROMIUM                              0x78F2
+#define GL_READ_WRITE_CHROMIUM                           0x78F2
 
 // GL_CHROMIUM_yuv_420_image
 #define GL_RGB_YUV_420_CHROMIUM                          0x78FA
diff --git a/ui/gl/gl_enums_implementation_autogen.h b/ui/gl/gl_enums_implementation_autogen.h
index 54dea5a..e6d7c36 100644
--- a/ui/gl/gl_enums_implementation_autogen.h
+++ b/ui/gl/gl_enums_implementation_autogen.h
@@ -46,9 +46,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x0BC2, "GL_ALPHA_TEST_REF_QCOM",
     },
     {
-        0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
-    },
-    {
         0x884D, "GL_TEXTURE_COMPARE_FUNC_EXT",
     },
     {
@@ -97,7 +94,7 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x9500, "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL",
     },
     {
-        0x78F2, "GL_SCANOUT_CHROMIUM",
+        0x78F2, "GL_READ_WRITE_CHROMIUM",
     },
     {
         0x9138, "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG",
@@ -1165,9 +1162,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x8A44, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
     },
     {
-        0x6000, "GL_TEXTURE_POOL_CHROMIUM",
-    },
-    {
         0x0B74, "GL_DEPTH_FUNC",
     },
     {
@@ -1495,7 +1489,7 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x04, "GL_LINE_TO_CHROMIUM",
     },
     {
-        0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
+        0x8905, "GL_MAX_PROGRAM_TEXEL_OFFSET",
     },
     {
         0x00080000, "GL_STENCIL_BUFFER_BIT3_QCOM",
@@ -1906,6 +1900,9 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x8CD9, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
     },
     {
+        24, "GL_SYNC_TOKEN_SIZE_CHROMIUM",
+    },
+    {
         0x84CC, "GL_TEXTURE12",
     },
     {
@@ -1915,7 +1912,7 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x84CA, "GL_TEXTURE10",
     },
     {
-        0x78F1, "GL_MAP_CHROMIUM",
+        0x0BA7, "GL_PATH_PROJECTION_MATRIX_CHROMIUM",
     },
     {
         0x84CF, "GL_TEXTURE15",
@@ -2269,9 +2266,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x84DC, "GL_TEXTURE28",
     },
     {
-        0x6002, "GL_TEXTURE_POOL_UNMANAGED_CHROMIUM",
-    },
-    {
         0x84DA, "GL_TEXTURE26",
     },
     {
@@ -2845,7 +2839,7 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x78EE, "GL_PIXEL_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
-        0x6001, "GL_TEXTURE_POOL_MANAGED_CHROMIUM",
+        0x78EF, "GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM",
     },
     {
         0x0B45, "GL_CULL_FACE_MODE",
@@ -2857,9 +2851,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x00100000, "GL_STENCIL_BUFFER_BIT4_QCOM",
     },
     {
-        24, "GL_SYNC_TOKEN_SIZE_CHROMIUM",
-    },
-    {
         0x8E4E, "GL_LAST_VERTEX_CONVENTION_EXT",
     },
     {
@@ -3001,9 +2992,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x0A, "GL_QUADRATIC_CURVE_TO_CHROMIUM",
     },
     {
-        0x8905, "GL_MAX_PROGRAM_TEXEL_OFFSET",
-    },
-    {
         0x8508, "GL_DECR_WRAP",
     },
     {
diff --git a/ui/gl/gl_surface_ozone.cc b/ui/gl/gl_surface_ozone.cc
index ad264cc..377597d 100644
--- a/ui/gl/gl_surface_ozone.cc
+++ b/ui/gl/gl_surface_ozone.cc
@@ -565,7 +565,7 @@ bool GLSurfaceOzoneSurfacelessSurfaceImpl::CreatePixmaps() {
             ->GetSurfaceFactoryOzone()
             ->CreateNativePixmap(widget_, GetSize(),
                                  gfx::BufferFormat::BGRA_8888,
-                                 gfx::BufferUsage::SCANOUT);
+                                 gfx::BufferUsage::GPU_READ_WRITE);
     if (!pixmap)
       return false;
     scoped_refptr<GLImageOzoneNativePixmap> image =
diff --git a/ui/ozone/demo/surfaceless_gl_renderer.cc b/ui/ozone/demo/surfaceless_gl_renderer.cc
index 60575d6..4b3d555 100644
--- a/ui/ozone/demo/surfaceless_gl_renderer.cc
+++ b/ui/ozone/demo/surfaceless_gl_renderer.cc
@@ -40,7 +40,7 @@ bool SurfacelessGlRenderer::BufferWrapper::Initialize(
       OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateNativePixmap(widget, size, gfx::BufferFormat::BGRX_8888,
-                               gfx::BufferUsage::SCANOUT);
+                               gfx::BufferUsage::GPU_READ_WRITE);
   scoped_refptr<gfx::GLImageOzoneNativePixmap> image(
       new gfx::GLImageOzoneNativePixmap(size, GL_RGB));
   if (!image->Initialize(pixmap.get(), gfx::BufferFormat::BGRX_8888)) {
diff --git a/ui/ozone/platform/drm/client_native_pixmap_factory_gbm.cc b/ui/ozone/platform/drm/client_native_pixmap_factory_gbm.cc
index ec832cb..d8c701c 100644
--- a/ui/ozone/platform/drm/client_native_pixmap_factory_gbm.cc
+++ b/ui/ozone/platform/drm/client_native_pixmap_factory_gbm.cc
@@ -47,12 +47,13 @@ class ClientNativePixmapFactoryGbm : public ClientNativePixmapFactory {
   bool IsConfigurationSupported(gfx::BufferFormat format,
                                 gfx::BufferUsage usage) const override {
     switch (usage) {
-      case gfx::BufferUsage::SCANOUT:
+      case gfx::BufferUsage::GPU_READ:
+      case gfx::BufferUsage::GPU_READ_WRITE:
         return format == gfx::BufferFormat::RGBA_8888 ||
                format == gfx::BufferFormat::BGRA_8888 ||
                format == gfx::BufferFormat::BGRX_8888;
-      case gfx::BufferUsage::MAP:
-      case gfx::BufferUsage::PERSISTENT_MAP: {
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT: {
 #if defined(USE_VGEM_MAP)
         return vgem_fd_.is_valid() && format == gfx::BufferFormat::BGRA_8888;
 #else
@@ -70,8 +71,8 @@ class ClientNativePixmapFactoryGbm : public ClientNativePixmapFactory {
     base::ScopedFD scoped_fd(handle.fd.fd);
 
     switch (usage) {
-      case gfx::BufferUsage::MAP:
-      case gfx::BufferUsage::PERSISTENT_MAP:
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+      case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
 #if defined(USE_VGEM_MAP)
         // A valid |vgem_fd_| is required to acquire a VGEM bo. |vgem_fd_| is
         // set before a widget is created.
@@ -81,7 +82,8 @@ class ClientNativePixmapFactoryGbm : public ClientNativePixmapFactory {
 #endif
         NOTREACHED();
         return nullptr;
-      case gfx::BufferUsage::SCANOUT:
+      case gfx::BufferUsage::GPU_READ:
+      case gfx::BufferUsage::GPU_READ_WRITE:
         return make_scoped_ptr<ClientNativePixmapGbm>(
             new ClientNativePixmapGbm);
     }
diff --git a/ui/ozone/platform/drm/gpu/drm_thread.cc b/ui/ozone/platform/drm/gpu/drm_thread.cc
index 901dedb..19ecdfb 100644
--- a/ui/ozone/platform/drm/gpu/drm_thread.cc
+++ b/ui/ozone/platform/drm/gpu/drm_thread.cc
@@ -34,7 +34,7 @@ class GbmBufferGenerator : public ScanoutBufferGenerator {
                                       const gfx::Size& size) override {
     scoped_refptr<GbmDevice> gbm(static_cast<GbmDevice*>(drm.get()));
     return GbmBuffer::CreateBuffer(gbm, format, size,
-                                   gfx::BufferUsage::SCANOUT);
+                                   gfx::BufferUsage::GPU_READ_WRITE);
   }
 
  protected:
diff --git a/ui/ozone/platform/drm/gpu/gbm_buffer.cc b/ui/ozone/platform/drm/gpu/gbm_buffer.cc
index 8c3c396..b94164d 100644
--- a/ui/ozone/platform/drm/gpu/gbm_buffer.cc
+++ b/ui/ozone/platform/drm/gpu/gbm_buffer.cc
@@ -25,7 +25,10 @@ namespace ui {
 GbmBuffer::GbmBuffer(const scoped_refptr<GbmDevice>& gbm,
                      gbm_bo* bo,
                      gfx::BufferUsage usage)
-    : GbmBufferBase(gbm, bo, usage == gfx::BufferUsage::SCANOUT),
+    : GbmBufferBase(gbm,
+                    bo,
+                    usage == gfx::BufferUsage::GPU_READ ||
+                        usage == gfx::BufferUsage::GPU_READ_WRITE),
       usage_(usage) {}
 
 GbmBuffer::~GbmBuffer() {
@@ -41,10 +44,12 @@ scoped_refptr<GbmBuffer> GbmBuffer::CreateBuffer(
     gfx::BufferUsage usage) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBuffer", "device",
                gbm->device_path().value(), "size", size.ToString());
-  bool use_scanout = (usage == gfx::BufferUsage::SCANOUT);
+  bool with_cpu_access =
+      usage == gfx::BufferUsage::GPU_READ_CPU_READ_WRITE ||
+      usage == gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT;
   unsigned flags = 0;
   // GBM_BO_USE_SCANOUT is the hint of x-tiling.
-  if (use_scanout)
+  if (!with_cpu_access)
     flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
   gbm_bo* bo = gbm_bo_create(gbm->device(), size.width(), size.height(),
                              GetFourCCFormatFromBufferFormat(format), flags);
@@ -52,7 +57,7 @@ scoped_refptr<GbmBuffer> GbmBuffer::CreateBuffer(
     return nullptr;
 
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(gbm, bo, usage));
-  if (use_scanout && !buffer->GetFramebufferId())
+  if (!with_cpu_access && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
@@ -140,7 +145,8 @@ bool GbmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
     return false;
   }
 
-  DCHECK(buffer_->GetUsage() == gfx::BufferUsage::SCANOUT);
+  DCHECK(buffer_->GetUsage() == gfx::BufferUsage::GPU_READ ||
+         buffer_->GetUsage() == gfx::BufferUsage::GPU_READ_WRITE);
   surface_manager_->GetSurface(widget)->QueueOverlayPlane(OverlayPlane(
       buffer_, plane_z_order, plane_transform, display_bounds, crop_rect));
   return true;
diff --git a/ui/ozone/platform/drm/gpu/gbm_surface_factory.cc b/ui/ozone/platform/drm/gpu/gbm_surface_factory.cc
index 42be306..f140f82 100644
--- a/ui/ozone/platform/drm/gpu/gbm_surface_factory.cc
+++ b/ui/ozone/platform/drm/gpu/gbm_surface_factory.cc
@@ -110,7 +110,8 @@ scoped_refptr<ui::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
 #if !defined(OS_CHROMEOS)
   // Support for memory mapping accelerated buffers requires some
   // CrOS-specific patches (using vgem).
-  DCHECK(gfx::BufferUsage::SCANOUT == usage);
+  DCHECK(gfx::BufferUsage::GPU_READ == usage ||
+         gfx::BufferUsage::GPU_READ_WRITE == usage);
 #endif
 
   scoped_refptr<GbmBuffer> buffer =