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

content/common/gpu/gpu_channel_manager.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "content/common/gpu/devtools_gpu_instrumentation.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_surface.h"
 
+#if defined(USE_X11)
+#include "ui/gl/x11_pixmap_tracker.h"
+#endif
+
 namespace base {
 class WaitableEvent;
 }
 
 namespace gfx {
 class GLShareGroup;
 struct GpuMemoryBufferHandle;
 }
 
 namespace gpu {
@@ skipping 13 matching lines @@
 namespace content {
 class GpuChannel;
 class GpuWatchdog;
 class MessageRouter;
 class SyncPointManager;
 
 // A GpuChannelManager is a thread responsible for issuing rendering commands
 // managing the lifetimes of GPU channels and forwarding IPC requests from the
 // browser process to them based on the corresponding renderer ID.
 class GpuChannelManager : public IPC::Listener,
-                          public IPC::Sender {
+                          public IPC::Sender
+#if defined(USE_X11)
+                          ,
+                          public gfx::X11PixmapTracker

[alexst (slow to review), 2014/06/13 19:15:57]

I like this general style, but as you mentioned there will be a number of these
to implement, and I'm not sure crowding them all into the ChannelManager class
is the best thing to do. 

I'm already adding SurfaceTextureTracker and EGLPixmapTracker, and before too
long, we will probably have a DMABufTracker, etc.

Maybe we have a separate class called something like
GpuMemoryBufferHandleTrackerImpl that would be a member here and would implement
all these interfaces.

I would even volunteer to add it as a followup if we think it's a good way to go
because I already have it for SurfaceTexture.

[reveman, 2014/06/13 19:27:56]

I agree. This was a bad idea.
I'd also like to avoid a lot of these ifdefs. A platform specific
GpuMemoryBufferFactory interface is really what we want here but I was hoping we
could save that to a follow up patch. Let me try to implement it as part of this
patch and then we can see if it's possible to split this up somehow.

[reveman, 2014/06/13 20:55:06]

Take a look at latest patch. It adds a GpuMemoryBufferFactory interface on the
GPU process side that can be used for all this platform/implementation specific
code. This makes it pretty clear how the GpuMemoryBufferFactoryHost code is
connected to the GPU process.

+#endif
+                          {
  public:
   GpuChannelManager(MessageRouter* router,
                     GpuWatchdog* watchdog,
                     base::MessageLoopProxy* io_message_loop,
                     base::WaitableEvent* shutdown_event);
   virtual ~GpuChannelManager();
 
   // Remove the channel for a particular renderer.
   void RemoveChannel(int client_id);
 
   // Listener overrides.
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // Sender overrides.
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
+#if defined(USE_X11)
+  // X11PixmapTracker overrides.
+  virtual XID AcquirePixmap(int primary_id, int secondary_id) OVERRIDE;
+#endif
+
   bool HandleMessagesScheduled();
   uint64 MessagesProcessed();
 
   void LoseAllContexts();
 
   base::WeakPtrFactory<GpuChannelManager> weak_factory_;
 
   int GenerateRouteID();
   void AddRoute(int32 routing_id, IPC::Listener* listener);
   void RemoveRoute(int32 routing_id);
@@ skipping 29 matching lines @@
   void OnCloseChannel(const IPC::ChannelHandle& channel_handle);
   void OnVisibilityChanged(
       int32 render_view_id, int32 client_id, bool visible);
   void OnCreateViewCommandBuffer(
       const gfx::GLSurfaceHandle& window,
       int32 render_view_id,
       int32 client_id,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id);
   void CreateImage(
-      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);
   void 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);
   void DeleteImage(int32 client_id, int32 image_id);
   void OnDeleteImage(int32 client_id, int32 image_id, int32 sync_point);
   void OnDeleteImageSyncPointRetired(ImageOperation*);
   void OnLoadedShader(std::string shader);
   void OnCreateGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
                                const gfx::Size& size,
                                unsigned internalformat,
                                unsigned usage);
   void OnDestroyGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
                                 int32 sync_point);
 
   void OnLoseAllContexts();
 
+#if defined(USE_X11)
+  void AddPixmap(XID pixmap, int pixmap_id, int client_id);
+  void RemoveAllPixmaps(int client_id);
+#endif
+
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   base::WaitableEvent* shutdown_event_;
 
   // Used to send and receive IPC messages from the browser process.
   MessageRouter* const router_;
 
   // These objects manage channels to individual renderer processes there is
   // one channel for each renderer process that has connected to this GPU
   // process.
   GpuChannelMap gpu_channels_;
   scoped_refptr<gfx::GLShareGroup> share_group_;
   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
   GpuMemoryManager gpu_memory_manager_;
   GpuEventsDispatcher gpu_devtools_events_dispatcher_;
   GpuWatchdog* watchdog_;
   scoped_refptr<SyncPointManager> sync_point_manager_;
   scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gfx::GLSurface> default_offscreen_surface_;
   ImageOperationQueue image_operations_;
 
+#if defined(USE_X11)
+  typedef std::pair<int, int> X11PixmapMapKey;
+  typedef base::hash_map<X11PixmapMapKey, XID> X11PixmapMap;
+  X11PixmapMap pixmaps_;
+  base::ThreadChecker thread_checker_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(GpuChannelManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_