Expose GpuMemoryBufferId through glGetImageivCHROMIUM.

gpu/command_buffer/tests/gl_manager.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
@@ skipping 129 matching lines @@
     DCHECK(mapped_);
     mapped_ = false;
   }
   gfx::Size GetSize() const override { return size_; }
   gfx::BufferFormat GetFormat() const override { return format_; }
   int stride(size_t plane) const override {
     DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
     return IOSurfaceGetWidthOfPlane(iosurface_, plane);
   }
   gfx::GpuMemoryBufferId GetId() const override {
-    NOTREACHED();
     return gfx::GpuMemoryBufferId(0);
   }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     NOTREACHED();
     return gfx::GpuMemoryBufferHandle();
   }
   ClientBuffer AsClientBuffer() override {
     return reinterpret_cast<ClientBuffer>(this);
   }
 
@@ skipping 348 matching lines @@
   return decoder_->GetCapabilities();
 }
 
 int32_t GLManager::CreateImage(ClientBuffer buffer,
                                size_t width,
                                size_t height,
                                unsigned internalformat) {
   gfx::Size size(width, height);
   scoped_refptr<gl::GLImage> gl_image;
 
+  int gmb_id = -1;
 #if defined(OS_MACOSX)
   if (use_iosurface_memory_buffers_) {
     IOSurfaceGpuMemoryBuffer* gpu_memory_buffer =
         IOSurfaceGpuMemoryBuffer::FromClientBuffer(buffer);
     scoped_refptr<gl::GLImageIOSurface> image(
         new gl::GLImageIOSurface(size, internalformat));
     if (!image->Initialize(gpu_memory_buffer->iosurface(),
                            gfx::GenericSharedMemoryId(1),
                            gfx::BufferFormat::BGRA_8888)) {
       return -1;
     }
     gl_image = image;
+    gmb_id = gpu_memory_buffer->GetId().id;
   }
 #endif  // defined(OS_MACOSX)
   if (!gl_image) {
     GpuMemoryBufferImpl* gpu_memory_buffer =
         GpuMemoryBufferImpl::FromClientBuffer(buffer);
 
     scoped_refptr<gl::GLImageRefCountedMemory> image(
         new gl::GLImageRefCountedMemory(size, internalformat));
     if (!image->Initialize(gpu_memory_buffer->bytes(),
                            gpu_memory_buffer->GetFormat())) {
       return -1;
     }
     gl_image = image;
   }
 
   static int32_t next_id = 1;
   int32_t new_id = next_id++;
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   image_manager->AddImage(gl_image.get(), new_id);
+
+  if (gmb_id != -1) {
+    DCHECK(image_gmb_ids_map_.find(new_id) == image_gmb_ids_map_.end());
+    image_gmb_ids_map_[new_id] = gmb_id;
+  }
+
   return new_id;
 }
 
 int32_t GLManager::CreateGpuMemoryBufferImage(size_t width,
                                               size_t height,
                                               unsigned internalformat,
                                               unsigned usage) {
   DCHECK_EQ(usage, static_cast<unsigned>(GL_READ_WRITE_CHROMIUM));
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer = CreateGpuMemoryBuffer(
       gfx::Size(width, height), gfx::BufferFormat::RGBA_8888);
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
+int32_t GLManager::GetImageGpuMemoryBufferId(unsigned image_id) {
+  auto it = image_gmb_ids_map_.find(image_id);
+  if (it != image_gmb_ids_map_.end())
+    return it->second;
+  return -1;
+}
+
 void GLManager::DestroyImage(int32_t id) {
+  auto it = image_gmb_ids_map_.find(id);
+  if (it != image_gmb_ids_map_.end())
+    image_gmb_ids_map_.erase(it);
+
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   image_manager->RemoveImage(id);
 }
 
 void GLManager::SignalQuery(uint32_t query, const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 void GLManager::SetLock(base::Lock*) {
@@ skipping 48 matching lines @@
 
   // Something went wrong, just run the callback now.
   callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace gpu