Home | History | Annotate | Download | only in service 
      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 // This file contains the GLES2Decoder class.
      6 
      7 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_H_
      8 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_H_
      9 
     10 #include <vector>
     11 
     12 #include "base/callback.h"
     13 #include "base/memory/weak_ptr.h"
     14 #include "base/time/time.h"
     15 #include "build/build_config.h"
     16 #include "gpu/command_buffer/common/capabilities.h"
     17 #include "gpu/command_buffer/service/common_decoder.h"
     18 #include "gpu/command_buffer/service/logger.h"
     19 #include "ui/gfx/size.h"
     20 #include "ui/gl/gl_context.h"
     21 
     22 namespace gfx {
     23 class GLContext;
     24 class GLSurface;
     25 }
     26 
     27 namespace gpu {
     28 
     29 class AsyncPixelTransferDelegate;
     30 class AsyncPixelTransferManager;
     31 struct Mailbox;
     32 
     33 namespace gles2 {
     34 
     35 class ContextGroup;
     36 class ErrorState;
     37 class GLES2Util;
     38 class Logger;
     39 class QueryManager;
     40 class VertexArrayManager;
     41 struct ContextState;
     42 
     43 struct DisallowedFeatures {
     44   DisallowedFeatures()
     45       : gpu_memory_manager(false) {
     46   }
     47 
     48   bool gpu_memory_manager;
     49 };
     50 
     51 typedef base::Callback<void(const std::string& key,
     52                             const std::string& shader)> ShaderCacheCallback;
     53 
     54 // This class implements the AsyncAPIInterface interface, decoding GLES2
     55 // commands and calling GL.
     56 class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
     57                                 public CommonDecoder {
     58  public:
     59   typedef error::Error Error;
     60   typedef base::Callback<bool(uint32 id)> WaitSyncPointCallback;
     61 
     62   // Creates a decoder.
     63   static GLES2Decoder* Create(ContextGroup* group);
     64 
     65   virtual ~GLES2Decoder();
     66 
     67   bool initialized() const {
     68     return initialized_;
     69   }
     70 
     71   void set_initialized() {
     72     initialized_ = true;
     73   }
     74 
     75   bool debug() const {
     76     return debug_;
     77   }
     78 
     79   // Set to true to call glGetError after every command.
     80   void set_debug(bool debug) {
     81     debug_ = debug;
     82   }
     83 
     84   bool log_commands() const {
     85     return log_commands_;
     86   }
     87 
     88   // Set to true to LOG every command.
     89   void set_log_commands(bool log_commands) {
     90     log_commands_ = log_commands;
     91   }
     92 
     93   // Initializes the graphics context. Can create an offscreen
     94   // decoder with a frame buffer that can be referenced from the parent.
     95   // Takes ownership of GLContext.
     96   // Parameters:
     97   //  surface: the GL surface to render to.
     98   //  context: the GL context to render to.
     99   //  offscreen: whether to make the context offscreen or not. When FBO 0 is
    100   //      bound, offscreen contexts render to an internal buffer, onscreen ones
    101   //      to the surface.
    102   //  size: the size if the GL context is offscreen.
    103   // Returns:
    104   //   true if successful.
    105   virtual bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
    106                           const scoped_refptr<gfx::GLContext>& context,
    107                           bool offscreen,
    108                           const gfx::Size& size,
    109                           const DisallowedFeatures& disallowed_features,
    110                           const std::vector<int32>& attribs) = 0;
    111 
    112   // Destroys the graphics context.
    113   virtual void Destroy(bool have_context) = 0;
    114 
    115   // Set the surface associated with the default FBO.
    116   virtual void SetSurface(const scoped_refptr<gfx::GLSurface>& surface) = 0;
    117 
    118   virtual void ProduceFrontBuffer(const Mailbox& mailbox) = 0;
    119 
    120   // Resize an offscreen frame buffer.
    121   virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size) = 0;
    122 
    123   // Make this decoder's GL context current.
    124   virtual bool MakeCurrent() = 0;
    125 
    126   // Gets the GLES2 Util which holds info.
    127   virtual GLES2Util* GetGLES2Util() = 0;
    128 
    129   // Gets the associated GLContext.
    130   virtual gfx::GLContext* GetGLContext() = 0;
    131 
    132   // Gets the associated ContextGroup
    133   virtual ContextGroup* GetContextGroup() = 0;
    134 
    135   virtual Capabilities GetCapabilities() = 0;
    136 
    137   // Restores all of the decoder GL state.
    138   virtual void RestoreState(const ContextState* prev_state) const = 0;
    139 
    140   // Restore States.
    141   virtual void RestoreActiveTexture() const = 0;
    142   virtual void RestoreAllTextureUnitBindings(
    143       const ContextState* prev_state) const = 0;
    144   virtual void RestoreActiveTextureUnitBinding(unsigned int target) const = 0;
    145   virtual void RestoreBufferBindings() const = 0;
    146   virtual void RestoreFramebufferBindings() const = 0;
    147   virtual void RestoreGlobalState() const = 0;
    148   virtual void RestoreProgramBindings() const = 0;
    149   virtual void RestoreTextureState(unsigned service_id) const = 0;
    150   virtual void RestoreTextureUnitBindings(unsigned unit) const = 0;
    151 
    152   virtual void ClearAllAttributes() const = 0;
    153   virtual void RestoreAllAttributes() const = 0;
    154 
    155   virtual void SetIgnoreCachedStateForTest(bool ignore) = 0;
    156 
    157   // Gets the QueryManager for this context.
    158   virtual QueryManager* GetQueryManager() = 0;
    159 
    160   // Gets the VertexArrayManager for this context.
    161   virtual VertexArrayManager* GetVertexArrayManager() = 0;
    162 
    163   // Process any pending queries. Returns false if there are no pending queries.
    164   virtual bool ProcessPendingQueries() = 0;
    165 
    166   // Returns false if there are no idle work to be made.
    167   virtual bool HasMoreIdleWork() = 0;
    168 
    169   virtual void PerformIdleWork() = 0;
    170 
    171   // Sets a callback which is called when a glResizeCHROMIUM command
    172   // is processed.
    173   virtual void SetResizeCallback(
    174       const base::Callback<void(gfx::Size, float)>& callback) = 0;
    175 
    176   // Interface to performing async pixel transfers.
    177   virtual AsyncPixelTransferManager* GetAsyncPixelTransferManager() = 0;
    178   virtual void ResetAsyncPixelTransferManagerForTest() = 0;
    179   virtual void SetAsyncPixelTransferManagerForTest(
    180       AsyncPixelTransferManager* manager) = 0;
    181 
    182   // Get the service texture ID corresponding to a client texture ID.
    183   // If no such record is found then return false.
    184   virtual bool GetServiceTextureId(uint32 client_texture_id,
    185                                    uint32* service_texture_id);
    186 
    187   // Provides detail about a lost context if one occurred.
    188   virtual error::ContextLostReason GetContextLostReason() = 0;
    189 
    190   // Clears a level of a texture
    191   // Returns false if a GL error should be generated.
    192   virtual bool ClearLevel(
    193       unsigned service_id,
    194       unsigned bind_target,
    195       unsigned target,
    196       int level,
    197       unsigned internal_format,
    198       unsigned format,
    199       unsigned type,
    200       int width,
    201       int height,
    202       bool is_texture_immutable) = 0;
    203 
    204   virtual ErrorState* GetErrorState() = 0;
    205 
    206   // A callback for messages from the decoder.
    207   virtual void SetShaderCacheCallback(const ShaderCacheCallback& callback) = 0;
    208 
    209   // Sets the callback for waiting on a sync point. The callback returns the
    210   // scheduling status (i.e. true if the channel is still scheduled).
    211   virtual void SetWaitSyncPointCallback(
    212       const WaitSyncPointCallback& callback) = 0;
    213 
    214   virtual void WaitForReadPixels(base::Closure callback) = 0;
    215   virtual uint32 GetTextureUploadCount() = 0;
    216   virtual base::TimeDelta GetTotalTextureUploadTime() = 0;
    217   virtual base::TimeDelta GetTotalProcessingCommandsTime() = 0;
    218   virtual void AddProcessingCommandsTime(base::TimeDelta) = 0;
    219 
    220   // Returns true if the context was lost either by GL_ARB_robustness, forced
    221   // context loss or command buffer parse error.
    222   virtual bool WasContextLost() = 0;
    223 
    224   // Returns true if the context was lost specifically by GL_ARB_robustness.
    225   virtual bool WasContextLostByRobustnessExtension() = 0;
    226 
    227   // Lose this context.
    228   virtual void LoseContext(uint32 reset_status) = 0;
    229 
    230   virtual Logger* GetLogger() = 0;
    231 
    232   virtual void BeginDecoding();
    233   virtual void EndDecoding();
    234 
    235   virtual const ContextState* GetContextState() = 0;
    236 
    237  protected:
    238   GLES2Decoder();
    239 
    240  private:
    241   bool initialized_;
    242   bool debug_;
    243   bool log_commands_;
    244 
    245   DISALLOW_COPY_AND_ASSIGN(GLES2Decoder);
    246 };
    247 
    248 }  // namespace gles2
    249 }  // namespace gpu
    250 
    251 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_H_
    252