Implement EXT_draw_buffers WebGL extention support in command buffer.

cc/test/test_web_graphics_context_3d.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/test/test_web_graphics_context_3d.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 using WebKit::WGC3Dboolean;
+using WebKit::WGC3Dchar;
 using WebKit::WGC3Denum;
+using WebKit::WGC3Dint;
+using WebKit::WGC3Dsizei;
+using WebKit::WGC3Dsizeiptr;
+using WebKit::WGC3Duint;
 using WebKit::WebGLId;
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 static const WebGLId kBufferId = 1;
 static const WebGLId kFramebufferId = 2;
 static const WebGLId kProgramId = 3;
 static const WebGLId kRenderbufferId = 4;
 static const WebGLId kShaderId = 5;
@@ skipping 87 matching lines @@
   if (name == GL_EXTENSIONS) {
     if (have_extension_io_surface_)
       string += "GL_CHROMIUM_iosurface GL_ARB_texture_rectangle ";
     if (have_extension_egl_image_)
       string += "GL_OES_EGL_image_external";
   }
 
   return WebKit::WebString::fromUTF8(string.c_str());
 }
 
-WebKit::WGC3Dint TestWebGraphicsContext3D::getUniformLocation(
+WGC3Dint TestWebGraphicsContext3D::getUniformLocation(
     WebGLId program,
-    const WebKit::WGC3Dchar* name) {
+    const WGC3Dchar* name) {
   return 0;
 }
 
-WebKit::WGC3Dsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset(
-    WebKit::WGC3Duint index,
+WGC3Dsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset(
+    WGC3Duint index,
     WGC3Denum pname) {
   return 0;
 }
 
 WGC3Dboolean TestWebGraphicsContext3D::isBuffer(
     WebGLId buffer) {
   return false;
 }
 
 WGC3Dboolean TestWebGraphicsContext3D::isEnabled(
@@ skipping 23 matching lines @@
 
 WGC3Dboolean TestWebGraphicsContext3D::isTexture(
     WebGLId texture) {
   return false;
 }
 
 WebGLId TestWebGraphicsContext3D::createBuffer() {
   return kBufferId | context_id_ << 16;
 }
 
-void TestWebGraphicsContext3D::deleteBuffer(WebKit::WebGLId id) {
+void TestWebGraphicsContext3D::deleteBuffer(WebGLId id) {
   EXPECT_EQ(kBufferId | context_id_ << 16, id);
 }
 
 WebGLId TestWebGraphicsContext3D::createFramebuffer() {
   return kFramebufferId | context_id_ << 16;
 }
 
-void TestWebGraphicsContext3D::deleteFramebuffer(WebKit::WebGLId id) {
+void TestWebGraphicsContext3D::deleteFramebuffer(WebGLId id) {
   EXPECT_EQ(kFramebufferId | context_id_ << 16, id);
 }
 
 WebGLId TestWebGraphicsContext3D::createProgram() {
   return kProgramId | context_id_ << 16;
 }
 
-void TestWebGraphicsContext3D::deleteProgram(WebKit::WebGLId id) {
+void TestWebGraphicsContext3D::deleteProgram(WebGLId id) {
   EXPECT_EQ(kProgramId | context_id_ << 16, id);
 }
 
 WebGLId TestWebGraphicsContext3D::createRenderbuffer() {
   return kRenderbufferId | context_id_ << 16;
 }
 
-void TestWebGraphicsContext3D::deleteRenderbuffer(WebKit::WebGLId id) {
+void TestWebGraphicsContext3D::deleteRenderbuffer(WebGLId id) {
   EXPECT_EQ(kRenderbufferId | context_id_ << 16, id);
 }
 
 WebGLId TestWebGraphicsContext3D::createShader(WGC3Denum) {
   return kShaderId | context_id_ << 16;
 }
 
-void TestWebGraphicsContext3D::deleteShader(WebKit::WebGLId id) {
+void TestWebGraphicsContext3D::deleteShader(WebGLId id) {
   EXPECT_EQ(kShaderId | context_id_ << 16, id);
 }
 
 WebGLId TestWebGraphicsContext3D::createTexture() {
   WebGLId texture_id = NextTextureId();
   DCHECK_NE(texture_id, kExternalTextureId);
   textures_.push_back(texture_id);
   return texture_id;
 }
 
@@ skipping 46 matching lines @@
 
   if (!texture_id)
     return;
   if (texture_id == kExternalTextureId)
     return;
   DCHECK(std::find(textures_.begin(), textures_.end(), texture_id) !=
          textures_.end());
   used_textures_.insert(texture_id);
 }
 
-void TestWebGraphicsContext3D::endQueryEXT(WebKit::WGC3Denum target) {
+void TestWebGraphicsContext3D::endQueryEXT(WGC3Denum target) {
   if (times_end_query_succeeds_ >= 0) {
     if (!times_end_query_succeeds_) {
       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                           GL_INNOCENT_CONTEXT_RESET_ARB);
     }
     --times_end_query_succeeds_;
   }
 }
 
 void TestWebGraphicsContext3D::getQueryObjectuivEXT(
-    WebKit::WebGLId query,
-    WebKit::WGC3Denum pname,
-    WebKit::WGC3Duint* params) {
+    WebGLId query,
+    WGC3Denum pname,
+    WGC3Duint* params) {
   // If the context is lost, behave as if result is available.
   if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
     *params = 1;
 }
 
 void TestWebGraphicsContext3D::setContextLostCallback(
     WebGraphicsContextLostCallback* callback) {
   context_lost_callback_ = callback;
 }
 
 void TestWebGraphicsContext3D::loseContextCHROMIUM(WGC3Denum current,
                                                    WGC3Denum other) {
   if (context_lost_)
     return;
   context_lost_ = true;
   if (context_lost_callback_)
     context_lost_callback_->onContextLost();
 
   for (size_t i = 0; i < shared_contexts_.size(); ++i)
     shared_contexts_[i]->loseContextCHROMIUM(current, other);
   shared_contexts_.clear();
 }
 
-WebKit::WebGLId TestWebGraphicsContext3D::NextTextureId() {
+WebGLId TestWebGraphicsContext3D::NextTextureId() {
   WebGLId texture_id = next_texture_id_++;
   DCHECK(texture_id < (1 << 16));
   texture_id |= context_id_ << 16;
   return texture_id;
 }
 
 }  // namespace cc