gpu: Compositor management of GpuMemoryBuffer instances.

content/common/gpu/client/gpu_channel_host.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 "content/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 17 matching lines @@
 
 GpuListenerInfo::GpuListenerInfo() {}
 
 GpuListenerInfo::~GpuListenerInfo() {}
 
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
-    base::WaitableEvent* shutdown_event) {
+    base::WaitableEvent* shutdown_event,
+    cc::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
   DCHECK(factory->IsMainThread());
-  scoped_refptr<GpuChannelHost> host = new GpuChannelHost(factory, gpu_info);
+  scoped_refptr<GpuChannelHost> host =
+      new GpuChannelHost(factory, gpu_info, gpu_memory_buffer_manager);
   host->Connect(channel_handle, shutdown_event);
   return host;
 }
 
-// static
-bool GpuChannelHost::IsValidGpuMemoryBuffer(
-    gfx::GpuMemoryBufferHandle handle) {
-  switch (handle.type) {
-    case gfx::SHARED_MEMORY_BUFFER:
-#if defined(OS_MACOSX)
-    case gfx::IO_SURFACE_BUFFER:
-#endif
-#if defined(OS_ANDROID)
-    case gfx::SURFACE_TEXTURE_BUFFER:
-#endif
-#if defined(USE_X11)
-    case gfx::X11_PIXMAP_BUFFER:
-#endif
-      return true;
-    default:
-      return false;
-  }
-}
-
-GpuChannelHost::GpuChannelHost(GpuChannelHostFactory* factory,
-                               const gpu::GPUInfo& gpu_info)
+GpuChannelHost::GpuChannelHost(
+    GpuChannelHostFactory* factory,
+    const gpu::GPUInfo& gpu_info,
+    cc::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : factory_(factory),
-      gpu_info_(gpu_info) {
+      gpu_info_(gpu_info),
+      gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
   next_transfer_buffer_id_.GetNext();
-  next_gpu_memory_buffer_id_.GetNext();
+  next_image_id_.GetNext();
   next_route_id_.GetNext();
 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
                              base::WaitableEvent* shutdown_event) {
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   channel_ = IPC::SyncChannel::Create(channel_handle,
                                       IPC::Channel::MODE_CLIENT,
@@ skipping 238 matching lines @@
 #if defined(USE_X11)
     case gfx::X11_PIXMAP_BUFFER:
       return source_handle;
 #endif
     default:
       NOTREACHED();
       return gfx::GpuMemoryBufferHandle();
   }
 }
 
-int32 GpuChannelHost::ReserveGpuMemoryBufferId() {
-  return next_gpu_memory_buffer_id_.GetNext();
+int32 GpuChannelHost::ReserveImageId() {
+  return next_image_id_.GetNext();
 }
 
 int32 GpuChannelHost::GenerateRouteID() {
   return next_route_id_.GetNext();
 }
 
 GpuChannelHost::~GpuChannelHost() {
   // channel_ must be destroyed on the main thread.
   if (!factory_->IsMainThread())
     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
@@ skipping 65 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content