gpu: Remove Create/DeleteImage IPC by adding an X11_PIXMAP_BUFFER GpuMemoryBuffer type.

content/common/gpu/gpu_channel_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 "content/common/gpu/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/common/message_router.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 19 matching lines @@
       shutdown_event_(shutdown_event),
       router_(router),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(new SyncPointManager) {
   DCHECK(router_);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
+  GpuMemoryBufferFactory::Initialize();
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
   DCHECK(image_operations_.empty());
 }
@@ skipping 117 matching lines @@
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
   if (iter != gpu_channels_.end()) {
     succeeded = iter->second->CreateViewCommandBuffer(
         window, surface_id, init_params, route_id);
   }
 
   Send(new GpuHostMsg_CommandBufferCreated(succeeded));
 }
 
 void GpuChannelManager::CreateImage(
-    gfx::PluginWindowHandle window, int32 client_id, int32 image_id) {
-  gfx::Size size;
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    unsigned internalformat,
+    int32 client_id,
+    int32 image_id) {
+  if (!GpuMemoryBufferFactory::CreateGpuMemoryBuffer(handle,
+                                                     size,
+                                                     internalformat,
+                                                     0)) {
+    Send(new GpuHostMsg_ImageCreated(false));
+    return;
+  }
 
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
-  if (iter != gpu_channels_.end()) {
-    iter->second->CreateImage(window, image_id, &size);
-  }
-
-  Send(new GpuHostMsg_ImageCreated(size));
+  Send(new GpuHostMsg_ImageCreated(
+      iter != gpu_channels_.end()
+          ? iter->second->CreateImage(handle, size, internalformat, image_id)
+          : false));
 }
 
 void GpuChannelManager::OnCreateImage(
-    gfx::PluginWindowHandle window, int32 client_id, int32 image_id) {
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    unsigned internalformat,
+    int32 client_id,
+    int32 image_id) {
   DCHECK(image_id);
 
   if (image_operations_.empty()) {
-    CreateImage(window, client_id, image_id);
+    CreateImage(handle, size, internalformat, client_id, image_id);
   } else {
     image_operations_.push_back(
         new ImageOperation(0, base::Bind(&GpuChannelManager::CreateImage,
                                          base::Unretained(this),
-                                         window,
+                                         handle,
+                                         size,
+                                         internalformat,
                                          client_id,
                                          image_id)));
   }
 }
 
 void GpuChannelManager::DeleteImage(int32 client_id, int32 image_id) {
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
   if (iter != gpu_channels_.end()) {
     iter->second->DeleteImage(image_id);
   }
@@ skipping 93 matching lines @@
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content