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