gpu: Compositor management of GpuMemoryBuffer instances.

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
@@ skipping 253 matching lines @@
                         OnSetSurfaceVisible)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
                         OnRetireSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncPoint,
                         OnSignalSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
                         OnSignalQuery)
     IPC_MESSAGE_HANDLER(
         GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback,
         OnSetClientHasMemoryAllocationChangedCallback)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterGpuMemoryBuffer,
-                        OnRegisterGpuMemoryBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_UnregisterGpuMemoryBuffer,
-                        OnUnregisterGpuMemoryBuffer);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   if (have_context) {
     // Ensure that any delayed work that was created will be handled.
     ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
@@ skipping 648 matching lines @@
   if (has_callback) {
     if (!memory_manager_client_state_) {
       memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
           this, surface_id_ != 0, true));
     }
   } else {
     memory_manager_client_state_.reset();
   }
 }
 
-void GpuCommandBufferStub::OnRegisterGpuMemoryBuffer(
-    int32 id,
-    gfx::GpuMemoryBufferHandle handle,
-    uint32 width,
-    uint32 height,
-    uint32 internalformat) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnRegisterGpuMemoryBuffer");
+void GpuCommandBufferStub::OnCreateImage(int32 id,
+                                         gfx::GpuMemoryBufferHandle handle,
+                                         gfx::Size size,
+                                         gfx::GpuMemoryBuffer::Format format,
+                                         uint32 internalformat) {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
 #if defined(OS_ANDROID)
   // Verify that renderer is not trying to use a surface texture it doesn't own.
   if (handle.type == gfx::SURFACE_TEXTURE_BUFFER &&
       handle.surface_texture_id.secondary_id != channel()->client_id()) {
     LOG(ERROR) << "Illegal surface texture ID for renderer.";
     return;
   }
 #endif
 
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image already exists with same ID.";
     return;
   }
 
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   scoped_refptr<gfx::GLImage> image =
       manager->gpu_memory_buffer_factory()->CreateImageForGpuMemoryBuffer(
-          handle,
-          gfx::Size(width, height),
-          internalformat,
-          channel()->client_id());
+          handle, size, format, internalformat, channel()->client_id());
   if (!image.get())
     return;
 
   image_manager->AddImage(image.get(), id);
 }
 
-void GpuCommandBufferStub::OnUnregisterGpuMemoryBuffer(int32 id) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnUnregisterGpuMemoryBuffer");
+void GpuCommandBufferStub::OnDestroyImage(int32 id) {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyImage");
 
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
@@ skipping 98 matching lines @@
 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
   return GetMemoryManager()->GetClientMemoryUsage(this);
 }
 
 void GpuCommandBufferStub::SwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info));
 }
 
 }  // namespace content