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_manager.h"
@@ skipping 28 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);
+#if defined(USE_X11)
+  gfx::X11PixmapTracker::InitInstance(this);
+#endif
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
   DCHECK(image_operations_.empty());
 }
@@ skipping 92 matching lines @@
   gpu_channels_.set(client_id, channel.Pass());
 
   Send(new GpuHostMsg_ChannelEstablished(channel_handle));
 }
 
 void GpuChannelManager::OnCloseChannel(
     const IPC::ChannelHandle& channel_handle) {
   for (GpuChannelMap::iterator iter = gpu_channels_.begin();
        iter != gpu_channels_.end(); ++iter) {
     if (iter->second->GetChannelName() == channel_handle.name) {
+#if defined(USE_X11)
+      RemoveAllPixmaps(iter->first);
+#endif
       gpu_channels_.erase(iter);
       return;
     }
   }
 }
 
 void GpuChannelManager::OnCreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     int32 client_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32 route_id) {
   DCHECK(surface_id);
   bool succeeded = false;
 
   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) {
+  switch (handle.type) {
+#if defined(USE_X11)
+    case gfx::X11_PIXMAP_BUFFER:
+      AddPixmap(handle.pixmap,
+                handle.global_id.primary_id,
+                handle.global_id.secondary_id);
+      break;
+#endif
+    default:
+      NOTIMPLEMENTED();
+      break;
+  }
 
   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 82 matching lines @@
     iter->second->MarkAllContextsLost();
   }
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannelManager::OnLoseAllContexts,
                  weak_factory_.GetWeakPtr()));
 }
 
 void GpuChannelManager::OnLoseAllContexts() {
   gpu_channels_.clear();
+#if defined(USE_X11)
+  pixmaps_.clear();
+#endif
 }
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
+#if defined(USE_X11)
+XID GpuChannelManager::AcquirePixmap(int primary_id, int secondary_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  X11PixmapMapKey key(primary_id, secondary_id);
+  X11PixmapMap::iterator it = pixmaps_.find(key);
+  if (it == pixmaps_.end())
+    return 0;
+  XID pixmap = it->second;
+  pixmaps_.erase(it);
+  return pixmap;
+}
+
+void GpuChannelManager::AddPixmap(XID pixmap, int pixmap_id, int client_id) {
+  X11PixmapMapKey key(pixmap_id, client_id);
+  DCHECK(pixmaps_.find(key) == pixmaps_.end());
+  pixmaps_[key] = pixmap;
+}
+
+void GpuChannelManager::RemoveAllPixmaps(int client_id) {
+  X11PixmapMap::iterator it = pixmaps_.begin();
+  while (it != pixmaps_.end()) {
+    if (it->first.second == client_id)
+      pixmaps_.erase(it++);
+    else
+      ++it;
+  }
+}
+#endif
+
 }  // namespace content