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/bind.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop.h"
  13 #include "gpu/GLES2/gl2extchromium.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/khronos/GLES2/gl2ext.h"
  16
  17 using WebKit::WGC3Dboolean;
  18 using WebKit::WGC3Dchar;
  19 using WebKit::WGC3Denum;
  20 using WebKit::WGC3Dint;
  21 using WebKit::WGC3Dsizei;
  22 using WebKit::WGC3Dsizeiptr;
  23 using WebKit::WGC3Duint;
  24 using WebKit::WebGLId;
  25 using WebKit::WebGraphicsContext3D;
  26
  27 namespace cc {
  28
  29 static const WebGLId kFramebufferId = 1;
  30 static const WebGLId kProgramId = 2;
  31 static const WebGLId kRenderbufferId = 3;
  32 static const WebGLId kShaderId = 4;
  33
  34 static unsigned s_context_id = 1;
  35
  36 const WebGLId TestWebGraphicsContext3D::kExternalTextureId = 1337;
  37
  38 TestWebGraphicsContext3D::TestWebGraphicsContext3D()
  39     : FakeWebGraphicsContext3D(),
  40       context_id_(s_context_id++),
  41       next_buffer_id_(1),
  42       next_texture_id_(1),
  43       have_extension_io_surface_(false),
  44       have_extension_egl_image_(false),
  45       times_make_current_succeeds_(-1),
  46       times_bind_texture_succeeds_(-1),
  47       times_end_query_succeeds_(-1),
  48       context_lost_(false),
  49       context_lost_callback_(NULL),
  50       swap_buffers_callback_(NULL),
  51       max_texture_size_(1024),
  52       width_(0),
  53       height_(0),
  54       bound_buffer_(0),
  55       weak_ptr_factory_(this) {
  56 }
  57
  58 TestWebGraphicsContext3D::TestWebGraphicsContext3D(
  59     const WebGraphicsContext3D::Attributes& attributes)
  60     : FakeWebGraphicsContext3D(),
  61       context_id_(s_context_id++),
  62       next_buffer_id_(1),
  63       next_texture_id_(1),
  64       attributes_(attributes),
  65       have_extension_io_surface_(false),
  66       have_extension_egl_image_(false),
  67       times_make_current_succeeds_(-1),
  68       times_bind_texture_succeeds_(-1),
  69       times_end_query_succeeds_(-1),
  70       context_lost_(false),
  71       context_lost_callback_(NULL),
  72       swap_buffers_callback_(NULL),
  73       max_texture_size_(1024),
  74       width_(0),
  75       height_(0),
  76       bound_buffer_(0),
  77       weak_ptr_factory_(this) {
  78 }
  79
  80 TestWebGraphicsContext3D::~TestWebGraphicsContext3D() {
  81   for (size_t i = 0; i < sync_point_callbacks_.size(); ++i) {
  82     if (sync_point_callbacks_[i] != NULL)
  83       delete sync_point_callbacks_[i];
  84   }
  85 }
  86
  87 bool TestWebGraphicsContext3D::makeContextCurrent() {
  88   if (times_make_current_succeeds_ >= 0) {
  89     if (!times_make_current_succeeds_) {
  90       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
  91                           GL_INNOCENT_CONTEXT_RESET_ARB);
  92     }
  93     --times_make_current_succeeds_;
  94   }
  95   return !context_lost_;
  96 }
  97
  98 int TestWebGraphicsContext3D::width() {
  99   return width_;
 100 }
 101
 102 int TestWebGraphicsContext3D::height() {
 103   return height_;
 104 }
 105
 106 void TestWebGraphicsContext3D::reshapeWithScaleFactor(
 107     int width, int height, float scale_factor) {
 108   width_ = width;
 109   height_ = height;
 110 }
 111
 112 bool TestWebGraphicsContext3D::isContextLost() {
 113   return context_lost_;
 114 }
 115
 116 WGC3Denum TestWebGraphicsContext3D::getGraphicsResetStatusARB() {
 117   return context_lost_ ? GL_UNKNOWN_CONTEXT_RESET_ARB : GL_NO_ERROR;
 118 }
 119
 120 WGC3Denum TestWebGraphicsContext3D::checkFramebufferStatus(
 121     WGC3Denum target) {
 122   if (context_lost_)
 123     return GL_FRAMEBUFFER_UNDEFINED_OES;
 124   return GL_FRAMEBUFFER_COMPLETE;
 125 }
 126
 127 WebGraphicsContext3D::Attributes
 128     TestWebGraphicsContext3D::getContextAttributes() {
 129   return attributes_;
 130 }
 131
 132 WebKit::WebString TestWebGraphicsContext3D::getString(WGC3Denum name) {
 133   std::string string("GL_CHROMIUM_swapbuffers_complete_callback");
 134
 135   if (name == GL_EXTENSIONS) {
 136     if (have_extension_io_surface_)
 137       string += " GL_CHROMIUM_iosurface GL_ARB_texture_rectangle";
 138     if (have_extension_egl_image_)
 139       string += " GL_OES_EGL_image_external";
 140   }
 141
 142   return WebKit::WebString::fromUTF8(string.c_str());
 143 }
 144
 145 WGC3Dint TestWebGraphicsContext3D::getUniformLocation(
 146     WebGLId program,
 147     const WGC3Dchar* name) {
 148   return 0;
 149 }
 150
 151 WGC3Dsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset(
 152     WGC3Duint index,
 153     WGC3Denum pname) {
 154   return 0;
 155 }
 156
 157 WGC3Dboolean TestWebGraphicsContext3D::isBuffer(
 158     WebGLId buffer) {
 159   return false;
 160 }
 161
 162 WGC3Dboolean TestWebGraphicsContext3D::isEnabled(
 163     WGC3Denum cap) {
 164   return false;
 165 }
 166
 167 WGC3Dboolean TestWebGraphicsContext3D::isFramebuffer(
 168     WebGLId framebuffer) {
 169   return false;
 170 }
 171
 172 WGC3Dboolean TestWebGraphicsContext3D::isProgram(
 173     WebGLId program) {
 174   return false;
 175 }
 176
 177 WGC3Dboolean TestWebGraphicsContext3D::isRenderbuffer(
 178     WebGLId renderbuffer) {
 179   return false;
 180 }
 181
 182 WGC3Dboolean TestWebGraphicsContext3D::isShader(
 183     WebGLId shader) {
 184   return false;
 185 }
 186
 187 WGC3Dboolean TestWebGraphicsContext3D::isTexture(
 188     WebGLId texture) {
 189   return false;
 190 }
 191
 192 WebGLId TestWebGraphicsContext3D::createBuffer() {
 193   return NextBufferId();
 194 }
 195
 196 void TestWebGraphicsContext3D::deleteBuffer(WebGLId id) {
 197   unsigned context_id = id >> 17;
 198   unsigned buffer_id = id & 0x1ffff;
 199   DCHECK(buffer_id && buffer_id < next_buffer_id_);
 200   DCHECK_EQ(context_id, context_id_);
 201 }
 202
 203 WebGLId TestWebGraphicsContext3D::createFramebuffer() {
 204   return kFramebufferId | context_id_ << 16;
 205 }
 206
 207 void TestWebGraphicsContext3D::deleteFramebuffer(WebGLId id) {
 208   EXPECT_EQ(kFramebufferId | context_id_ << 16, id);
 209 }
 210
 211 WebGLId TestWebGraphicsContext3D::createProgram() {
 212   return kProgramId | context_id_ << 16;
 213 }
 214
 215 void TestWebGraphicsContext3D::deleteProgram(WebGLId id) {
 216   EXPECT_EQ(kProgramId | context_id_ << 16, id);
 217 }
 218
 219 WebGLId TestWebGraphicsContext3D::createRenderbuffer() {
 220   return kRenderbufferId | context_id_ << 16;
 221 }
 222
 223 void TestWebGraphicsContext3D::deleteRenderbuffer(WebGLId id) {
 224   EXPECT_EQ(kRenderbufferId | context_id_ << 16, id);
 225 }
 226
 227 WebGLId TestWebGraphicsContext3D::createShader(WGC3Denum) {
 228   return kShaderId | context_id_ << 16;
 229 }
 230
 231 void TestWebGraphicsContext3D::deleteShader(WebGLId id) {
 232   EXPECT_EQ(kShaderId | context_id_ << 16, id);
 233 }
 234
 235 WebGLId TestWebGraphicsContext3D::createTexture() {
 236   WebGLId texture_id = NextTextureId();
 237   DCHECK_NE(texture_id, kExternalTextureId);
 238   textures_.push_back(texture_id);
 239   return texture_id;
 240 }
 241
 242 void TestWebGraphicsContext3D::deleteTexture(WebGLId texture_id) {
 243   DCHECK(std::find(textures_.begin(), textures_.end(), texture_id) !=
 244          textures_.end());
 245   textures_.erase(std::find(textures_.begin(), textures_.end(), texture_id));
 246 }
 247
 248 void TestWebGraphicsContext3D::attachShader(WebGLId program, WebGLId shader) {
 249   EXPECT_EQ(kProgramId | context_id_ << 16, program);
 250   EXPECT_EQ(kShaderId | context_id_ << 16, shader);
 251 }
 252
 253 void TestWebGraphicsContext3D::useProgram(WebGLId program) {
 254   if (!program)
 255     return;
 256   EXPECT_EQ(kProgramId | context_id_ << 16, program);
 257 }
 258
 259 void TestWebGraphicsContext3D::bindFramebuffer(
 260     WGC3Denum target, WebGLId framebuffer) {
 261   if (!framebuffer)
 262     return;
 263   EXPECT_EQ(kFramebufferId | context_id_ << 16, framebuffer);
 264 }
 265
 266 void TestWebGraphicsContext3D::bindRenderbuffer(
 267       WGC3Denum target, WebGLId renderbuffer) {
 268   if (!renderbuffer)
 269     return;
 270   EXPECT_EQ(kRenderbufferId | context_id_ << 16, renderbuffer);
 271 }
 272
 273 void TestWebGraphicsContext3D::bindTexture(
 274     WGC3Denum target, WebGLId texture_id) {
 275   if (times_bind_texture_succeeds_ >= 0) {
 276     if (!times_bind_texture_succeeds_) {
 277       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 278                           GL_INNOCENT_CONTEXT_RESET_ARB);
 279     }
 280     --times_bind_texture_succeeds_;
 281   }
 282
 283   if (!texture_id)
 284     return;
 285   if (texture_id == kExternalTextureId)
 286     return;
 287   DCHECK(std::find(textures_.begin(), textures_.end(), texture_id) !=
 288          textures_.end());
 289   used_textures_.insert(texture_id);
 290 }
 291
 292 void TestWebGraphicsContext3D::endQueryEXT(WGC3Denum target) {
 293   if (times_end_query_succeeds_ >= 0) {
 294     if (!times_end_query_succeeds_) {
 295       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 296                           GL_INNOCENT_CONTEXT_RESET_ARB);
 297     }
 298     --times_end_query_succeeds_;
 299   }
 300 }
 301
 302 void TestWebGraphicsContext3D::getQueryObjectuivEXT(
 303     WebGLId query,
 304     WGC3Denum pname,
 305     WGC3Duint* params) {
 306   // If the context is lost, behave as if result is available.
 307   if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
 308     *params = 1;
 309 }
 310
 311 void TestWebGraphicsContext3D::getIntegerv(
 312     WGC3Denum pname,
 313     WebKit::WGC3Dint* value) {
 314   if (pname == GL_MAX_TEXTURE_SIZE)
 315     *value = max_texture_size_;
 316 }
 317
 318 void TestWebGraphicsContext3D::genMailboxCHROMIUM(WebKit::WGC3Dbyte* mailbox) {
 319   static char mailbox_name1 = '1';
 320   static char mailbox_name2 = '1';
 321   mailbox[0] = mailbox_name1;
 322   mailbox[1] = mailbox_name2;
 323   mailbox[2] = '\0';
 324   if (++mailbox_name1 == 0) {
 325     mailbox_name1 = '1';
 326     ++mailbox_name2;
 327   }
 328 }
 329
 330 void TestWebGraphicsContext3D::setContextLostCallback(
 331     WebGraphicsContextLostCallback* callback) {
 332   context_lost_callback_ = callback;
 333 }
 334
 335 void TestWebGraphicsContext3D::loseContextCHROMIUM(WGC3Denum current,
 336                                                    WGC3Denum other) {
 337   if (context_lost_)
 338     return;
 339   context_lost_ = true;
 340   if (context_lost_callback_)
 341     context_lost_callback_->onContextLost();
 342
 343   for (size_t i = 0; i < shared_contexts_.size(); ++i)
 344     shared_contexts_[i]->loseContextCHROMIUM(current, other);
 345   shared_contexts_.clear();
 346 }
 347
 348 void TestWebGraphicsContext3D::signalSyncPoint(
 349     unsigned sync_point,
 350     WebGraphicsSyncPointCallback* callback) {
 351   sync_point_callbacks_.push_back(callback);
 352 }
 353
 354 void TestWebGraphicsContext3D::setSwapBuffersCompleteCallbackCHROMIUM(
 355     WebGraphicsSwapBuffersCompleteCallbackCHROMIUM* callback) {
 356   swap_buffers_callback_ = callback;
 357 }
 358
 359 void TestWebGraphicsContext3D::prepareTexture() {
 360   if (swap_buffers_callback_) {
 361     base::MessageLoop::current()->PostTask(
 362         FROM_HERE, base::Bind(&TestWebGraphicsContext3D::SwapBuffersComplete,
 363                               weak_ptr_factory_.GetWeakPtr()));
 364   }
 365   CallAllSyncPointCallbacks();
 366 }
 367
 368 void TestWebGraphicsContext3D::finish() {
 369   CallAllSyncPointCallbacks();
 370 }
 371
 372 void TestWebGraphicsContext3D::flush() {
 373   CallAllSyncPointCallbacks();
 374 }
 375
 376 static void CallAndDestroy(
 377     WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback* callback) {
 378   if (!callback)
 379     return;
 380   callback->onSyncPointReached();
 381   delete callback;
 382 }
 383
 384 void TestWebGraphicsContext3D::CallAllSyncPointCallbacks() {
 385   for (size_t i = 0; i < sync_point_callbacks_.size(); ++i) {
 386     base::MessageLoop::current()->PostTask(
 387         FROM_HERE,
 388         base::Bind(&CallAndDestroy,
 389                    sync_point_callbacks_[i]));
 390   }
 391   sync_point_callbacks_.clear();
 392 }
 393
 394 void TestWebGraphicsContext3D::SwapBuffersComplete() {
 395   if (swap_buffers_callback_)
 396     swap_buffers_callback_->onSwapBuffersComplete();
 397 }
 398
 399 void TestWebGraphicsContext3D::bindBuffer(WebKit::WGC3Denum target,
 400                                           WebKit::WebGLId buffer) {
 401   bound_buffer_ = buffer;
 402   if (!bound_buffer_)
 403     return;
 404   unsigned context_id = buffer >> 17;
 405   unsigned buffer_id = buffer & 0x1ffff;
 406   DCHECK(buffer_id && buffer_id < next_buffer_id_);
 407   DCHECK_EQ(context_id, context_id_);
 408
 409   if (buffers_.count(bound_buffer_) == 0)
 410     buffers_.set(bound_buffer_, make_scoped_ptr(new Buffer).Pass());
 411
 412   buffers_.get(bound_buffer_)->target = target;
 413 }
 414
 415 void TestWebGraphicsContext3D::bufferData(WebKit::WGC3Denum target,
 416                                           WebKit::WGC3Dsizeiptr size,
 417                                           const void* data,
 418                                           WebKit::WGC3Denum usage) {
 419   DCHECK_GT(buffers_.count(bound_buffer_), 0u);
 420   DCHECK_EQ(target, buffers_.get(bound_buffer_)->target);
 421   if (context_lost_) {
 422     buffers_.get(bound_buffer_)->pixels.reset();
 423     return;
 424   }
 425   buffers_.get(bound_buffer_)->pixels.reset(new uint8[size]);
 426   if (data != NULL)
 427     memcpy(buffers_.get(bound_buffer_)->pixels.get(), data, size);
 428 }
 429
 430 void* TestWebGraphicsContext3D::mapBufferCHROMIUM(WebKit::WGC3Denum target,
 431                                                   WebKit::WGC3Denum access) {
 432   DCHECK_GT(buffers_.count(bound_buffer_), 0u);
 433   DCHECK_EQ(target, buffers_.get(bound_buffer_)->target);
 434   return buffers_.get(bound_buffer_)->pixels.get();
 435 }
 436
 437 WebKit::WGC3Dboolean TestWebGraphicsContext3D::unmapBufferCHROMIUM(
 438     WebKit::WGC3Denum target) {
 439   DCHECK_GT(buffers_.count(bound_buffer_), 0u);
 440   DCHECK_EQ(target, buffers_.get(bound_buffer_)->target);
 441   buffers_.get(bound_buffer_)->pixels.reset();
 442   return true;
 443 }
 444
 445 WebGLId TestWebGraphicsContext3D::NextTextureId() {
 446   WebGLId texture_id = next_texture_id_++;
 447   DCHECK(texture_id < (1 << 16));
 448   texture_id |= context_id_ << 16;
 449   return texture_id;
 450 }
 451
 452 WebGLId TestWebGraphicsContext3D::NextBufferId() {
 453   WebGLId buffer_id = next_buffer_id_++;
 454   DCHECK(buffer_id < (1 << 17));
 455   buffer_id |= context_id_ << 17;
 456   return buffer_id;
 457 }
 458
 459 TestWebGraphicsContext3D::Buffer::Buffer() : target(0) {}
 460
 461 TestWebGraphicsContext3D::Buffer::~Buffer() {}
 462
 463 }  // namespace cc