Expose GpuMemoryBufferId through glGetImageivCHROMIUM.

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/service/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 664 matching lines @@
       gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
   int32_t new_id = next_image_id_.GetNext();
 
   DCHECK(gpu::IsGpuMemoryBufferFormatSupported(gpu_memory_buffer->GetFormat(),
                                                capabilities_));
   DCHECK(gpu::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
 
+  DCHECK(image_gmb_ids_map_.find(new_id) == image_gmb_ids_map_.end());
+  image_gmb_ids_map_[new_id] = gpu_memory_buffer->GetId().id;
+
   // This handle is owned by the GPU thread and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // queuing of the CreateImage task below.
   bool requires_sync_point = false;
   gfx::GpuMemoryBufferHandle handle =
       ShareGpuMemoryBufferToGpuThread(gpu_memory_buffer->GetHandle(),
                                       &requires_sync_point);
 
   SyncPointManager* sync_manager = service_->sync_point_manager();
   const uint32_t order_num =
@@ skipping 84 matching lines @@
   }
 
   if (fence_sync) {
     sync_point_client_->ReleaseFenceSync(fence_sync);
   }
 }
 
 void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
+  auto it = image_gmb_ids_map_.find(id);
+  if (it != image_gmb_ids_map_.end())
+    image_gmb_ids_map_.erase(it);
+
   QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
                        base::Unretained(this),
                        id));
 }
 
 void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
@@ skipping 18 matching lines @@
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::DefaultBufferFormatForImageFormat(internalformat),
           gfx::BufferUsage::SCANOUT, gpu::kNullSurfaceHandle));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
+int32_t InProcessCommandBuffer::GetImageGpuMemoryBufferId(unsigned image_id) {
+  CheckSequencedThread();
+  auto it = image_gmb_ids_map_.find(image_id);
+  if (it != image_gmb_ids_map_.end())
+    return it->second;
+  return -1;
+}
+
 void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
     SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
                          GetCommandBufferID(), release);
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
@@ skipping 207 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu