cc/test/test_web_graphics_context_3d.h

   1 // Copyright 2013 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 CC_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_
   6 #define CC_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_
   7
   8 #include <vector>
   9
  10 #include "base/callback.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/containers/hash_tables.h"
  13 #include "base/containers/scoped_ptr_hash_map.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/stl_util.h"
  18 #include "base/synchronization/lock.h"
  19 #include "cc/output/context_provider.h"
  20 #include "cc/test/ordered_texture_map.h"
  21 #include "cc/test/test_texture.h"
  22 #include "third_party/khronos/GLES2/gl2.h"
  23 #include "ui/gfx/rect.h"
  24
  25 namespace cc {
  26 class TestContextSupport;
  27
  28 class TestWebGraphicsContext3D {
  29  public:
  30   static scoped_ptr<TestWebGraphicsContext3D> Create();
  31
  32   virtual ~TestWebGraphicsContext3D();
  33
  34   void set_context_lost_callback(const base::Closure& callback) {
  35     context_lost_callback_ = callback;
  36   }
  37
  38   virtual void reshapeWithScaleFactor(int width,
  39                                       int height,
  40                                       float scale_factor);
  41
  42   virtual bool isContextLost();
  43
  44   virtual void discardFramebufferEXT(GLenum target,
  45                                      GLsizei num_attachments,
  46                                      const GLenum* attachments) {}
  47
  48   virtual void activeTexture(GLenum texture) {}
  49   virtual void attachShader(GLuint program, GLuint shader);
  50   virtual void bindFramebuffer(GLenum target, GLuint framebuffer);
  51   virtual void bindRenderbuffer(GLenum target, GLuint renderbuffer);
  52   virtual void bindTexture(GLenum target, GLuint texture_id);
  53
  54   virtual void texParameteri(GLenum target, GLenum pname, GLint param);
  55   virtual void getTexParameteriv(GLenum target, GLenum pname, GLint* value);
  56   virtual void asyncTexImage2DCHROMIUM(GLenum target,
  57                                        GLint level,
  58                                        GLenum internalformat,
  59                                        GLsizei width,
  60                                        GLsizei height,
  61                                        GLint border,
  62                                        GLenum format,
  63                                        GLenum type,
  64                                        const void* pixels) {}
  65   virtual void asyncTexSubImage2DCHROMIUM(GLenum target,
  66                                           GLint level,
  67                                           GLint xoffset,
  68                                           GLint yoffset,
  69                                           GLsizei width,
  70                                           GLsizei height,
  71                                           GLenum format,
  72                                           GLenum type,
  73                                           const void* pixels) {}
  74   virtual void waitAsyncTexImage2DCHROMIUM(GLenum target) {}
  75   virtual void releaseTexImage2DCHROMIUM(GLenum target, GLint image_id) {}
  76
  77   virtual GLenum checkFramebufferStatus(GLenum target);
  78
  79   virtual void clear(GLbitfield mask) {}
  80   virtual void clearColor(GLclampf red,
  81                           GLclampf green,
  82                           GLclampf blue,
  83                           GLclampf alpha) {}
  84   virtual void clearStencil(GLint s) {}
  85   virtual void compressedTexImage2D(GLenum target,
  86                                     GLint level,
  87                                     GLenum internal_format,
  88                                     GLsizei width,
  89                                     GLsizei height,
  90                                     GLint border,
  91                                     GLsizei image_size,
  92                                     const void* data) {}
  93   virtual GLint getUniformLocation(GLuint program, const GLchar* name);
  94   virtual GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);
  95
  96   virtual GLboolean isBuffer(GLuint buffer);
  97   virtual GLboolean isEnabled(GLenum cap);
  98   virtual GLboolean isFramebuffer(GLuint framebuffer);
  99   virtual GLboolean isProgram(GLuint program);
 100   virtual GLboolean isRenderbuffer(GLuint renderbuffer);
 101   virtual GLboolean isShader(GLuint shader);
 102   virtual GLboolean isTexture(GLuint texture);
 103
 104   virtual void useProgram(GLuint program);
 105
 106   virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height) {}
 107
 108   virtual void genBuffers(GLsizei count, GLuint* ids);
 109   virtual void genFramebuffers(GLsizei count, GLuint* ids);
 110   virtual void genRenderbuffers(GLsizei count, GLuint* ids);
 111   virtual void genTextures(GLsizei count, GLuint* ids);
 112
 113   virtual void deleteBuffers(GLsizei count, GLuint* ids);
 114   virtual void deleteFramebuffers(GLsizei count, GLuint* ids);
 115   virtual void deleteRenderbuffers(GLsizei count, GLuint* ids);
 116   virtual void deleteTextures(GLsizei count, GLuint* ids);
 117
 118   virtual GLuint createBuffer();
 119   virtual GLuint createFramebuffer();
 120   virtual GLuint createRenderbuffer();
 121   virtual GLuint createTexture();
 122
 123   virtual void deleteBuffer(GLuint id);
 124   virtual void deleteFramebuffer(GLuint id);
 125   virtual void deleteRenderbuffer(GLuint id);
 126   virtual void deleteTexture(GLuint id);
 127
 128   virtual GLuint createProgram();
 129   virtual GLuint createShader(GLenum);
 130   virtual GLuint createExternalTexture();
 131
 132   virtual void deleteProgram(GLuint id);
 133   virtual void deleteShader(GLuint id);
 134
 135   virtual void texStorage2DEXT(GLenum target,
 136                                GLint levels,
 137                                GLuint internalformat,
 138                                GLint width,
 139                                GLint height) {}
 140
 141   virtual GLuint createQueryEXT();
 142   virtual void deleteQueryEXT(GLuint query) {}
 143   virtual void beginQueryEXT(GLenum target, GLuint query) {}
 144   virtual void endQueryEXT(GLenum target);
 145   virtual void getQueryObjectuivEXT(GLuint query, GLenum pname, GLuint* params);
 146
 147   virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height) {}
 148
 149   virtual void texImage2D(GLenum target,
 150                           GLint level,
 151                           GLenum internalformat,
 152                           GLsizei width,
 153                           GLsizei height,
 154                           GLint border,
 155                           GLenum format,
 156                           GLenum type,
 157                           const void* pixels) {}
 158
 159   virtual void texSubImage2D(GLenum target,
 160                              GLint level,
 161                              GLint xoffset,
 162                              GLint yoffset,
 163                              GLsizei width,
 164                              GLsizei height,
 165                              GLenum format,
 166                              GLenum type,
 167                              const void* pixels) {}
 168
 169   virtual void genMailboxCHROMIUM(GLbyte* mailbox);
 170   virtual void produceTextureCHROMIUM(GLenum target,
 171                                       const GLbyte* mailbox) { }
 172   virtual void produceTextureDirectCHROMIUM(GLuint texture,
 173                                             GLenum target,
 174                                             const GLbyte* mailbox) {}
 175   virtual void consumeTextureCHROMIUM(GLenum target,
 176                                       const GLbyte* mailbox) { }
 177   virtual GLuint createAndConsumeTextureCHROMIUM(GLenum target,
 178                                                  const GLbyte* mailbox);
 179
 180   virtual void loseContextCHROMIUM(GLenum current, GLenum other);
 181
 182   virtual void bindTexImage2DCHROMIUM(GLenum target, GLint image_id) {}
 183
 184   virtual void drawArrays(GLenum mode, GLint first, GLsizei count) {}
 185   virtual void drawElements(GLenum mode,
 186                             GLsizei count,
 187                             GLenum type,
 188                             GLintptr offset) {}
 189   virtual void disable(GLenum cap) {}
 190   virtual void enable(GLenum cap) {}
 191   virtual void finish();
 192   virtual void flush();
 193   virtual void shallowFlushCHROMIUM() {}
 194
 195   virtual void getAttachedShaders(GLuint program,
 196                                   GLsizei max_count,
 197                                   GLsizei* count,
 198                                   GLuint* shaders) {}
 199   virtual GLint getAttribLocation(GLuint program, const GLchar* name);
 200   virtual void getBooleanv(GLenum pname, GLboolean* value) {}
 201   virtual void getBufferParameteriv(GLenum target, GLenum pname, GLint* value) {
 202   }
 203   virtual GLenum getError();
 204   virtual void getFloatv(GLenum pname, GLfloat* value) {}
 205   virtual void getFramebufferAttachmentParameteriv(GLenum target,
 206                                                    GLenum attachment,
 207                                                    GLenum pname,
 208                                                    GLint* value) {}
 209
 210   virtual void getIntegerv(GLenum pname, GLint* value);
 211
 212   virtual void getProgramiv(GLuint program, GLenum pname, GLint* value);
 213
 214   virtual void getRenderbufferParameteriv(GLenum target,
 215                                           GLenum pname,
 216                                           GLint* value) {}
 217
 218   virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value);
 219
 220   virtual void getShaderPrecisionFormat(GLenum shadertype,
 221                                         GLenum precisiontype,
 222                                         GLint* range,
 223                                         GLint* precision);
 224
 225   virtual void getTexParameterfv(GLenum target, GLenum pname, GLfloat* value) {}
 226   virtual void getUniformfv(GLuint program, GLint location, GLfloat* value) {}
 227   virtual void getUniformiv(GLuint program, GLint location, GLint* value) {}
 228   virtual void getVertexAttribfv(GLuint index, GLenum pname, GLfloat* value) {}
 229   virtual void getVertexAttribiv(GLuint index, GLenum pname, GLint* value) {}
 230
 231   virtual void bindBuffer(GLenum target, GLuint buffer);
 232   virtual void bufferData(GLenum target,
 233                           GLsizeiptr size,
 234                           const void* data,
 235                           GLenum usage);
 236   virtual void* mapBufferCHROMIUM(GLenum target,
 237                                   GLenum access);
 238   virtual GLboolean unmapBufferCHROMIUM(GLenum target);
 239
 240   virtual GLuint createImageCHROMIUM(GLsizei width,
 241                                      GLsizei height,
 242                                      GLenum internalformat,
 243                                      GLenum usage);
 244   virtual void destroyImageCHROMIUM(GLuint image_id);
 245   virtual void getImageParameterivCHROMIUM(GLuint image_id,
 246                                            GLenum pname,
 247                                            GLint* params);
 248   virtual void* mapImageCHROMIUM(GLuint image_id);
 249   virtual void unmapImageCHROMIUM(GLuint image_id);
 250   virtual void texImageIOSurface2DCHROMIUM(GLenum target,
 251                                            GLsizei width,
 252                                            GLsizei height,
 253                                            GLuint io_surface_id,
 254                                            GLuint plane) {}
 255
 256   virtual unsigned insertSyncPoint();
 257   virtual void waitSyncPoint(unsigned sync_point);
 258
 259   unsigned last_waited_sync_point() const { return last_waited_sync_point_; }
 260
 261   const ContextProvider::Capabilities& test_capabilities() const {
 262     return test_capabilities_;
 263   }
 264
 265   void set_context_lost(bool context_lost) { context_lost_ = context_lost; }
 266   void set_times_bind_texture_succeeds(int times) {
 267     times_bind_texture_succeeds_ = times;
 268   }
 269   void set_times_end_query_succeeds(int times) {
 270     times_end_query_succeeds_ = times;
 271   }
 272
 273   // When set, mapImageCHROMIUM and mapBufferCHROMIUM will return NULL after
 274   // this many times.
 275   void set_times_map_image_chromium_succeeds(int times) {
 276     times_map_image_chromium_succeeds_ = times;
 277   }
 278   void set_times_map_buffer_chromium_succeeds(int times) {
 279     times_map_buffer_chromium_succeeds_ = times;
 280   }
 281
 282   size_t NumTextures() const;
 283   GLuint TextureAt(int i) const;
 284
 285   size_t NumUsedTextures() const { return used_textures_.size(); }
 286   bool UsedTexture(int texture) const {
 287     return ContainsKey(used_textures_, texture);
 288   }
 289   void ResetUsedTextures() { used_textures_.clear(); }
 290
 291   void set_have_extension_io_surface(bool have) {
 292     test_capabilities_.gpu.iosurface = have;
 293     test_capabilities_.gpu.texture_rectangle = have;
 294   }
 295   void set_have_extension_egl_image(bool have) {
 296     test_capabilities_.gpu.egl_image_external = have;
 297   }
 298   void set_have_post_sub_buffer(bool have) {
 299     test_capabilities_.gpu.post_sub_buffer = have;
 300   }
 301   void set_have_discard_framebuffer(bool have) {
 302     test_capabilities_.gpu.discard_framebuffer = have;
 303   }
 304   void set_support_compressed_texture_etc1(bool support) {
 305     test_capabilities_.gpu.texture_format_etc1 = support;
 306   }
 307   void set_support_texture_format_bgra8888(bool support) {
 308     test_capabilities_.gpu.texture_format_bgra8888 = support;
 309   }
 310   void set_support_texture_storage(bool support) {
 311     test_capabilities_.gpu.texture_storage = support;
 312   }
 313   void set_support_texture_usage(bool support) {
 314     test_capabilities_.gpu.texture_usage = support;
 315   }
 316   void set_support_sync_query(bool support) {
 317     test_capabilities_.gpu.sync_query = support;
 318   }
 319
 320   // When this context is lost, all contexts in its share group are also lost.
 321   void add_share_group_context(TestWebGraphicsContext3D* context3d) {
 322     shared_contexts_.push_back(context3d);
 323   }
 324
 325   void set_max_texture_size(int size) { max_texture_size_ = size; }
 326
 327   static const GLuint kExternalTextureId;
 328   virtual GLuint NextTextureId();
 329   virtual void RetireTextureId(GLuint id);
 330
 331   virtual GLuint NextBufferId();
 332   virtual void RetireBufferId(GLuint id);
 333
 334   virtual GLuint NextImageId();
 335   virtual void RetireImageId(GLuint id);
 336
 337   void SetMaxTransferBufferUsageBytes(size_t max_transfer_buffer_usage_bytes);
 338   size_t max_used_transfer_buffer_usage_bytes() const {
 339     return max_used_transfer_buffer_usage_bytes_;
 340   }
 341
 342   void set_test_support(TestContextSupport* test_support) {
 343     test_support_ = test_support;
 344   }
 345
 346   int width() const { return width_; }
 347   int height() const { return height_; }
 348   bool reshape_called() const { return reshape_called_; }
 349   void clear_reshape_called() { reshape_called_ = false; }
 350   float scale_factor() const { return scale_factor_; }
 351
 352   enum UpdateType {
 353     NoUpdate = 0,
 354     PrepareTexture,
 355     PostSubBuffer
 356   };
 357
 358   gfx::Rect update_rect() const { return update_rect_; }
 359
 360   UpdateType last_update_type() { return last_update_type_; }
 361
 362  protected:
 363   struct TextureTargets {
 364     TextureTargets();
 365     ~TextureTargets();
 366
 367     void BindTexture(GLenum target, GLuint id);
 368     void UnbindTexture(GLuint id);
 369
 370     GLuint BoundTexture(GLenum target);
 371
 372    private:
 373     typedef base::hash_map<GLenum, GLuint> TargetTextureMap;
 374     TargetTextureMap bound_textures_;
 375   };
 376
 377   struct Buffer {
 378     Buffer();
 379     ~Buffer();
 380
 381     GLenum target;
 382     scoped_ptr<uint8[]> pixels;
 383     size_t size;
 384
 385    private:
 386     DISALLOW_COPY_AND_ASSIGN(Buffer);
 387   };
 388
 389   struct Image {
 390     Image();
 391     ~Image();
 392
 393     scoped_ptr<uint8[]> pixels;
 394
 395    private:
 396     DISALLOW_COPY_AND_ASSIGN(Image);
 397   };
 398
 399   struct Namespace : public base::RefCountedThreadSafe<Namespace> {
 400     Namespace();
 401
 402     // Protects all fields.
 403     base::Lock lock;
 404     unsigned next_buffer_id;
 405     unsigned next_image_id;
 406     unsigned next_texture_id;
 407     base::ScopedPtrHashMap<unsigned, Buffer> buffers;
 408     base::ScopedPtrHashMap<unsigned, Image> images;
 409     OrderedTextureMap textures;
 410
 411    private:
 412     friend class base::RefCountedThreadSafe<Namespace>;
 413     ~Namespace();
 414     DISALLOW_COPY_AND_ASSIGN(Namespace);
 415   };
 416
 417   TestWebGraphicsContext3D();
 418
 419   void CreateNamespace();
 420   GLuint BoundTextureId(GLenum target);
 421   scoped_refptr<TestTexture> BoundTexture(GLenum target);
 422   void CheckTextureIsBound(GLenum target);
 423
 424   unsigned context_id_;
 425   ContextProvider::Capabilities test_capabilities_;
 426   int times_bind_texture_succeeds_;
 427   int times_end_query_succeeds_;
 428   bool context_lost_;
 429   int times_map_image_chromium_succeeds_;
 430   int times_map_buffer_chromium_succeeds_;
 431   int current_used_transfer_buffer_usage_bytes_;
 432   int max_used_transfer_buffer_usage_bytes_;
 433   base::Closure context_lost_callback_;
 434   base::hash_set<unsigned> used_textures_;
 435   unsigned next_program_id_;
 436   base::hash_set<unsigned> program_set_;
 437   unsigned next_shader_id_;
 438   base::hash_set<unsigned> shader_set_;
 439   std::vector<TestWebGraphicsContext3D*> shared_contexts_;
 440   int max_texture_size_;
 441   bool reshape_called_;
 442   int width_;
 443   int height_;
 444   float scale_factor_;
 445   TestContextSupport* test_support_;
 446   gfx::Rect update_rect_;
 447   UpdateType last_update_type_;
 448   unsigned next_insert_sync_point_;
 449   unsigned last_waited_sync_point_;
 450
 451   unsigned bound_buffer_;
 452   TextureTargets texture_targets_;
 453
 454   scoped_refptr<Namespace> namespace_;
 455   static Namespace* shared_namespace_;
 456
 457   base::WeakPtrFactory<TestWebGraphicsContext3D> weak_ptr_factory_;
 458 };
 459
 460 }  // namespace cc
 461
 462 #endif  // CC_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_