Home | History | Annotate | Download | only in gpu 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
      6 #define CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
      7 
      8 #include <deque>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/containers/hash_tables.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/memory/weak_ptr.h"
     16 #include "base/message_loop/message_loop_proxy.h"
     17 #include "build/build_config.h"
     18 #include "content/common/gpu/gpu_memory_manager.h"
     19 #include "ipc/ipc_listener.h"
     20 #include "ipc/ipc_sender.h"
     21 #include "ui/gfx/native_widget_types.h"
     22 #include "ui/gl/gl_surface.h"
     23 
     24 namespace base {
     25 class WaitableEvent;
     26 }
     27 
     28 namespace gfx {
     29 class GLShareGroup;
     30 }
     31 
     32 namespace gpu {
     33 namespace gles2 {
     34 class MailboxManager;
     35 class ProgramCache;
     36 }
     37 }
     38 
     39 namespace IPC {
     40 struct ChannelHandle;
     41 }
     42 
     43 struct GPUCreateCommandBufferConfig;
     44 
     45 namespace content {
     46 class ChildThread;
     47 class GpuChannel;
     48 class GpuWatchdog;
     49 class SyncPointManager;
     50 
     51 // A GpuChannelManager is a thread responsible for issuing rendering commands
     52 // managing the lifetimes of GPU channels and forwarding IPC requests from the
     53 // browser process to them based on the corresponding renderer ID.
     54 //
     55 // A GpuChannelManager can also be hosted in the browser process in single
     56 // process or in-process GPU modes. In this case there is no corresponding
     57 // GpuChildThread and this is the reason the GpuChildThread is referenced via
     58 // a pointer to IPC::Sender, which can be implemented by other hosts to send
     59 // IPC messages to the browser process IO thread on the GpuChannelManager's
     60 // behalf.
     61 class GpuChannelManager : public IPC::Listener,
     62                           public IPC::Sender {
     63  public:
     64   GpuChannelManager(ChildThread* gpu_child_thread,
     65                     GpuWatchdog* watchdog,
     66                     base::MessageLoopProxy* io_message_loop,
     67                     base::WaitableEvent* shutdown_event);
     68   virtual ~GpuChannelManager();
     69 
     70   // Remove the channel for a particular renderer.
     71   void RemoveChannel(int client_id);
     72 
     73   // Listener overrides.
     74   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
     75 
     76   // Sender overrides.
     77   virtual bool Send(IPC::Message* msg) OVERRIDE;
     78 
     79   bool HandleMessagesScheduled();
     80   uint64 MessagesProcessed();
     81 
     82   void LoseAllContexts();
     83 
     84   base::WeakPtrFactory<GpuChannelManager> weak_factory_;
     85 
     86   int GenerateRouteID();
     87   void AddRoute(int32 routing_id, IPC::Listener* listener);
     88   void RemoveRoute(int32 routing_id);
     89 
     90   gpu::gles2::ProgramCache* program_cache();
     91 
     92   GpuMemoryManager* gpu_memory_manager() { return &gpu_memory_manager_; }
     93 
     94   GpuChannel* LookupChannel(int32 client_id);
     95 
     96   SyncPointManager* sync_point_manager() { return sync_point_manager_.get(); }
     97 
     98   gfx::GLSurface* GetDefaultOffscreenSurface();
     99 
    100  private:
    101   struct ImageOperation {
    102     ImageOperation(int32 sync_point, base::Closure callback);
    103     ~ImageOperation();
    104 
    105     int32 sync_point;
    106     base::Closure callback;
    107   };
    108   typedef base::hash_map<int, scoped_refptr<GpuChannel> > GpuChannelMap;
    109   typedef std::deque<ImageOperation*> ImageOperationQueue;
    110 
    111   // Message handlers.
    112   void OnEstablishChannel(int client_id, bool share_context);
    113   void OnCloseChannel(const IPC::ChannelHandle& channel_handle);
    114   void OnVisibilityChanged(
    115       int32 render_view_id, int32 client_id, bool visible);
    116   void OnCreateViewCommandBuffer(
    117       const gfx::GLSurfaceHandle& window,
    118       int32 render_view_id,
    119       int32 client_id,
    120       const GPUCreateCommandBufferConfig& init_params);
    121   void CreateImage(
    122       gfx::PluginWindowHandle window, int32 client_id, int32 image_id);
    123   void OnCreateImage(
    124       gfx::PluginWindowHandle window, int32 client_id, int32 image_id);
    125   void DeleteImage(int32 client_id, int32 image_id);
    126   void OnDeleteImage(int32 client_id, int32 image_id, int32 sync_point);
    127   void OnDeleteImageSyncPointRetired(ImageOperation*);
    128   void OnLoadedShader(std::string shader);
    129 
    130   void OnLoseAllContexts();
    131 
    132   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
    133   base::WaitableEvent* shutdown_event_;
    134 
    135   // Used to send and receive IPC messages from the browser process.
    136   ChildThread* gpu_child_thread_;
    137 
    138   // These objects manage channels to individual renderer processes there is
    139   // one channel for each renderer process that has connected to this GPU
    140   // process.
    141   GpuChannelMap gpu_channels_;
    142   scoped_refptr<gfx::GLShareGroup> share_group_;
    143   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
    144   GpuMemoryManager gpu_memory_manager_;
    145   GpuWatchdog* watchdog_;
    146   scoped_refptr<SyncPointManager> sync_point_manager_;
    147   scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
    148   scoped_refptr<gfx::GLSurface> default_offscreen_surface_;
    149   ImageOperationQueue image_operations_;
    150 
    151   DISALLOW_COPY_AND_ASSIGN(GpuChannelManager);
    152 };
    153 
    154 }  // namespace content
    155 
    156 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
    157