cc/test/test_web_graphics_context_3d.cc

   1 // Copyright 2011 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 #include "cc/test/test_web_graphics_context_3d.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/logging.h"
  11 #include "gpu/GLES2/gl2extchromium.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/khronos/GLES2/gl2ext.h"
  14
  15 using WebKit::WGC3Dboolean;
  16 using WebKit::WGC3Dchar;
  17 using WebKit::WGC3Denum;
  18 using WebKit::WGC3Dint;
  19 using WebKit::WGC3Dsizei;
  20 using WebKit::WGC3Dsizeiptr;
  21 using WebKit::WGC3Duint;
  22 using WebKit::WebGLId;
  23 using WebKit::WebGraphicsContext3D;
  24
  25 namespace cc {
  26
  27 static const WebGLId kBufferId = 1;
  28 static const WebGLId kFramebufferId = 2;
  29 static const WebGLId kProgramId = 3;
  30 static const WebGLId kRenderbufferId = 4;
  31 static const WebGLId kShaderId = 5;
  32
  33 static unsigned s_context_id = 1;
  34
  35 const WebGLId TestWebGraphicsContext3D::kExternalTextureId = 1337;
  36
  37 TestWebGraphicsContext3D::TestWebGraphicsContext3D()
  38     : FakeWebGraphicsContext3D(),
  39       context_id_(s_context_id++),
  40       next_texture_id_(1),
  41       have_extension_io_surface_(false),
  42       have_extension_egl_image_(false),
  43       times_make_current_succeeds_(-1),
  44       times_bind_texture_succeeds_(-1),
  45       times_end_query_succeeds_(-1),
  46       context_lost_(false),
  47       context_lost_callback_(NULL),
  48       max_texture_size_(1024),
  49       width_(0),
  50       height_(0) {
  51 }
  52
  53 TestWebGraphicsContext3D::TestWebGraphicsContext3D(
  54     const WebGraphicsContext3D::Attributes& attributes)
  55     : FakeWebGraphicsContext3D(),
  56       context_id_(s_context_id++),
  57       next_texture_id_(1),
  58       attributes_(attributes),
  59       have_extension_io_surface_(false),
  60       have_extension_egl_image_(false),
  61       times_make_current_succeeds_(-1),
  62       times_bind_texture_succeeds_(-1),
  63       times_end_query_succeeds_(-1),
  64       context_lost_(false),
  65       context_lost_callback_(NULL),
  66       max_texture_size_(1024),
  67       width_(0),
  68       height_(0) {
  69 }
  70
  71 TestWebGraphicsContext3D::~TestWebGraphicsContext3D() {
  72 }
  73
  74 bool TestWebGraphicsContext3D::makeContextCurrent() {
  75   if (times_make_current_succeeds_ >= 0) {
  76     if (!times_make_current_succeeds_) {
  77       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
  78                           GL_INNOCENT_CONTEXT_RESET_ARB);
  79     }
  80     --times_make_current_succeeds_;
  81   }
  82   return !context_lost_;
  83 }
  84
  85 int TestWebGraphicsContext3D::width() {
  86   return width_;
  87 }
  88
  89 int TestWebGraphicsContext3D::height() {
  90   return height_;
  91 }
  92
  93 void TestWebGraphicsContext3D::reshape(int width, int height) {
  94   width_ = width;
  95   height_ = height;
  96 }
  97
  98 bool TestWebGraphicsContext3D::isContextLost() {
  99   return context_lost_;
 100 }
 101
 102 WGC3Denum TestWebGraphicsContext3D::getGraphicsResetStatusARB() {
 103   return context_lost_ ? GL_UNKNOWN_CONTEXT_RESET_ARB : GL_NO_ERROR;
 104 }
 105
 106 WGC3Denum TestWebGraphicsContext3D::checkFramebufferStatus(
 107     WGC3Denum target) {
 108   if (context_lost_)
 109     return GL_FRAMEBUFFER_UNDEFINED_OES;
 110   return GL_FRAMEBUFFER_COMPLETE;
 111 }
 112
 113 WebGraphicsContext3D::Attributes
 114     TestWebGraphicsContext3D::getContextAttributes() {
 115   return attributes_;
 116 }
 117
 118 WebKit::WebString TestWebGraphicsContext3D::getString(WGC3Denum name) {
 119   std::string string;
 120
 121   if (name == GL_EXTENSIONS) {
 122     if (have_extension_io_surface_)
 123       string += "GL_CHROMIUM_iosurface GL_ARB_texture_rectangle ";
 124     if (have_extension_egl_image_)
 125       string += "GL_OES_EGL_image_external";
 126   }
 127
 128   return WebKit::WebString::fromUTF8(string.c_str());
 129 }
 130
 131 WGC3Dint TestWebGraphicsContext3D::getUniformLocation(
 132     WebGLId program,
 133     const WGC3Dchar* name) {
 134   return 0;
 135 }
 136
 137 WGC3Dsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset(
 138     WGC3Duint index,
 139     WGC3Denum pname) {
 140   return 0;
 141 }
 142
 143 WGC3Dboolean TestWebGraphicsContext3D::isBuffer(
 144     WebGLId buffer) {
 145   return false;
 146 }
 147
 148 WGC3Dboolean TestWebGraphicsContext3D::isEnabled(
 149     WGC3Denum cap) {
 150   return false;
 151 }
 152
 153 WGC3Dboolean TestWebGraphicsContext3D::isFramebuffer(
 154     WebGLId framebuffer) {
 155   return false;
 156 }
 157
 158 WGC3Dboolean TestWebGraphicsContext3D::isProgram(
 159     WebGLId program) {
 160   return false;
 161 }
 162
 163 WGC3Dboolean TestWebGraphicsContext3D::isRenderbuffer(
 164     WebGLId renderbuffer) {
 165   return false;
 166 }
 167
 168 WGC3Dboolean TestWebGraphicsContext3D::isShader(
 169     WebGLId shader) {
 170   return false;
 171 }
 172
 173 WGC3Dboolean TestWebGraphicsContext3D::isTexture(
 174     WebGLId texture) {
 175   return false;
 176 }
 177
 178 WebGLId TestWebGraphicsContext3D::createBuffer() {
 179   return kBufferId | context_id_ << 16;
 180 }
 181
 182 void TestWebGraphicsContext3D::deleteBuffer(WebGLId id) {
 183   EXPECT_EQ(kBufferId | context_id_ << 16, id);
 184 }
 185
 186 WebGLId TestWebGraphicsContext3D::createFramebuffer() {
 187   return kFramebufferId | context_id_ << 16;
 188 }
 189
 190 void TestWebGraphicsContext3D::deleteFramebuffer(WebGLId id) {
 191   EXPECT_EQ(kFramebufferId | context_id_ << 16, id);
 192 }
 193
 194 WebGLId TestWebGraphicsContext3D::createProgram() {
 195   return kProgramId | context_id_ << 16;
 196 }
 197
 198 void TestWebGraphicsContext3D::deleteProgram(WebGLId id) {
 199   EXPECT_EQ(kProgramId | context_id_ << 16, id);
 200 }
 201
 202 WebGLId TestWebGraphicsContext3D::createRenderbuffer() {
 203   return kRenderbufferId | context_id_ << 16;
 204 }
 205
 206 void TestWebGraphicsContext3D::deleteRenderbuffer(WebGLId id) {
 207   EXPECT_EQ(kRenderbufferId | context_id_ << 16, id);
 208 }
 209
 210 WebGLId TestWebGraphicsContext3D::createShader(WGC3Denum) {
 211   return kShaderId | context_id_ << 16;
 212 }
 213
 214 void TestWebGraphicsContext3D::deleteShader(WebGLId id) {
 215   EXPECT_EQ(kShaderId | context_id_ << 16, id);
 216 }
 217
 218 WebGLId TestWebGraphicsContext3D::createTexture() {
 219   WebGLId texture_id = NextTextureId();
 220   DCHECK_NE(texture_id, kExternalTextureId);
 221   textures_.push_back(texture_id);
 222   return texture_id;
 223 }
 224
 225 void TestWebGraphicsContext3D::deleteTexture(WebGLId texture_id) {
 226   DCHECK(std::find(textures_.begin(), textures_.end(), texture_id) !=
 227          textures_.end());
 228   textures_.erase(std::find(textures_.begin(), textures_.end(), texture_id));
 229 }
 230
 231 void TestWebGraphicsContext3D::attachShader(WebGLId program, WebGLId shader) {
 232   EXPECT_EQ(kProgramId | context_id_ << 16, program);
 233   EXPECT_EQ(kShaderId | context_id_ << 16, shader);
 234 }
 235
 236 void TestWebGraphicsContext3D::useProgram(WebGLId program) {
 237   if (!program)
 238     return;
 239   EXPECT_EQ(kProgramId | context_id_ << 16, program);
 240 }
 241
 242 void TestWebGraphicsContext3D::bindBuffer(WGC3Denum target, WebGLId buffer) {
 243   if (!buffer)
 244     return;
 245   EXPECT_EQ(kBufferId | context_id_ << 16, buffer);
 246 }
 247
 248 void TestWebGraphicsContext3D::bindFramebuffer(
 249     WGC3Denum target, WebGLId framebuffer) {
 250   if (!framebuffer)
 251     return;
 252   EXPECT_EQ(kFramebufferId | context_id_ << 16, framebuffer);
 253 }
 254
 255 void TestWebGraphicsContext3D::bindRenderbuffer(
 256       WGC3Denum target, WebGLId renderbuffer) {
 257   if (!renderbuffer)
 258     return;
 259   EXPECT_EQ(kRenderbufferId | context_id_ << 16, renderbuffer);
 260 }
 261
 262 void TestWebGraphicsContext3D::bindTexture(
 263     WGC3Denum target, WebGLId texture_id) {
 264   if (times_bind_texture_succeeds_ >= 0) {
 265     if (!times_bind_texture_succeeds_) {
 266       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 267                           GL_INNOCENT_CONTEXT_RESET_ARB);
 268     }
 269     --times_bind_texture_succeeds_;
 270   }
 271
 272   if (!texture_id)
 273     return;
 274   if (texture_id == kExternalTextureId)
 275     return;
 276   DCHECK(std::find(textures_.begin(), textures_.end(), texture_id) !=
 277          textures_.end());
 278   used_textures_.insert(texture_id);
 279 }
 280
 281 void TestWebGraphicsContext3D::endQueryEXT(WGC3Denum target) {
 282   if (times_end_query_succeeds_ >= 0) {
 283     if (!times_end_query_succeeds_) {
 284       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 285                           GL_INNOCENT_CONTEXT_RESET_ARB);
 286     }
 287     --times_end_query_succeeds_;
 288   }
 289 }
 290
 291 void TestWebGraphicsContext3D::getQueryObjectuivEXT(
 292     WebGLId query,
 293     WGC3Denum pname,
 294     WGC3Duint* params) {
 295   // If the context is lost, behave as if result is available.
 296   if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
 297     *params = 1;
 298 }
 299
 300 void TestWebGraphicsContext3D::getIntegerv(
 301     WGC3Denum pname,
 302     WebKit::WGC3Dint* value) {
 303   if (pname == GL_MAX_TEXTURE_SIZE)
 304     *value = max_texture_size_;
 305 }
 306
 307 void TestWebGraphicsContext3D::genMailboxCHROMIUM(WebKit::WGC3Dbyte* mailbox) {
 308   static char mailbox_name1 = '1';
 309   static char mailbox_name2 = '1';
 310   mailbox[0] = mailbox_name1;
 311   mailbox[1] = mailbox_name2;
 312   mailbox[2] = '\0';
 313   if (++mailbox_name1 == 0) {
 314     mailbox_name1 = '1';
 315     ++mailbox_name2;
 316   }
 317 }
 318
 319 void TestWebGraphicsContext3D::setContextLostCallback(
 320     WebGraphicsContextLostCallback* callback) {
 321   context_lost_callback_ = callback;
 322 }
 323
 324 void TestWebGraphicsContext3D::loseContextCHROMIUM(WGC3Denum current,
 325                                                    WGC3Denum other) {
 326   if (context_lost_)
 327     return;
 328   context_lost_ = true;
 329   if (context_lost_callback_)
 330     context_lost_callback_->onContextLost();
 331
 332   for (size_t i = 0; i < shared_contexts_.size(); ++i)
 333     shared_contexts_[i]->loseContextCHROMIUM(current, other);
 334   shared_contexts_.clear();
 335 }
 336
 337 WebGLId TestWebGraphicsContext3D::NextTextureId() {
 338   WebGLId texture_id = next_texture_id_++;
 339   DCHECK(texture_id < (1 << 16));
 340   texture_id |= context_id_ << 16;
 341   return texture_id;
 342 }
 343
 344 }  // namespace cc