Home | History | Annotate | Download | only in client 
      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_CLIENT_GLES2_IMPLEMENTATION_H_
      6 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
      7 
      8 #include <GLES2/gl2.h>
      9 
     10 #include <map>
     11 #include <queue>
     12 #include <set>
     13 #include <string>
     14 #include <vector>
     15 
     16 #include "base/compiler_specific.h"
     17 #include "base/memory/scoped_ptr.h"
     18 #include "base/memory/weak_ptr.h"
     19 #include "gles2_impl_export.h"
     20 #include "gpu/command_buffer/client/buffer_tracker.h"
     21 #include "gpu/command_buffer/client/client_context_state.h"
     22 #include "gpu/command_buffer/client/context_support.h"
     23 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
     24 #include "gpu/command_buffer/client/gles2_interface.h"
     25 #include "gpu/command_buffer/client/gpu_memory_buffer_tracker.h"
     26 #include "gpu/command_buffer/client/mapped_memory.h"
     27 #include "gpu/command_buffer/client/query_tracker.h"
     28 #include "gpu/command_buffer/client/ref_counted.h"
     29 #include "gpu/command_buffer/client/ring_buffer.h"
     30 #include "gpu/command_buffer/client/share_group.h"
     31 #include "gpu/command_buffer/common/capabilities.h"
     32 #include "gpu/command_buffer/common/debug_marker_manager.h"
     33 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
     34 
     35 #if !defined(NDEBUG) && !defined(__native_client__) && !defined(GLES2_CONFORMANCE_TESTS)  // NOLINT
     36   #if defined(GLES2_INLINE_OPTIMIZATION)
     37     // TODO(gman): Replace with macros that work with inline optmization.
     38     #define GPU_CLIENT_SINGLE_THREAD_CHECK()
     39     #define GPU_CLIENT_LOG(args)
     40     #define GPU_CLIENT_LOG_CODE_BLOCK(code)
     41     #define GPU_CLIENT_DCHECK_CODE_BLOCK(code)
     42   #else
     43     #include "base/logging.h"
     44     #define GPU_CLIENT_SINGLE_THREAD_CHECK() SingleThreadChecker checker(this);
     45     #define GPU_CLIENT_LOG(args)  DLOG_IF(INFO, debug_) << args;
     46     #define GPU_CLIENT_LOG_CODE_BLOCK(code) code
     47     #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) code
     48     #define GPU_CLIENT_DEBUG
     49   #endif
     50 #else
     51   #define GPU_CLIENT_SINGLE_THREAD_CHECK()
     52   #define GPU_CLIENT_LOG(args)
     53   #define GPU_CLIENT_LOG_CODE_BLOCK(code)
     54   #define GPU_CLIENT_DCHECK_CODE_BLOCK(code)
     55 #endif
     56 
     57 #if defined(GPU_CLIENT_DEBUG)
     58   // Set to 1 to have the client fail when a GL error is generated.
     59   // This helps find bugs in the renderer since the debugger stops on the error.
     60 #  if 0
     61 #    define GL_CLIENT_FAIL_GL_ERRORS
     62 #  endif
     63 #endif
     64 
     65 // Check that destination pointers point to initialized memory.
     66 // When the context is lost, calling GL function has no effect so if destination
     67 // pointers point to initialized memory it can often lead to crash bugs. eg.
     68 //
     69 // GLsizei len;
     70 // glGetShaderSource(shader, max_size, &len, buffer);
     71 // std::string src(buffer, buffer + len);  // len can be uninitialized here!!!
     72 //
     73 // Because this check is not official GL this check happens only on Chrome code,
     74 // not Pepper.
     75 //
     76 // If it was up to us we'd just always write to the destination but the OpenGL
     77 // spec defines the behavior of OpenGL functions, not us. :-(
     78 #if defined(__native_client__) || defined(GLES2_CONFORMANCE_TESTS)
     79   #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v)
     80   #define GPU_CLIENT_DCHECK(v)
     81 #elif defined(GPU_DCHECK)
     82   #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) GPU_DCHECK(v)
     83   #define GPU_CLIENT_DCHECK(v) GPU_DCHECK(v)
     84 #elif defined(DCHECK)
     85   #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) DCHECK(v)
     86   #define GPU_CLIENT_DCHECK(v) DCHECK(v)
     87 #else
     88   #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) ASSERT(v)
     89   #define GPU_CLIENT_DCHECK(v) ASSERT(v)
     90 #endif
     91 
     92 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(type, ptr) \
     93     GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(ptr && \
     94         (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1)));
     95 
     96 #define GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(type, ptr) \
     97     GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(!ptr || \
     98         (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1)));
     99 
    100 struct GLUniformDefinitionCHROMIUM;
    101 
    102 namespace gpu {
    103 
    104 class GpuControl;
    105 class ScopedTransferBufferPtr;
    106 class TransferBufferInterface;
    107 
    108 namespace gles2 {
    109 
    110 class ImageFactory;
    111 class VertexArrayObjectManager;
    112 
    113 class GLES2ImplementationErrorMessageCallback {
    114  public:
    115   virtual ~GLES2ImplementationErrorMessageCallback() { }
    116   virtual void OnErrorMessage(const char* msg, int id) = 0;
    117 };
    118 
    119 // This class emulates GLES2 over command buffers. It can be used by a client
    120 // program so that the program does not need deal with shared memory and command
    121 // buffer management. See gl2_lib.h.  Note that there is a performance gain to
    122 // be had by changing your code to use command buffers directly by using the
    123 // GLES2CmdHelper but that entails changing your code to use and deal with
    124 // shared memory and synchronization issues.
    125 class GLES2_IMPL_EXPORT GLES2Implementation
    126     : NON_EXPORTED_BASE(public GLES2Interface),
    127       NON_EXPORTED_BASE(public ContextSupport) {
    128  public:
    129   enum MappedMemoryLimit {
    130     kNoLimit = MappedMemoryManager::kNoLimit,
    131   };
    132 
    133   // Stores GL state that never changes.
    134   struct GLES2_IMPL_EXPORT GLStaticState {
    135     GLStaticState();
    136     ~GLStaticState();
    137 
    138     struct GLES2_IMPL_EXPORT IntState {
    139       IntState();
    140       GLint max_combined_texture_image_units;
    141       GLint max_cube_map_texture_size;
    142       GLint max_fragment_uniform_vectors;
    143       GLint max_renderbuffer_size;
    144       GLint max_texture_image_units;
    145       GLint max_texture_size;
    146       GLint max_varying_vectors;
    147       GLint max_vertex_attribs;
    148       GLint max_vertex_texture_image_units;
    149       GLint max_vertex_uniform_vectors;
    150       GLint num_compressed_texture_formats;
    151       GLint num_shader_binary_formats;
    152       GLint bind_generates_resource_chromium;
    153     };
    154     IntState int_state;
    155 
    156     typedef std::pair<GLenum,GLenum> ShaderPrecisionKey;
    157     typedef std::map<ShaderPrecisionKey,
    158                      cmds::GetShaderPrecisionFormat::Result>
    159         ShaderPrecisionMap;
    160     ShaderPrecisionMap shader_precisions;
    161   };
    162 
    163   // The maxiumum result size from simple GL get commands.
    164   static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32);  // NOLINT.
    165 
    166   // used for testing only. If more things are reseved add them here.
    167   static const unsigned int kStartingOffset = kMaxSizeOfSimpleResult;
    168 
    169   // Size in bytes to issue async flush for transfer buffer.
    170   static const unsigned int kSizeToFlush = 256 * 1024;
    171 
    172   // The bucket used for results. Public for testing only.
    173   static const uint32 kResultBucketId = 1;
    174 
    175   // Alignment of allocations.
    176   static const unsigned int kAlignment = 4;
    177 
    178   // GL names for the buffers used to emulate client side buffers.
    179   static const GLuint kClientSideArrayId = 0xFEDCBA98u;
    180   static const GLuint kClientSideElementArrayId = 0xFEDCBA99u;
    181 
    182   // Number of swap buffers allowed before waiting.
    183   static const size_t kMaxSwapBuffers = 2;
    184 
    185   GLES2Implementation(GLES2CmdHelper* helper,
    186                       ShareGroup* share_group,
    187                       TransferBufferInterface* transfer_buffer,
    188                       bool bind_generates_resource,
    189                       bool lose_context_when_out_of_memory,
    190                       GpuControl* gpu_control);
    191 
    192   virtual ~GLES2Implementation();
    193 
    194   bool Initialize(
    195       unsigned int starting_transfer_buffer_size,
    196       unsigned int min_transfer_buffer_size,
    197       unsigned int max_transfer_buffer_size,
    198       unsigned int mapped_memory_limit);
    199 
    200   // The GLES2CmdHelper being used by this GLES2Implementation. You can use
    201   // this to issue cmds at a lower level for certain kinds of optimization.
    202   GLES2CmdHelper* helper() const;
    203 
    204   // Gets client side generated errors.
    205   GLenum GetClientSideGLError();
    206 
    207   // Include the auto-generated part of this class. We split this because
    208   // it means we can easily edit the non-auto generated parts right here in
    209   // this file instead of having to edit some template or the code generator.
    210   #include "gpu/command_buffer/client/gles2_implementation_autogen.h"
    211 
    212   virtual void DisableVertexAttribArray(GLuint index) OVERRIDE;
    213   virtual void EnableVertexAttribArray(GLuint index) OVERRIDE;
    214   virtual void GetVertexAttribfv(
    215       GLuint index, GLenum pname, GLfloat* params) OVERRIDE;
    216   virtual void GetVertexAttribiv(
    217       GLuint index, GLenum pname, GLint* params) OVERRIDE;
    218 
    219   // ContextSupport implementation.
    220   virtual void Swap() OVERRIDE;
    221   virtual void PartialSwapBuffers(const gfx::Rect& sub_buffer) OVERRIDE;
    222   virtual void SetSwapBuffersCompleteCallback(
    223       const base::Closure& swap_buffers_complete_callback)
    224           OVERRIDE;
    225   virtual void ScheduleOverlayPlane(int plane_z_order,
    226                                     gfx::OverlayTransform plane_transform,
    227                                     unsigned overlay_texture_id,
    228                                     const gfx::Rect& display_bounds,
    229                                     const gfx::RectF& uv_rect) OVERRIDE;
    230 
    231   void GetProgramInfoCHROMIUMHelper(GLuint program, std::vector<int8>* result);
    232   GLint GetAttribLocationHelper(GLuint program, const char* name);
    233   GLint GetUniformLocationHelper(GLuint program, const char* name);
    234   bool GetActiveAttribHelper(
    235       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
    236       GLint* size, GLenum* type, char* name);
    237   bool GetActiveUniformHelper(
    238       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
    239       GLint* size, GLenum* type, char* name);
    240 
    241   void FreeUnusedSharedMemory();
    242   void FreeEverything();
    243 
    244   // ContextSupport implementation.
    245   virtual void SignalSyncPoint(uint32 sync_point,
    246                                const base::Closure& callback) OVERRIDE;
    247   virtual void SignalQuery(uint32 query,
    248                            const base::Closure& callback) OVERRIDE;
    249   virtual void SetSurfaceVisible(bool visible) OVERRIDE;
    250 
    251   void SetErrorMessageCallback(
    252       GLES2ImplementationErrorMessageCallback* callback) {
    253     error_message_callback_ = callback;
    254   }
    255 
    256   ShareGroup* share_group() const {
    257     return share_group_.get();
    258   }
    259 
    260   const Capabilities& capabilities() const {
    261     return capabilities_;
    262   }
    263 
    264   GpuControl* gpu_control() {
    265     return gpu_control_;
    266   }
    267 
    268   ShareGroupContextData* share_group_context_data() {
    269     return &share_group_context_data_;
    270   }
    271 
    272  private:
    273   friend class GLES2ImplementationTest;
    274   friend class VertexArrayObjectManager;
    275 
    276   // Used to track whether an extension is available
    277   enum ExtensionStatus {
    278       kAvailableExtensionStatus,
    279       kUnavailableExtensionStatus,
    280       kUnknownExtensionStatus
    281   };
    282 
    283   // Base class for mapped resources.
    284   struct MappedResource {
    285     MappedResource(GLenum _access, int _shm_id, void* mem, unsigned int offset)
    286         : access(_access),
    287           shm_id(_shm_id),
    288           shm_memory(mem),
    289           shm_offset(offset) {
    290     }
    291 
    292     // access mode. Currently only GL_WRITE_ONLY is valid
    293     GLenum access;
    294 
    295     // Shared memory ID for buffer.
    296     int shm_id;
    297 
    298     // Address of shared memory
    299     void* shm_memory;
    300 
    301     // Offset of shared memory
    302     unsigned int shm_offset;
    303   };
    304 
    305   // Used to track mapped textures.
    306   struct MappedTexture : public MappedResource {
    307     MappedTexture(
    308         GLenum access,
    309         int shm_id,
    310         void* shm_mem,
    311         unsigned int shm_offset,
    312         GLenum _target,
    313         GLint _level,
    314         GLint _xoffset,
    315         GLint _yoffset,
    316         GLsizei _width,
    317         GLsizei _height,
    318         GLenum _format,
    319         GLenum _type)
    320         : MappedResource(access, shm_id, shm_mem, shm_offset),
    321           target(_target),
    322           level(_level),
    323           xoffset(_xoffset),
    324           yoffset(_yoffset),
    325           width(_width),
    326           height(_height),
    327           format(_format),
    328           type(_type) {
    329     }
    330 
    331     // These match the arguments to TexSubImage2D.
    332     GLenum target;
    333     GLint level;
    334     GLint xoffset;
    335     GLint yoffset;
    336     GLsizei width;
    337     GLsizei height;
    338     GLenum format;
    339     GLenum type;
    340   };
    341 
    342   // Used to track mapped buffers.
    343   struct MappedBuffer : public MappedResource {
    344     MappedBuffer(
    345         GLenum access,
    346         int shm_id,
    347         void* shm_mem,
    348         unsigned int shm_offset,
    349         GLenum _target,
    350         GLintptr _offset,
    351         GLsizeiptr _size)
    352         : MappedResource(access, shm_id, shm_mem, shm_offset),
    353           target(_target),
    354           offset(_offset),
    355           size(_size) {
    356     }
    357 
    358     // These match the arguments to BufferSubData.
    359     GLenum target;
    360     GLintptr offset;
    361     GLsizeiptr size;
    362   };
    363 
    364   struct TextureUnit {
    365     TextureUnit()
    366         : bound_texture_2d(0),
    367           bound_texture_cube_map(0),
    368           bound_texture_external_oes(0) {}
    369 
    370     // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture
    371     GLuint bound_texture_2d;
    372 
    373     // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
    374     // glBindTexture
    375     GLuint bound_texture_cube_map;
    376 
    377     // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with
    378     // glBindTexture
    379     GLuint bound_texture_external_oes;
    380   };
    381 
    382   // Checks for single threaded access.
    383   class SingleThreadChecker {
    384    public:
    385     SingleThreadChecker(GLES2Implementation* gles2_implementation);
    386     ~SingleThreadChecker();
    387 
    388    private:
    389     GLES2Implementation* gles2_implementation_;
    390   };
    391 
    392   // Gets the value of the result.
    393   template <typename T>
    394   T GetResultAs() {
    395     return static_cast<T>(GetResultBuffer());
    396   }
    397 
    398   void* GetResultBuffer();
    399   int32 GetResultShmId();
    400   uint32 GetResultShmOffset();
    401 
    402   bool QueryAndCacheStaticState();
    403 
    404   // Helpers used to batch synchronous GetIntergerv calls with other
    405   // synchronous calls.
    406   struct GetMultipleIntegervState {
    407     GetMultipleIntegervState(const GLenum* pnames, GLuint pnames_count,
    408                              GLint* results, GLsizeiptr results_size)
    409        : pnames(pnames),
    410          pnames_count(pnames_count),
    411          results(results),
    412          results_size(results_size)
    413     { }
    414     // inputs
    415     const GLenum* pnames;
    416     GLuint pnames_count;
    417     // outputs
    418     GLint* results;
    419     GLsizeiptr results_size;
    420     // transfer buffer
    421     int num_results;
    422     int transfer_buffer_size_needed;
    423     void* buffer;
    424     void* results_buffer;
    425   };
    426   bool GetMultipleIntegervSetup(
    427       GetMultipleIntegervState* state);
    428   void GetMultipleIntegervRequest(
    429       GetMultipleIntegervState* state);
    430   void GetMultipleIntegervOnCompleted(
    431       GetMultipleIntegervState* state);
    432 
    433   // Helpers used to batch synchronous GetShaderPrecision calls with other
    434   // synchronous calls.
    435   struct GetAllShaderPrecisionFormatsState {
    436     GetAllShaderPrecisionFormatsState(
    437         const GLenum (*precision_params)[2],
    438         int precision_params_count)
    439         : precision_params(precision_params),
    440           precision_params_count(precision_params_count)
    441     { }
    442     const GLenum (*precision_params)[2];
    443     int precision_params_count;
    444     int transfer_buffer_size_needed;
    445     void* results_buffer;
    446   };
    447   void GetAllShaderPrecisionFormatsSetup(
    448       GetAllShaderPrecisionFormatsState* state);
    449   void GetAllShaderPrecisionFormatsRequest(
    450       GetAllShaderPrecisionFormatsState* state);
    451   void GetAllShaderPrecisionFormatsOnCompleted(
    452       GetAllShaderPrecisionFormatsState* state);
    453 
    454   // Lazily determines if GL_ANGLE_pack_reverse_row_order is available
    455   bool IsAnglePackReverseRowOrderAvailable();
    456   bool IsChromiumFramebufferMultisampleAvailable();
    457 
    458   bool IsExtensionAvailableHelper(
    459       const char* extension, ExtensionStatus* status);
    460 
    461   // Gets the GLError through our wrapper.
    462   GLenum GetGLError();
    463 
    464   // Sets our wrapper for the GLError.
    465   void SetGLError(GLenum error, const char* function_name, const char* msg);
    466   void SetGLErrorInvalidEnum(
    467       const char* function_name, GLenum value, const char* label);
    468 
    469   // Returns the last error and clears it. Useful for debugging.
    470   const std::string& GetLastError() {
    471     return last_error_;
    472   }
    473 
    474   // Waits for all commands to execute.
    475   void WaitForCmd();
    476 
    477   // TODO(gman): These bucket functions really seem like they belong in
    478   // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need
    479   // a transfer buffer to function which is currently managed by this class.
    480 
    481   // Gets the contents of a bucket.
    482   bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data);
    483 
    484   // Sets the contents of a bucket.
    485   void SetBucketContents(uint32 bucket_id, const void* data, size_t size);
    486 
    487   // Sets the contents of a bucket as a string.
    488   void SetBucketAsCString(uint32 bucket_id, const char* str);
    489 
    490   // Gets the contents of a bucket as a string. Returns false if there is no
    491   // string available which is a separate case from the empty string.
    492   bool GetBucketAsString(uint32 bucket_id, std::string* str);
    493 
    494   // Sets the contents of a bucket as a string.
    495   void SetBucketAsString(uint32 bucket_id, const std::string& str);
    496 
    497   // Returns true if id is reserved.
    498   bool IsBufferReservedId(GLuint id);
    499   bool IsFramebufferReservedId(GLuint id) { return false;  }
    500   bool IsRenderbufferReservedId(GLuint id) { return false; }
    501   bool IsTextureReservedId(GLuint id) { return false; }
    502   bool IsVertexArrayReservedId(GLuint id) { return false; }
    503   bool IsProgramReservedId(GLuint id) { return false; }
    504 
    505   bool BindBufferHelper(GLenum target, GLuint texture);
    506   bool BindFramebufferHelper(GLenum target, GLuint texture);
    507   bool BindRenderbufferHelper(GLenum target, GLuint texture);
    508   bool BindTextureHelper(GLenum target, GLuint texture);
    509   bool BindVertexArrayOESHelper(GLuint array);
    510   bool UseProgramHelper(GLuint program);
    511 
    512   void GenBuffersHelper(GLsizei n, const GLuint* buffers);
    513   void GenFramebuffersHelper(GLsizei n, const GLuint* framebuffers);
    514   void GenRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers);
    515   void GenTexturesHelper(GLsizei n, const GLuint* textures);
    516   void GenVertexArraysOESHelper(GLsizei n, const GLuint* arrays);
    517   void GenQueriesEXTHelper(GLsizei n, const GLuint* queries);
    518 
    519   void DeleteBuffersHelper(GLsizei n, const GLuint* buffers);
    520   void DeleteFramebuffersHelper(GLsizei n, const GLuint* framebuffers);
    521   void DeleteRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers);
    522   void DeleteTexturesHelper(GLsizei n, const GLuint* textures);
    523   bool DeleteProgramHelper(GLuint program);
    524   bool DeleteShaderHelper(GLuint shader);
    525   void DeleteQueriesEXTHelper(GLsizei n, const GLuint* queries);
    526   void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* arrays);
    527 
    528   void DeleteBuffersStub(GLsizei n, const GLuint* buffers);
    529   void DeleteFramebuffersStub(GLsizei n, const GLuint* framebuffers);
    530   void DeleteRenderbuffersStub(GLsizei n, const GLuint* renderbuffers);
    531   void DeleteTexturesStub(GLsizei n, const GLuint* textures);
    532   void DeleteProgramStub(GLsizei n, const GLuint* programs);
    533   void DeleteShaderStub(GLsizei n, const GLuint* shaders);
    534   // TODO(gman): Remove this as queries are not shared.
    535   void DeleteQueriesStub(GLsizei n, const GLuint* queries);
    536   void DeleteVertexArraysOESStub(GLsizei n, const GLuint* arrays);
    537 
    538   void BufferDataHelper(
    539       GLenum target, GLsizeiptr size, const void* data, GLenum usage);
    540   void BufferSubDataHelper(
    541       GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
    542   void BufferSubDataHelperImpl(
    543       GLenum target, GLintptr offset, GLsizeiptr size, const void* data,
    544       ScopedTransferBufferPtr* buffer);
    545 
    546   GLuint CreateImageCHROMIUMHelper(GLsizei width,
    547                                    GLsizei height,
    548                                    GLenum internalformat,
    549                                    GLenum usage);
    550   void DestroyImageCHROMIUMHelper(GLuint image_id);
    551   void* MapImageCHROMIUMHelper(GLuint image_id);
    552   void UnmapImageCHROMIUMHelper(GLuint image_id);
    553   void GetImageParameterivCHROMIUMHelper(
    554       GLuint image_id, GLenum pname, GLint* params);
    555 
    556   // Helper for GetVertexAttrib
    557   bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32* param);
    558 
    559   GLuint GetMaxValueInBufferCHROMIUMHelper(
    560       GLuint buffer_id, GLsizei count, GLenum type, GLuint offset);
    561 
    562   void RestoreElementAndArrayBuffers(bool restore);
    563   void RestoreArrayBuffer(bool restrore);
    564 
    565   // The pixels pointer should already account for unpack skip rows and skip
    566   // pixels.
    567   void TexSubImage2DImpl(
    568       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
    569       GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size,
    570       const void* pixels, uint32 pixels_padded_row_size, GLboolean internal,
    571       ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size);
    572 
    573   // Helpers for query functions.
    574   bool GetHelper(GLenum pname, GLint* params);
    575   bool GetBooleanvHelper(GLenum pname, GLboolean* params);
    576   bool GetBufferParameterivHelper(GLenum target, GLenum pname, GLint* params);
    577   bool GetFloatvHelper(GLenum pname, GLfloat* params);
    578   bool GetFramebufferAttachmentParameterivHelper(
    579       GLenum target, GLenum attachment, GLenum pname, GLint* params);
    580   bool GetIntegervHelper(GLenum pname, GLint* params);
    581   bool GetProgramivHelper(GLuint program, GLenum pname, GLint* params);
    582   bool GetRenderbufferParameterivHelper(
    583       GLenum target, GLenum pname, GLint* params);
    584   bool GetShaderivHelper(GLuint shader, GLenum pname, GLint* params);
    585   bool GetTexParameterfvHelper(GLenum target, GLenum pname, GLfloat* params);
    586   bool GetTexParameterivHelper(GLenum target, GLenum pname, GLint* params);
    587   const GLubyte* GetStringHelper(GLenum name);
    588 
    589   bool IsExtensionAvailable(const char* ext);
    590 
    591   // Caches certain capabilties state. Return true if cached.
    592   bool SetCapabilityState(GLenum cap, bool enabled);
    593 
    594   IdHandlerInterface* GetIdHandler(int id_namespace) const;
    595 
    596   void FinishHelper();
    597 
    598   void RunIfContextNotLost(const base::Closure& callback);
    599 
    600   void OnSwapBuffersComplete();
    601 
    602   // Validate if an offset is valid, i.e., non-negative and fit into 32-bit.
    603   // If not, generate an approriate error, and return false.
    604   bool ValidateOffset(const char* func, GLintptr offset);
    605 
    606   // Validate if a size is valid, i.e., non-negative and fit into 32-bit.
    607   // If not, generate an approriate error, and return false.
    608   bool ValidateSize(const char* func, GLsizeiptr offset);
    609 
    610   // Remove the transfer buffer from the buffer tracker. For buffers used
    611   // asynchronously the memory is free:ed if the upload has completed. For
    612   // other buffers, the memory is either free:ed immediately or free:ed pending
    613   // a token.
    614   void RemoveTransferBuffer(BufferTracker::Buffer* buffer);
    615 
    616   // Returns true if the async upload token has passed.
    617   //
    618   // NOTE: This will detect wrapped async tokens by checking if the most
    619   // significant  bit of async token to check is 1 but the last read is 0, i.e.
    620   // the uint32 wrapped.
    621   bool HasAsyncUploadTokenPassed(uint32 token) const {
    622     return async_upload_sync_->HasAsyncUploadTokenPassed(token);
    623   }
    624 
    625   // Get the next async upload token.
    626   uint32 NextAsyncUploadToken();
    627 
    628   // Ensure that the shared memory used for synchronizing async upload tokens
    629   // has been mapped.
    630   //
    631   // Returns false on error, true on success.
    632   bool EnsureAsyncUploadSync();
    633 
    634   // Checks the last read asynchronously upload token and frees any unmanaged
    635   // transfer buffer that has its async token passed.
    636   void PollAsyncUploads();
    637 
    638   // Free every async upload buffer. If some async upload buffer is still in use
    639   // wait for them to finish before freeing.
    640   void FreeAllAsyncUploadBuffers();
    641 
    642   bool GetBoundPixelTransferBuffer(
    643       GLenum target, const char* function_name, GLuint* buffer_id);
    644   BufferTracker::Buffer* GetBoundPixelUnpackTransferBufferIfValid(
    645       GLuint buffer_id,
    646       const char* function_name, GLuint offset, GLsizei size);
    647 
    648   const std::string& GetLogPrefix() const;
    649 
    650 #if defined(GL_CLIENT_FAIL_GL_ERRORS)
    651   void CheckGLError();
    652   void FailGLError(GLenum error);
    653 #else
    654   void CheckGLError() { }
    655   void FailGLError(GLenum /* error */) { }
    656 #endif
    657 
    658   GLES2Util util_;
    659   GLES2CmdHelper* helper_;
    660   TransferBufferInterface* transfer_buffer_;
    661   std::string last_error_;
    662   DebugMarkerManager debug_marker_manager_;
    663   std::string this_in_hex_;
    664 
    665   std::queue<int32> swap_buffers_tokens_;
    666   std::queue<int32> rate_limit_tokens_;
    667 
    668   ExtensionStatus angle_pack_reverse_row_order_status_;
    669   ExtensionStatus chromium_framebuffer_multisample_;
    670 
    671   GLStaticState static_state_;
    672   ClientContextState state_;
    673 
    674   // pack alignment as last set by glPixelStorei
    675   GLint pack_alignment_;
    676 
    677   // unpack alignment as last set by glPixelStorei
    678   GLint unpack_alignment_;
    679 
    680   // unpack yflip as last set by glPixelstorei
    681   bool unpack_flip_y_;
    682 
    683   // unpack row length as last set by glPixelStorei
    684   GLint unpack_row_length_;
    685 
    686   // unpack skip rows as last set by glPixelStorei
    687   GLint unpack_skip_rows_;
    688 
    689   // unpack skip pixels as last set by glPixelStorei
    690   GLint unpack_skip_pixels_;
    691 
    692   // pack reverse row order as last set by glPixelstorei
    693   bool pack_reverse_row_order_;
    694 
    695   scoped_ptr<TextureUnit[]> texture_units_;
    696 
    697   // 0 to gl_state_.max_combined_texture_image_units.
    698   GLuint active_texture_unit_;
    699 
    700   GLuint bound_framebuffer_;
    701   GLuint bound_read_framebuffer_;
    702   GLuint bound_renderbuffer_;
    703 
    704   // The program in use by glUseProgram
    705   GLuint current_program_;
    706 
    707   // The currently bound array buffer.
    708   GLuint bound_array_buffer_id_;
    709 
    710   // The currently bound pixel transfer buffers.
    711   GLuint bound_pixel_pack_transfer_buffer_id_;
    712   GLuint bound_pixel_unpack_transfer_buffer_id_;
    713 
    714   // The current asynchronous pixel buffer upload token.
    715   uint32 async_upload_token_;
    716 
    717   // The shared memory used for synchronizing asynchronous upload tokens.
    718   AsyncUploadSync* async_upload_sync_;
    719   int32 async_upload_sync_shm_id_;
    720   unsigned int async_upload_sync_shm_offset_;
    721 
    722   // Unmanaged pixel transfer buffer memory pending asynchronous upload token.
    723   typedef std::list<std::pair<void*, uint32> > DetachedAsyncUploadMemoryList;
    724   DetachedAsyncUploadMemoryList detached_async_upload_memory_;
    725 
    726   // Client side management for vertex array objects. Needed to correctly
    727   // track client side arrays.
    728   scoped_ptr<VertexArrayObjectManager> vertex_array_object_manager_;
    729 
    730   GLuint reserved_ids_[2];
    731 
    732   // Current GL error bits.
    733   uint32 error_bits_;
    734 
    735   // Whether or not to print debugging info.
    736   bool debug_;
    737 
    738   // When true, the context is lost when a GL_OUT_OF_MEMORY error occurs.
    739   bool lose_context_when_out_of_memory_;
    740 
    741   // Used to check for single threaded access.
    742   int use_count_;
    743 
    744   // Map of GLenum to Strings for glGetString.  We need to cache these because
    745   // the pointer passed back to the client has to remain valid for eternity.
    746   typedef std::map<uint32, std::set<std::string> > GLStringMap;
    747   GLStringMap gl_strings_;
    748 
    749   // Similar cache for glGetRequestableExtensionsCHROMIUM. We don't
    750   // have an enum for this so handle it separately.
    751   std::set<std::string> requestable_extensions_set_;
    752 
    753   typedef std::map<const void*, MappedBuffer> MappedBufferMap;
    754   MappedBufferMap mapped_buffers_;
    755 
    756   typedef std::map<const void*, MappedTexture> MappedTextureMap;
    757   MappedTextureMap mapped_textures_;
    758 
    759   scoped_ptr<MappedMemoryManager> mapped_memory_;
    760 
    761   scoped_refptr<ShareGroup> share_group_;
    762   ShareGroupContextData share_group_context_data_;
    763 
    764   scoped_ptr<QueryTracker> query_tracker_;
    765   typedef std::map<GLuint, QueryTracker::Query*> QueryMap;
    766   QueryMap current_queries_;
    767 
    768   scoped_ptr<BufferTracker> buffer_tracker_;
    769 
    770   scoped_ptr<GpuMemoryBufferTracker> gpu_memory_buffer_tracker_;
    771 
    772   GLES2ImplementationErrorMessageCallback* error_message_callback_;
    773 
    774   scoped_ptr<std::string> current_trace_name_;
    775 
    776   GpuControl* gpu_control_;
    777 
    778   Capabilities capabilities_;
    779 
    780   base::Closure swap_buffers_complete_callback_;
    781 
    782   base::WeakPtrFactory<GLES2Implementation> weak_ptr_factory_;
    783 
    784   DISALLOW_COPY_AND_ASSIGN(GLES2Implementation);
    785 };
    786 
    787 inline bool GLES2Implementation::GetBufferParameterivHelper(
    788     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
    789   return false;
    790 }
    791 
    792 inline bool GLES2Implementation::GetFramebufferAttachmentParameterivHelper(
    793     GLenum /* target */,
    794     GLenum /* attachment */,
    795     GLenum /* pname */,
    796     GLint* /* params */) {
    797   return false;
    798 }
    799 
    800 inline bool GLES2Implementation::GetRenderbufferParameterivHelper(
    801     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
    802   return false;
    803 }
    804 
    805 inline bool GLES2Implementation::GetShaderivHelper(
    806     GLuint /* shader */, GLenum /* pname */, GLint* /* params */) {
    807   return false;
    808 }
    809 
    810 inline bool GLES2Implementation::GetTexParameterfvHelper(
    811     GLenum /* target */, GLenum /* pname */, GLfloat* /* params */) {
    812   return false;
    813 }
    814 
    815 inline bool GLES2Implementation::GetTexParameterivHelper(
    816     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
    817   return false;
    818 }
    819 
    820 }  // namespace gles2
    821 }  // namespace gpu
    822 
    823 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
    824