gpu/command_buffer/tests/gl_manager.h

   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 GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
   6 #define GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
   7
   8 #include "base/containers/scoped_ptr_hash_map.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "gpu/command_buffer/client/gpu_control.h"
  12 #include "gpu/command_buffer/service/feature_info.h"
  13 #include "ui/gfx/size.h"
  14
  15 namespace gfx {
  16
  17 class GLContext;
  18 class GLShareGroup;
  19 class GLSurface;
  20
  21 }
  22
  23 namespace gpu {
  24
  25 class CommandBufferService;
  26 class GpuControlService;
  27 class GpuMemoryBufferFactory;
  28 class GpuScheduler;
  29 class TransferBuffer;
  30
  31 namespace gles2 {
  32
  33 class ContextGroup;
  34 class MailboxManager;
  35 class GLES2Decoder;
  36 class GLES2CmdHelper;
  37 class GLES2Implementation;
  38 class ImageFactory;
  39 class ImageManager;
  40 class ShareGroup;
  41
  42 };
  43
  44 class GLManager : private GpuControl {
  45  public:
  46   struct Options {
  47     Options();
  48     // The size of the backbuffer.
  49     gfx::Size size;
  50     // If not null will share resources with this context.
  51     GLManager* share_group_manager;
  52     // If not null will share a mailbox manager with this context.
  53     GLManager* share_mailbox_manager;
  54     // If not null will create a virtual manager based on this context.
  55     GLManager* virtual_manager;
  56     // Whether or not glBindXXX generates a resource.
  57     bool bind_generates_resource;
  58     // Whether or not the context is auto-lost when GL_OUT_OF_MEMORY occurs.
  59     bool lose_context_when_out_of_memory;
  60     // Whether or not it's ok to lose the context.
  61     bool context_lost_allowed;
  62     // Image manager to be used.
  63     gles2::ImageManager* image_manager;
  64     // GpuMemoryBuffer factory to be used.
  65     GpuMemoryBufferFactory* gpu_memory_buffer_factory;
  66   };
  67   GLManager();
  68   virtual ~GLManager();
  69
  70   void Initialize(const Options& options);
  71   void Destroy();
  72
  73   void MakeCurrent();
  74
  75   void SetSurface(gfx::GLSurface* surface);
  76
  77   gles2::GLES2Decoder* decoder() const {
  78     return decoder_.get();
  79   }
  80
  81   gles2::MailboxManager* mailbox_manager() const {
  82     return mailbox_manager_.get();
  83   }
  84
  85   gfx::GLShareGroup* share_group() const {
  86     return share_group_.get();
  87   }
  88
  89   gles2::GLES2Implementation* gles2_implementation() const {
  90     return gles2_implementation_.get();
  91   }
  92
  93   gfx::GLContext* context() {
  94     return context_.get();
  95   }
  96
  97   const gpu::gles2::FeatureInfo::Workarounds& workarounds() const;
  98
  99   // GpuControl implementation.
 100   virtual Capabilities GetCapabilities() OVERRIDE;
 101   virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(size_t width,
 102                                                       size_t height,
 103                                                       unsigned internalformat,
 104                                                       unsigned usage,
 105                                                       int32* id) OVERRIDE;
 106   virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE;
 107   virtual uint32 InsertSyncPoint() OVERRIDE;
 108   virtual void SignalSyncPoint(uint32 sync_point,
 109                                const base::Closure& callback) OVERRIDE;
 110   virtual void SignalQuery(uint32 query,
 111                            const base::Closure& callback) OVERRIDE;
 112   virtual void SetSurfaceVisible(bool visible) OVERRIDE;
 113   virtual void Echo(const base::Closure& callback) OVERRIDE;
 114   virtual uint32 CreateStreamTexture(uint32 texture_id) OVERRIDE;
 115
 116  private:
 117   void PumpCommands();
 118   bool GetBufferChanged(int32 transfer_buffer_id);
 119   void SetupBaseContext();
 120
 121   scoped_refptr<gles2::MailboxManager> mailbox_manager_;
 122   scoped_refptr<gfx::GLShareGroup> share_group_;
 123   scoped_ptr<CommandBufferService> command_buffer_;
 124   scoped_ptr<GpuControlService> gpu_control_service_;
 125   scoped_ptr<gles2::GLES2Decoder> decoder_;
 126   scoped_ptr<GpuScheduler> gpu_scheduler_;
 127   scoped_refptr<gfx::GLSurface> surface_;
 128   scoped_refptr<gfx::GLContext> context_;
 129   scoped_ptr<gles2::GLES2CmdHelper> gles2_helper_;
 130   scoped_ptr<TransferBuffer> transfer_buffer_;
 131   scoped_ptr<gles2::GLES2Implementation> gles2_implementation_;
 132   bool context_lost_allowed_;
 133
 134   // Client GpuControl implementation.
 135   GpuMemoryBufferFactory* gpu_memory_buffer_factory_;
 136   base::ScopedPtrHashMap<int32, gfx::GpuMemoryBuffer> memory_buffers_;
 137
 138   // Used on Android to virtualize GL for all contexts.
 139   static int use_count_;
 140   static scoped_refptr<gfx::GLShareGroup>* base_share_group_;
 141   static scoped_refptr<gfx::GLSurface>* base_surface_;
 142   static scoped_refptr<gfx::GLContext>* base_context_;
 143 };
 144
 145 }  // namespace gpu
 146
 147 #endif  // GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_