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 "base/lazy_instance.h"
 #include "content/common/gpu/gpu_channel.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"
 #include "ui/gl/gl_share_group.h"
 
+#if defined(USE_X11)
+#include "ui/gl/x11_pixmap_tracker.h"
+#endif
+
 namespace content {
+namespace {
+
+#if defined(USE_X11)
+class X11PixmapTrackerImpl : public gfx::X11PixmapTracker {
+ public:
+  // Overridden from gfx::X11PixmapTracker:
+  virtual XID AcquirePixmap(int primary_id, int secondary_id) OVERRIDE {
+    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 AddPixmap(XID pixmap, int pixmap_id, int child_process_id) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    X11PixmapMapKey key(pixmap_id, child_process_id);
+    DCHECK(pixmaps_.find(key) == pixmaps_.end());
+    pixmaps_[key] = pixmap;
+  }
+
+  void RemoveAllPixmaps(int child_process_id) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    X11PixmapMap::iterator it = pixmaps_.begin();
+    while (it != pixmaps_.end()) {
+      if (it->first.second == child_process_id)
+        pixmaps_.erase(it++);
+      else
+        ++it;
+    }
+  }
+
+ private:
+  typedef std::pair<int, int> X11PixmapMapKey;
+  typedef base::hash_map<X11PixmapMapKey, XID> X11PixmapMap;
+  X11PixmapMap pixmaps_;
+  base::ThreadChecker thread_checker_;
+};
+base::LazyInstance<X11PixmapTrackerImpl> g_x11_pixmap_tracker =
+    LAZY_INSTANCE_INITIALIZER;

[piman, 2014/06/13 17:14:21]

Why not simply making it a member of GpuChannelManager?

[reveman, 2014/06/13 18:50:34]

No other reason than hiding as much as possible in the .cc file. I think the
implementation should move to a separate file if we make this a member. That's
fine with me though and maybe the best solution. Another alternative is to just
have the GpuChannelManager class implement this interface. Latest patch does
that. All these options are OK with me as long as we're consistent in how we
track other types of objects that can back gpu memory buffers. ie. surface
textures.

Let me know what you prefer.

+#endif
+
+}  // namespace
 
 GpuChannelManager::ImageOperation::ImageOperation(
     int32 sync_point, base::Closure callback)
     : sync_point(sync_point),
       callback(callback) {
 }
 
 GpuChannelManager::ImageOperation::~ImageOperation() {
 }
 
 GpuChannelManager::GpuChannelManager(MessageRouter* router,
                                      GpuWatchdog* watchdog,
                                      base::MessageLoopProxy* io_message_loop,
                                      base::WaitableEvent* shutdown_event)
     : weak_factory_(this),
       io_message_loop_(io_message_loop),
       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(g_x11_pixmap_tracker.Pointer());
+#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)
+      g_x11_pixmap_tracker.Pointer()->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:
+      g_x11_pixmap_tracker.Pointer()->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 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