| OLD | NEW |
|---|
| (Empty) |
| 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 #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/lazy_instance.h" | |
| 12 #include "base/logging.h" | |
| 13 #include "base/message_loop/message_loop.h" | |
| 14 #include "cc/test/test_context_support.h" | |
| 15 #include "gpu/GLES2/gl2extchromium.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 #include "third_party/khronos/GLES2/gl2ext.h" | |
| 18 | |
| 19 namespace cc { | |
| 20 | |
| 21 static unsigned s_context_id = 1; | |
| 22 | |
| 23 const GLuint TestWebGraphicsContext3D::kExternalTextureId = 1337; | |
| 24 | |
| 25 static base::LazyInstance<base::Lock>::Leaky | |
| 26 g_shared_namespace_lock = LAZY_INSTANCE_INITIALIZER; | |
| 27 | |
| 28 TestWebGraphicsContext3D::Namespace* | |
| 29 TestWebGraphicsContext3D::shared_namespace_ = NULL; | |
| 30 | |
| 31 TestWebGraphicsContext3D::Namespace::Namespace() | |
| 32 : next_buffer_id(1), | |
| 33 next_image_id(1), | |
| 34 next_texture_id(1), | |
| 35 next_renderbuffer_id(1) { | |
| 36 } | |
| 37 | |
| 38 TestWebGraphicsContext3D::Namespace::~Namespace() { | |
| 39 g_shared_namespace_lock.Get().AssertAcquired(); | |
| 40 if (shared_namespace_ == this) | |
| 41 shared_namespace_ = NULL; | |
| 42 } | |
| 43 | |
| 44 // static | |
| 45 scoped_ptr<TestWebGraphicsContext3D> TestWebGraphicsContext3D::Create() { | |
| 46 return make_scoped_ptr(new TestWebGraphicsContext3D()); | |
| 47 } | |
| 48 | |
| 49 TestWebGraphicsContext3D::TestWebGraphicsContext3D() | |
| 50 : context_id_(s_context_id++), | |
| 51 times_bind_texture_succeeds_(-1), | |
| 52 times_end_query_succeeds_(-1), | |
| 53 context_lost_(false), | |
| 54 times_map_buffer_chromium_succeeds_(-1), | |
| 55 current_used_transfer_buffer_usage_bytes_(0), | |
| 56 max_used_transfer_buffer_usage_bytes_(0), | |
| 57 next_program_id_(1000), | |
| 58 next_shader_id_(2000), | |
| 59 next_framebuffer_id_(1), | |
| 60 current_framebuffer_(0), | |
| 61 max_texture_size_(2048), | |
| 62 reshape_called_(false), | |
| 63 width_(0), | |
| 64 height_(0), | |
| 65 scale_factor_(-1.f), | |
| 66 test_support_(NULL), | |
| 67 last_update_type_(NO_UPDATE), | |
| 68 next_insert_sync_point_(1), | |
| 69 last_waited_sync_point_(0), | |
| 70 unpack_alignment_(4), | |
| 71 bound_buffer_(0), | |
| 72 weak_ptr_factory_(this) { | |
| 73 CreateNamespace(); | |
| 74 set_support_image(true); | |
| 75 } | |
| 76 | |
| 77 TestWebGraphicsContext3D::~TestWebGraphicsContext3D() { | |
| 78 base::AutoLock lock(g_shared_namespace_lock.Get()); | |
| 79 namespace_ = NULL; | |
| 80 } | |
| 81 | |
| 82 void TestWebGraphicsContext3D::CreateNamespace() { | |
| 83 base::AutoLock lock(g_shared_namespace_lock.Get()); | |
| 84 if (shared_namespace_) { | |
| 85 namespace_ = shared_namespace_; | |
| 86 } else { | |
| 87 namespace_ = new Namespace; | |
| 88 shared_namespace_ = namespace_.get(); | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 void TestWebGraphicsContext3D::reshapeWithScaleFactor( | |
| 93 int width, int height, float scale_factor) { | |
| 94 reshape_called_ = true; | |
| 95 width_ = width; | |
| 96 height_ = height; | |
| 97 scale_factor_ = scale_factor; | |
| 98 } | |
| 99 | |
| 100 bool TestWebGraphicsContext3D::isContextLost() { | |
| 101 return context_lost_; | |
| 102 } | |
| 103 | |
| 104 GLenum TestWebGraphicsContext3D::checkFramebufferStatus( | |
| 105 GLenum target) { | |
| 106 if (context_lost_) | |
| 107 return GL_FRAMEBUFFER_UNDEFINED_OES; | |
| 108 return GL_FRAMEBUFFER_COMPLETE; | |
| 109 } | |
| 110 | |
| 111 GLint TestWebGraphicsContext3D::getUniformLocation( | |
| 112 GLuint program, | |
| 113 const GLchar* name) { | |
| 114 return 0; | |
| 115 } | |
| 116 | |
| 117 GLsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset( | |
| 118 GLuint index, | |
| 119 GLenum pname) { | |
| 120 return 0; | |
| 121 } | |
| 122 | |
| 123 GLboolean TestWebGraphicsContext3D::isBuffer( | |
| 124 GLuint buffer) { | |
| 125 return false; | |
| 126 } | |
| 127 | |
| 128 GLboolean TestWebGraphicsContext3D::isEnabled( | |
| 129 GLenum cap) { | |
| 130 return false; | |
| 131 } | |
| 132 | |
| 133 GLboolean TestWebGraphicsContext3D::isFramebuffer( | |
| 134 GLuint framebuffer) { | |
| 135 return false; | |
| 136 } | |
| 137 | |
| 138 GLboolean TestWebGraphicsContext3D::isProgram( | |
| 139 GLuint program) { | |
| 140 return false; | |
| 141 } | |
| 142 | |
| 143 GLboolean TestWebGraphicsContext3D::isRenderbuffer( | |
| 144 GLuint renderbuffer) { | |
| 145 return false; | |
| 146 } | |
| 147 | |
| 148 GLboolean TestWebGraphicsContext3D::isShader( | |
| 149 GLuint shader) { | |
| 150 return false; | |
| 151 } | |
| 152 | |
| 153 GLboolean TestWebGraphicsContext3D::isTexture( | |
| 154 GLuint texture) { | |
| 155 return false; | |
| 156 } | |
| 157 | |
| 158 void TestWebGraphicsContext3D::genBuffers(GLsizei count, GLuint* ids) { | |
| 159 for (int i = 0; i < count; ++i) | |
| 160 ids[i] = NextBufferId(); | |
| 161 } | |
| 162 | |
| 163 void TestWebGraphicsContext3D::genFramebuffers( | |
| 164 GLsizei count, GLuint* ids) { | |
| 165 for (int i = 0; i < count; ++i) | |
| 166 ids[i] = NextFramebufferId(); | |
| 167 } | |
| 168 | |
| 169 void TestWebGraphicsContext3D::genRenderbuffers( | |
| 170 GLsizei count, GLuint* ids) { | |
| 171 for (int i = 0; i < count; ++i) | |
| 172 ids[i] = NextRenderbufferId(); | |
| 173 } | |
| 174 | |
| 175 void TestWebGraphicsContext3D::genTextures(GLsizei count, GLuint* ids) { | |
| 176 for (int i = 0; i < count; ++i) { | |
| 177 ids[i] = NextTextureId(); | |
| 178 DCHECK_NE(ids[i], kExternalTextureId); | |
| 179 } | |
| 180 base::AutoLock lock(namespace_->lock); | |
| 181 for (int i = 0; i < count; ++i) | |
| 182 namespace_->textures.Append(ids[i], new TestTexture()); | |
| 183 } | |
| 184 | |
| 185 void TestWebGraphicsContext3D::deleteBuffers(GLsizei count, GLuint* ids) { | |
| 186 for (int i = 0; i < count; ++i) | |
| 187 RetireBufferId(ids[i]); | |
| 188 } | |
| 189 | |
| 190 void TestWebGraphicsContext3D::deleteFramebuffers( | |
| 191 GLsizei count, GLuint* ids) { | |
| 192 for (int i = 0; i < count; ++i) { | |
| 193 if (ids[i]) { | |
| 194 RetireFramebufferId(ids[i]); | |
| 195 if (ids[i] == current_framebuffer_) | |
| 196 current_framebuffer_ = 0; | |
| 197 } | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 void TestWebGraphicsContext3D::deleteRenderbuffers( | |
| 202 GLsizei count, GLuint* ids) { | |
| 203 for (int i = 0; i < count; ++i) | |
| 204 RetireRenderbufferId(ids[i]); | |
| 205 } | |
| 206 | |
| 207 void TestWebGraphicsContext3D::deleteTextures(GLsizei count, GLuint* ids) { | |
| 208 for (int i = 0; i < count; ++i) | |
| 209 RetireTextureId(ids[i]); | |
| 210 base::AutoLock lock(namespace_->lock); | |
| 211 for (int i = 0; i < count; ++i) { | |
| 212 namespace_->textures.Remove(ids[i]); | |
| 213 texture_targets_.UnbindTexture(ids[i]); | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 GLuint TestWebGraphicsContext3D::createBuffer() { | |
| 218 GLuint id; | |
| 219 genBuffers(1, &id); | |
| 220 return id; | |
| 221 } | |
| 222 | |
| 223 GLuint TestWebGraphicsContext3D::createFramebuffer() { | |
| 224 GLuint id; | |
| 225 genFramebuffers(1, &id); | |
| 226 return id; | |
| 227 } | |
| 228 | |
| 229 GLuint TestWebGraphicsContext3D::createRenderbuffer() { | |
| 230 GLuint id; | |
| 231 genRenderbuffers(1, &id); | |
| 232 return id; | |
| 233 } | |
| 234 | |
| 235 GLuint TestWebGraphicsContext3D::createTexture() { | |
| 236 GLuint id; | |
| 237 genTextures(1, &id); | |
| 238 return id; | |
| 239 } | |
| 240 | |
| 241 void TestWebGraphicsContext3D::deleteBuffer(GLuint id) { | |
| 242 deleteBuffers(1, &id); | |
| 243 } | |
| 244 | |
| 245 void TestWebGraphicsContext3D::deleteFramebuffer(GLuint id) { | |
| 246 deleteFramebuffers(1, &id); | |
| 247 } | |
| 248 | |
| 249 void TestWebGraphicsContext3D::deleteRenderbuffer(GLuint id) { | |
| 250 deleteRenderbuffers(1, &id); | |
| 251 } | |
| 252 | |
| 253 void TestWebGraphicsContext3D::deleteTexture(GLuint id) { | |
| 254 deleteTextures(1, &id); | |
| 255 } | |
| 256 | |
| 257 unsigned TestWebGraphicsContext3D::createProgram() { | |
| 258 unsigned program = next_program_id_++ | context_id_ << 16; | |
| 259 program_set_.insert(program); | |
| 260 return program; | |
| 261 } | |
| 262 | |
| 263 GLuint TestWebGraphicsContext3D::createShader(GLenum) { | |
| 264 unsigned shader = next_shader_id_++ | context_id_ << 16; | |
| 265 shader_set_.insert(shader); | |
| 266 return shader; | |
| 267 } | |
| 268 | |
| 269 GLuint TestWebGraphicsContext3D::createExternalTexture() { | |
| 270 base::AutoLock lock(namespace_->lock); | |
| 271 namespace_->textures.Append(kExternalTextureId, new TestTexture()); | |
| 272 return kExternalTextureId; | |
| 273 } | |
| 274 | |
| 275 void TestWebGraphicsContext3D::deleteProgram(GLuint id) { | |
| 276 if (!program_set_.count(id)) | |
| 277 ADD_FAILURE() << "deleteProgram called on unknown program " << id; | |
| 278 program_set_.erase(id); | |
| 279 } | |
| 280 | |
| 281 void TestWebGraphicsContext3D::deleteShader(GLuint id) { | |
| 282 if (!shader_set_.count(id)) | |
| 283 ADD_FAILURE() << "deleteShader called on unknown shader " << id; | |
| 284 shader_set_.erase(id); | |
| 285 } | |
| 286 | |
| 287 void TestWebGraphicsContext3D::attachShader(GLuint program, GLuint shader) { | |
| 288 if (!program_set_.count(program)) | |
| 289 ADD_FAILURE() << "attachShader called with unknown program " << program; | |
| 290 if (!shader_set_.count(shader)) | |
| 291 ADD_FAILURE() << "attachShader called with unknown shader " << shader; | |
| 292 } | |
| 293 | |
| 294 void TestWebGraphicsContext3D::useProgram(GLuint program) { | |
| 295 if (!program) | |
| 296 return; | |
| 297 if (!program_set_.count(program)) | |
| 298 ADD_FAILURE() << "useProgram called on unknown program " << program; | |
| 299 } | |
| 300 | |
| 301 void TestWebGraphicsContext3D::bindFramebuffer( | |
| 302 GLenum target, GLuint framebuffer) { | |
| 303 base::AutoLock lock_for_framebuffer_access(namespace_->lock); | |
| 304 if (framebuffer != 0 && | |
| 305 framebuffer_set_.find(framebuffer) == framebuffer_set_.end()) { | |
| 306 ADD_FAILURE() << "bindFramebuffer called with unknown framebuffer"; | |
| 307 } else if (framebuffer != 0 && (framebuffer >> 16) != context_id_) { | |
| 308 ADD_FAILURE() | |
| 309 << "bindFramebuffer called with framebuffer from other context"; | |
| 310 } else { | |
| 311 current_framebuffer_ = framebuffer; | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 void TestWebGraphicsContext3D::bindRenderbuffer( | |
| 316 GLenum target, GLuint renderbuffer) { | |
| 317 if (!renderbuffer) | |
| 318 return; | |
| 319 base::AutoLock lock_for_renderbuffer_access(namespace_->lock); | |
| 320 if (renderbuffer != 0 && | |
| 321 namespace_->renderbuffer_set.find(renderbuffer) == | |
| 322 namespace_->renderbuffer_set.end()) { | |
| 323 ADD_FAILURE() << "bindRenderbuffer called with unknown renderbuffer"; | |
| 324 } else if ((renderbuffer >> 16) != context_id_) { | |
| 325 ADD_FAILURE() | |
| 326 << "bindRenderbuffer called with renderbuffer from other context"; | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 void TestWebGraphicsContext3D::bindTexture( | |
| 331 GLenum target, GLuint texture_id) { | |
| 332 if (times_bind_texture_succeeds_ >= 0) { | |
| 333 if (!times_bind_texture_succeeds_) { | |
| 334 loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB, | |
| 335 GL_INNOCENT_CONTEXT_RESET_ARB); | |
| 336 } | |
| 337 --times_bind_texture_succeeds_; | |
| 338 } | |
| 339 | |
| 340 if (!texture_id) | |
| 341 return; | |
| 342 base::AutoLock lock(namespace_->lock); | |
| 343 DCHECK(namespace_->textures.ContainsId(texture_id)); | |
| 344 texture_targets_.BindTexture(target, texture_id); | |
| 345 used_textures_.insert(texture_id); | |
| 346 } | |
| 347 | |
| 348 GLuint TestWebGraphicsContext3D::BoundTextureId( | |
| 349 GLenum target) { | |
| 350 return texture_targets_.BoundTexture(target); | |
| 351 } | |
| 352 | |
| 353 scoped_refptr<TestTexture> TestWebGraphicsContext3D::BoundTexture( | |
| 354 GLenum target) { | |
| 355 // The caller is expected to lock the namespace for texture access. | |
| 356 namespace_->lock.AssertAcquired(); | |
| 357 return namespace_->textures.TextureForId(BoundTextureId(target)); | |
| 358 } | |
| 359 | |
| 360 scoped_refptr<TestTexture> TestWebGraphicsContext3D::UnboundTexture( | |
| 361 GLuint texture) { | |
| 362 // The caller is expected to lock the namespace for texture access. | |
| 363 namespace_->lock.AssertAcquired(); | |
| 364 return namespace_->textures.TextureForId(texture); | |
| 365 } | |
| 366 | |
| 367 void TestWebGraphicsContext3D::CheckTextureIsBound(GLenum target) { | |
| 368 DCHECK(BoundTextureId(target)); | |
| 369 } | |
| 370 | |
| 371 GLuint TestWebGraphicsContext3D::createQueryEXT() { return 1u; } | |
| 372 | |
| 373 void TestWebGraphicsContext3D::endQueryEXT(GLenum target) { | |
| 374 if (times_end_query_succeeds_ >= 0) { | |
| 375 if (!times_end_query_succeeds_) { | |
| 376 loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB, | |
| 377 GL_INNOCENT_CONTEXT_RESET_ARB); | |
| 378 } | |
| 379 --times_end_query_succeeds_; | |
| 380 } | |
| 381 } | |
| 382 | |
| 383 void TestWebGraphicsContext3D::getQueryObjectuivEXT( | |
| 384 GLuint query, | |
| 385 GLenum pname, | |
| 386 GLuint* params) { | |
| 387 // If the context is lost, behave as if result is available. | |
| 388 if (pname == GL_QUERY_RESULT_AVAILABLE_EXT) | |
| 389 *params = 1; | |
| 390 } | |
| 391 | |
| 392 void TestWebGraphicsContext3D::getIntegerv( | |
| 393 GLenum pname, | |
| 394 GLint* value) { | |
| 395 if (pname == GL_MAX_TEXTURE_SIZE) | |
| 396 *value = max_texture_size_; | |
| 397 else if (pname == GL_ACTIVE_TEXTURE) | |
| 398 *value = GL_TEXTURE0; | |
| 399 else if (pname == GL_UNPACK_ALIGNMENT) | |
| 400 *value = unpack_alignment_; | |
| 401 else if (pname == GL_FRAMEBUFFER_BINDING) | |
| 402 *value = current_framebuffer_; | |
| 403 } | |
| 404 | |
| 405 void TestWebGraphicsContext3D::getProgramiv(GLuint program, | |
| 406 GLenum pname, | |
| 407 GLint* value) { | |
| 408 if (pname == GL_LINK_STATUS) | |
| 409 *value = 1; | |
| 410 } | |
| 411 | |
| 412 void TestWebGraphicsContext3D::getShaderiv(GLuint shader, | |
| 413 GLenum pname, | |
| 414 GLint* value) { | |
| 415 if (pname == GL_COMPILE_STATUS) | |
| 416 *value = 1; | |
| 417 } | |
| 418 | |
| 419 void TestWebGraphicsContext3D::getShaderPrecisionFormat(GLenum shadertype, | |
| 420 GLenum precisiontype, | |
| 421 GLint* range, | |
| 422 GLint* precision) { | |
| 423 // Return the minimum precision requirements of the GLES2 | |
| 424 // specification. | |
| 425 switch (precisiontype) { | |
| 426 case GL_LOW_INT: | |
| 427 range[0] = 8; | |
| 428 range[1] = 8; | |
| 429 *precision = 0; | |
| 430 break; | |
| 431 case GL_MEDIUM_INT: | |
| 432 range[0] = 10; | |
| 433 range[1] = 10; | |
| 434 *precision = 0; | |
| 435 break; | |
| 436 case GL_HIGH_INT: | |
| 437 range[0] = 16; | |
| 438 range[1] = 16; | |
| 439 *precision = 0; | |
| 440 break; | |
| 441 case GL_LOW_FLOAT: | |
| 442 range[0] = 8; | |
| 443 range[1] = 8; | |
| 444 *precision = 8; | |
| 445 break; | |
| 446 case GL_MEDIUM_FLOAT: | |
| 447 range[0] = 14; | |
| 448 range[1] = 14; | |
| 449 *precision = 10; | |
| 450 break; | |
| 451 case GL_HIGH_FLOAT: | |
| 452 range[0] = 62; | |
| 453 range[1] = 62; | |
| 454 *precision = 16; | |
| 455 break; | |
| 456 default: | |
| 457 NOTREACHED(); | |
| 458 break; | |
| 459 } | |
| 460 } | |
| 461 | |
| 462 void TestWebGraphicsContext3D::genMailboxCHROMIUM(GLbyte* mailbox) { | |
| 463 static char mailbox_name1 = '1'; | |
| 464 static char mailbox_name2 = '1'; | |
| 465 mailbox[0] = mailbox_name1; | |
| 466 mailbox[1] = mailbox_name2; | |
| 467 mailbox[2] = '\0'; | |
| 468 if (++mailbox_name1 == 0) { | |
| 469 mailbox_name1 = '1'; | |
| 470 ++mailbox_name2; | |
| 471 } | |
| 472 } | |
| 473 | |
| 474 GLuint TestWebGraphicsContext3D::createAndConsumeTextureCHROMIUM( | |
| 475 GLenum target, | |
| 476 const GLbyte* mailbox) { | |
| 477 GLuint texture_id = createTexture(); | |
| 478 consumeTextureCHROMIUM(target, mailbox); | |
| 479 return texture_id; | |
| 480 } | |
| 481 | |
| 482 void TestWebGraphicsContext3D::loseContextCHROMIUM(GLenum current, | |
| 483 GLenum other) { | |
| 484 if (context_lost_) | |
| 485 return; | |
| 486 context_lost_ = true; | |
| 487 if (!context_lost_callback_.is_null()) | |
| 488 context_lost_callback_.Run(); | |
| 489 | |
| 490 for (size_t i = 0; i < shared_contexts_.size(); ++i) | |
| 491 shared_contexts_[i]->loseContextCHROMIUM(current, other); | |
| 492 shared_contexts_.clear(); | |
| 493 } | |
| 494 | |
| 495 void TestWebGraphicsContext3D::finish() { | |
| 496 test_support_->CallAllSyncPointCallbacks(); | |
| 497 } | |
| 498 | |
| 499 void TestWebGraphicsContext3D::flush() { | |
| 500 test_support_->CallAllSyncPointCallbacks(); | |
| 501 } | |
| 502 | |
| 503 GLint TestWebGraphicsContext3D::getAttribLocation(GLuint program, | |
| 504 const GLchar* name) { | |
| 505 return 0; | |
| 506 } | |
| 507 | |
| 508 GLenum TestWebGraphicsContext3D::getError() { return GL_NO_ERROR; } | |
| 509 | |
| 510 void TestWebGraphicsContext3D::bindBuffer(GLenum target, | |
| 511 GLuint buffer) { | |
| 512 bound_buffer_ = buffer; | |
| 513 if (!bound_buffer_) | |
| 514 return; | |
| 515 unsigned context_id = buffer >> 16; | |
| 516 unsigned buffer_id = buffer & 0xffff; | |
| 517 base::AutoLock lock(namespace_->lock); | |
| 518 DCHECK(buffer_id); | |
| 519 DCHECK_LT(buffer_id, namespace_->next_buffer_id); | |
| 520 DCHECK_EQ(context_id, context_id_); | |
| 521 | |
| 522 base::ScopedPtrHashMap<unsigned, Buffer>& buffers = namespace_->buffers; | |
| 523 if (buffers.count(bound_buffer_) == 0) | |
| 524 buffers.set(bound_buffer_, make_scoped_ptr(new Buffer).Pass()); | |
| 525 | |
| 526 buffers.get(bound_buffer_)->target = target; | |
| 527 } | |
| 528 | |
| 529 void TestWebGraphicsContext3D::bufferData(GLenum target, | |
| 530 GLsizeiptr size, | |
| 531 const void* data, | |
| 532 GLenum usage) { | |
| 533 base::AutoLock lock(namespace_->lock); | |
| 534 base::ScopedPtrHashMap<unsigned, Buffer>& buffers = namespace_->buffers; | |
| 535 DCHECK_GT(buffers.count(bound_buffer_), 0u); | |
| 536 DCHECK_EQ(target, buffers.get(bound_buffer_)->target); | |
| 537 Buffer* buffer = buffers.get(bound_buffer_); | |
| 538 if (context_lost_) { | |
| 539 buffer->pixels = nullptr; | |
| 540 return; | |
| 541 } | |
| 542 | |
| 543 size_t old_size = buffer->size; | |
| 544 | |
| 545 buffer->pixels.reset(new uint8[size]); | |
| 546 buffer->size = size; | |
| 547 if (data != NULL) | |
| 548 memcpy(buffer->pixels.get(), data, size); | |
| 549 if (buffer->target == GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM) | |
| 550 current_used_transfer_buffer_usage_bytes_ += buffer->size - old_size; | |
| 551 max_used_transfer_buffer_usage_bytes_ = | |
| 552 std::max(max_used_transfer_buffer_usage_bytes_, | |
| 553 current_used_transfer_buffer_usage_bytes_); | |
| 554 } | |
| 555 | |
| 556 void TestWebGraphicsContext3D::pixelStorei(GLenum pname, GLint param) { | |
| 557 switch (pname) { | |
| 558 case GL_UNPACK_ALIGNMENT: | |
| 559 // Param should be a power of two <= 8. | |
| 560 EXPECT_EQ(0, param & (param - 1)); | |
| 561 EXPECT_GE(8, param); | |
| 562 switch (param) { | |
| 563 case 1: | |
| 564 case 2: | |
| 565 case 4: | |
| 566 case 8: | |
| 567 unpack_alignment_ = param; | |
| 568 break; | |
| 569 default: | |
| 570 break; | |
| 571 } | |
| 572 break; | |
| 573 default: | |
| 574 break; | |
| 575 } | |
| 576 } | |
| 577 | |
| 578 void* TestWebGraphicsContext3D::mapBufferCHROMIUM(GLenum target, | |
| 579 GLenum access) { | |
| 580 base::AutoLock lock(namespace_->lock); | |
| 581 base::ScopedPtrHashMap<unsigned, Buffer>& buffers = namespace_->buffers; | |
| 582 DCHECK_GT(buffers.count(bound_buffer_), 0u); | |
| 583 DCHECK_EQ(target, buffers.get(bound_buffer_)->target); | |
| 584 if (times_map_buffer_chromium_succeeds_ >= 0) { | |
| 585 if (!times_map_buffer_chromium_succeeds_) { | |
| 586 return NULL; | |
| 587 } | |
| 588 --times_map_buffer_chromium_succeeds_; | |
| 589 } | |
| 590 | |
| 591 return buffers.get(bound_buffer_)->pixels.get(); | |
| 592 } | |
| 593 | |
| 594 GLboolean TestWebGraphicsContext3D::unmapBufferCHROMIUM( | |
| 595 GLenum target) { | |
| 596 base::AutoLock lock(namespace_->lock); | |
| 597 base::ScopedPtrHashMap<unsigned, Buffer>& buffers = namespace_->buffers; | |
| 598 DCHECK_GT(buffers.count(bound_buffer_), 0u); | |
| 599 DCHECK_EQ(target, buffers.get(bound_buffer_)->target); | |
| 600 buffers.get(bound_buffer_)->pixels = nullptr; | |
| 601 return true; | |
| 602 } | |
| 603 | |
| 604 GLuint TestWebGraphicsContext3D::createImageCHROMIUM(ClientBuffer buffer, | |
| 605 GLsizei width, | |
| 606 GLsizei height, | |
| 607 GLenum internalformat) { | |
| 608 DCHECK_EQ(GL_RGBA, static_cast<int>(internalformat)); | |
| 609 GLuint image_id = NextImageId(); | |
| 610 base::AutoLock lock(namespace_->lock); | |
| 611 base::hash_set<unsigned>& images = namespace_->images; | |
| 612 images.insert(image_id); | |
| 613 return image_id; | |
| 614 } | |
| 615 | |
| 616 void TestWebGraphicsContext3D::destroyImageCHROMIUM( | |
| 617 GLuint id) { | |
| 618 RetireImageId(id); | |
| 619 base::AutoLock lock(namespace_->lock); | |
| 620 base::hash_set<unsigned>& images = namespace_->images; | |
| 621 if (!images.count(id)) | |
| 622 ADD_FAILURE() << "destroyImageCHROMIUM called on unknown image " << id; | |
| 623 images.erase(id); | |
| 624 } | |
| 625 | |
| 626 GLuint TestWebGraphicsContext3D::createGpuMemoryBufferImageCHROMIUM( | |
| 627 GLsizei width, | |
| 628 GLsizei height, | |
| 629 GLenum internalformat, | |
| 630 GLenum usage) { | |
| 631 DCHECK_EQ(GL_RGBA, static_cast<int>(internalformat)); | |
| 632 GLuint image_id = NextImageId(); | |
| 633 base::AutoLock lock(namespace_->lock); | |
| 634 base::hash_set<unsigned>& images = namespace_->images; | |
| 635 images.insert(image_id); | |
| 636 return image_id; | |
| 637 } | |
| 638 | |
| 639 unsigned TestWebGraphicsContext3D::insertSyncPoint() { | |
| 640 return next_insert_sync_point_++; | |
| 641 } | |
| 642 | |
| 643 void TestWebGraphicsContext3D::waitSyncPoint(unsigned sync_point) { | |
| 644 if (sync_point) | |
| 645 last_waited_sync_point_ = sync_point; | |
| 646 } | |
| 647 | |
| 648 size_t TestWebGraphicsContext3D::NumTextures() const { | |
| 649 base::AutoLock lock(namespace_->lock); | |
| 650 return namespace_->textures.Size(); | |
| 651 } | |
| 652 | |
| 653 GLuint TestWebGraphicsContext3D::TextureAt(int i) const { | |
| 654 base::AutoLock lock(namespace_->lock); | |
| 655 return namespace_->textures.IdAt(i); | |
| 656 } | |
| 657 | |
| 658 GLuint TestWebGraphicsContext3D::NextTextureId() { | |
| 659 base::AutoLock lock(namespace_->lock); | |
| 660 GLuint texture_id = namespace_->next_texture_id++; | |
| 661 DCHECK(texture_id < (1 << 16)); | |
| 662 texture_id |= context_id_ << 16; | |
| 663 return texture_id; | |
| 664 } | |
| 665 | |
| 666 void TestWebGraphicsContext3D::RetireTextureId(GLuint id) { | |
| 667 base::AutoLock lock(namespace_->lock); | |
| 668 unsigned context_id = id >> 16; | |
| 669 unsigned texture_id = id & 0xffff; | |
| 670 DCHECK(texture_id); | |
| 671 DCHECK_LT(texture_id, namespace_->next_texture_id); | |
| 672 DCHECK_EQ(context_id, context_id_); | |
| 673 } | |
| 674 | |
| 675 GLuint TestWebGraphicsContext3D::NextBufferId() { | |
| 676 base::AutoLock lock(namespace_->lock); | |
| 677 GLuint buffer_id = namespace_->next_buffer_id++; | |
| 678 DCHECK(buffer_id < (1 << 16)); | |
| 679 buffer_id |= context_id_ << 16; | |
| 680 return buffer_id; | |
| 681 } | |
| 682 | |
| 683 void TestWebGraphicsContext3D::RetireBufferId(GLuint id) { | |
| 684 base::AutoLock lock(namespace_->lock); | |
| 685 unsigned context_id = id >> 16; | |
| 686 unsigned buffer_id = id & 0xffff; | |
| 687 DCHECK(buffer_id); | |
| 688 DCHECK_LT(buffer_id, namespace_->next_buffer_id); | |
| 689 DCHECK_EQ(context_id, context_id_); | |
| 690 } | |
| 691 | |
| 692 GLuint TestWebGraphicsContext3D::NextImageId() { | |
| 693 base::AutoLock lock(namespace_->lock); | |
| 694 GLuint image_id = namespace_->next_image_id++; | |
| 695 DCHECK(image_id < (1 << 16)); | |
| 696 image_id |= context_id_ << 16; | |
| 697 return image_id; | |
| 698 } | |
| 699 | |
| 700 void TestWebGraphicsContext3D::RetireImageId(GLuint id) { | |
| 701 base::AutoLock lock(namespace_->lock); | |
| 702 unsigned context_id = id >> 16; | |
| 703 unsigned image_id = id & 0xffff; | |
| 704 DCHECK(image_id); | |
| 705 DCHECK_LT(image_id, namespace_->next_image_id); | |
| 706 DCHECK_EQ(context_id, context_id_); | |
| 707 } | |
| 708 | |
| 709 GLuint TestWebGraphicsContext3D::NextFramebufferId() { | |
| 710 base::AutoLock lock_for_framebuffer_access(namespace_->lock); | |
| 711 GLuint id = next_framebuffer_id_++; | |
| 712 DCHECK(id < (1 << 16)); | |
| 713 id |= context_id_ << 16; | |
| 714 framebuffer_set_.insert(id); | |
| 715 return id; | |
| 716 } | |
| 717 | |
| 718 void TestWebGraphicsContext3D::RetireFramebufferId(GLuint id) { | |
| 719 base::AutoLock lock_for_framebuffer_access(namespace_->lock); | |
| 720 DCHECK(framebuffer_set_.find(id) != framebuffer_set_.end()); | |
| 721 framebuffer_set_.erase(id); | |
| 722 } | |
| 723 | |
| 724 GLuint TestWebGraphicsContext3D::NextRenderbufferId() { | |
| 725 base::AutoLock lock_for_renderbuffer_access(namespace_->lock); | |
| 726 GLuint id = namespace_->next_renderbuffer_id++; | |
| 727 DCHECK(id < (1 << 16)); | |
| 728 id |= context_id_ << 16; | |
| 729 namespace_->renderbuffer_set.insert(id); | |
| 730 return id; | |
| 731 } | |
| 732 | |
| 733 void TestWebGraphicsContext3D::RetireRenderbufferId(GLuint id) { | |
| 734 base::AutoLock lock_for_renderbuffer_access(namespace_->lock); | |
| 735 DCHECK(namespace_->renderbuffer_set.find(id) != | |
| 736 namespace_->renderbuffer_set.end()); | |
| 737 namespace_->renderbuffer_set.erase(id); | |
| 738 } | |
| 739 | |
| 740 void TestWebGraphicsContext3D::SetMaxTransferBufferUsageBytes( | |
| 741 size_t max_transfer_buffer_usage_bytes) { | |
| 742 test_capabilities_.max_transfer_buffer_usage_bytes = | |
| 743 max_transfer_buffer_usage_bytes; | |
| 744 } | |
| 745 | |
| 746 TestWebGraphicsContext3D::TextureTargets::TextureTargets() { | |
| 747 // Initialize default bindings. | |
| 748 bound_textures_[GL_TEXTURE_2D] = 0; | |
| 749 bound_textures_[GL_TEXTURE_EXTERNAL_OES] = 0; | |
| 750 bound_textures_[GL_TEXTURE_RECTANGLE_ARB] = 0; | |
| 751 } | |
| 752 | |
| 753 TestWebGraphicsContext3D::TextureTargets::~TextureTargets() {} | |
| 754 | |
| 755 void TestWebGraphicsContext3D::TextureTargets::BindTexture( | |
| 756 GLenum target, | |
| 757 GLuint id) { | |
| 758 // Make sure this is a supported target by seeing if it was bound to before. | |
| 759 DCHECK(bound_textures_.find(target) != bound_textures_.end()); | |
| 760 bound_textures_[target] = id; | |
| 761 } | |
| 762 | |
| 763 void TestWebGraphicsContext3D::texParameteri(GLenum target, | |
| 764 GLenum pname, | |
| 765 GLint param) { | |
| 766 CheckTextureIsBound(target); | |
| 767 base::AutoLock lock_for_texture_access(namespace_->lock); | |
| 768 scoped_refptr<TestTexture> texture = BoundTexture(target); | |
| 769 DCHECK(texture->IsValidParameter(pname)); | |
| 770 texture->params[pname] = param; | |
| 771 } | |
| 772 | |
| 773 void TestWebGraphicsContext3D::getTexParameteriv(GLenum target, | |
| 774 GLenum pname, | |
| 775 GLint* value) { | |
| 776 CheckTextureIsBound(target); | |
| 777 base::AutoLock lock_for_texture_access(namespace_->lock); | |
| 778 scoped_refptr<TestTexture> texture = BoundTexture(target); | |
| 779 DCHECK(texture->IsValidParameter(pname)); | |
| 780 TestTexture::TextureParametersMap::iterator it = texture->params.find(pname); | |
| 781 if (it != texture->params.end()) | |
| 782 *value = it->second; | |
| 783 } | |
| 784 | |
| 785 void TestWebGraphicsContext3D::TextureTargets::UnbindTexture( | |
| 786 GLuint id) { | |
| 787 // Bind zero to any targets that the id is bound to. | |
| 788 for (TargetTextureMap::iterator it = bound_textures_.begin(); | |
| 789 it != bound_textures_.end(); | |
| 790 it++) { | |
| 791 if (it->second == id) | |
| 792 it->second = 0; | |
| 793 } | |
| 794 } | |
| 795 | |
| 796 GLuint TestWebGraphicsContext3D::TextureTargets::BoundTexture( | |
| 797 GLenum target) { | |
| 798 DCHECK(bound_textures_.find(target) != bound_textures_.end()); | |
| 799 return bound_textures_[target]; | |
| 800 } | |
| 801 | |
| 802 TestWebGraphicsContext3D::Buffer::Buffer() : target(0), size(0) {} | |
| 803 | |
| 804 TestWebGraphicsContext3D::Buffer::~Buffer() {} | |
| 805 | |
| 806 TestWebGraphicsContext3D::Image::Image() {} | |
| 807 | |
| 808 TestWebGraphicsContext3D::Image::~Image() {} | |
| 809 | |
| 810 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master