Revert of Remove create/delete methods from WebGraphicsContext3D.

components/test_runner/test_plugin.cc

 // Copyright 2013 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 "components/test_runner/test_plugin.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 
 namespace test_runner {
 
 namespace {
 
-void PremultiplyAlpha(const uint8_t color_in[3],
+void PremultiplyAlpha(const unsigned color_in[3],
                       float alpha,
                       float color_out[4]) {
   for (int i = 0; i < 3; ++i)
     color_out[i] = (color_in[i] / 255.0f) * alpha;
 
   color_out[3] = alpha;
 }
 
 const char* PointState(blink::WebTouchPoint::State state) {
   switch (state) {
@@ skipping 274 matching lines @@
     primitive = PrimitiveNone;
   else if (string == kPrimitiveTriangle)
     primitive = PrimitiveTriangle;
   else
     NOTREACHED();
   return primitive;
 }
 
 // FIXME: This method should already exist. Use it.
 // For now just parse primary colors.
-void TestPlugin::ParseColor(const blink::WebString& string, uint8_t color[3]) {
+void TestPlugin::ParseColor(const blink::WebString& string, unsigned color[3]) {
   color[0] = color[1] = color[2] = 0;
   if (string == "black")
     return;
 
   if (string == "red")
     color[0] = 255;
   else if (string == "green")
     color[1] = 255;
   else if (string == "blue")
     color[2] = 255;
   else
     NOTREACHED();
 }
 
 float TestPlugin::ParseOpacity(const blink::WebString& string) {
   return static_cast<float>(atof(string.utf8().data()));
 }
 
 bool TestPlugin::ParseBoolean(const blink::WebString& string) {
   const CR_DEFINE_STATIC_LOCAL(blink::WebString, kPrimitiveTrue, ("true"));
   return string == kPrimitiveTrue;
 }
 
 bool TestPlugin::InitScene() {
-  if (!gl_)
+  if (!context_)
     return true;
 
   float color[4];
   PremultiplyAlpha(scene_.background_color, scene_.opacity, color);
 
-  gl_->GenTextures(1, &color_texture_);
-  gl_->GenFramebuffers(1, &framebuffer_);
+  color_texture_ = context_->createTexture();
+  framebuffer_ = context_->createFramebuffer();
 
   gl_->Viewport(0, 0, rect_.width, rect_.height);
   gl_->Disable(GL_DEPTH_TEST);
   gl_->Disable(GL_SCISSOR_TEST);
 
   gl_->ClearColor(color[0], color[1], color[2], color[3]);
 
   gl_->Enable(GL_BLEND);
   gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
@@ skipping 36 matching lines @@
     canvas.drawPath(triangle_path, paint);
   }
 }
 
 void TestPlugin::DestroyScene() {
   if (scene_.program) {
     gl_->DeleteProgram(scene_.program);
     scene_.program = 0;
   }
   if (scene_.vbo) {
-    gl_->DeleteBuffers(1, &scene_.vbo);
+    context_->deleteBuffer(scene_.vbo);
     scene_.vbo = 0;
   }
 
   if (framebuffer_) {
-    gl_->DeleteFramebuffers(1, &framebuffer_);
+    context_->deleteFramebuffer(framebuffer_);
     framebuffer_ = 0;
   }
 
   if (color_texture_) {
-    gl_->DeleteTextures(1, &color_texture_);
+    context_->deleteTexture(color_texture_);
     color_texture_ = 0;
   }
 }
 
 bool TestPlugin::InitProgram() {
   const std::string vertex_source(
       "attribute vec4 position;  \n"
       "void main() {             \n"
       "  gl_Position = position; \n"
       "}                         \n");
@@ skipping 10 matching lines @@
     return false;
 
   scene_.color_location = gl_->GetUniformLocation(scene_.program, "color");
   scene_.position_location = gl_->GetAttribLocation(scene_.program, "position");
   return true;
 }
 
 bool TestPlugin::InitPrimitive() {
   DCHECK_EQ(scene_.primitive, PrimitiveTriangle);
 
-  gl_->GenBuffers(1, &scene_.vbo);
+  scene_.vbo = context_->createBuffer();
   if (!scene_.vbo)
     return false;
 
   const float vertices[] = {0.0f, 0.8f, 0.0f,  -0.8f, -0.8f,
                             0.0f, 0.8f, -0.8f, 0.0f};
   gl_->BindBuffer(GL_ARRAY_BUFFER, scene_.vbo);
   gl_->BufferData(GL_ARRAY_BUFFER, sizeof(vertices), 0, GL_STATIC_DRAW);
   gl_->BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
   return true;
 }
@@ skipping 11 matching lines @@
   gl_->Uniform4f(scene_.color_location, color[0], color[1], color[2], color[3]);
 
   // Bind primitive vertices.
   gl_->BindBuffer(GL_ARRAY_BUFFER, scene_.vbo);
   gl_->EnableVertexAttribArray(scene_.position_location);
   gl_->VertexAttribPointer(scene_.position_location, 3, GL_FLOAT, GL_FALSE, 0,
                            nullptr);
   gl_->DrawArrays(GL_TRIANGLES, 0, 3);
 }
 
-GLuint TestPlugin::LoadShader(GLenum type, const std::string& source) {
-  GLuint shader = gl_->CreateShader(type);
+unsigned TestPlugin::LoadShader(unsigned type, const std::string& source) {
+  unsigned shader = gl_->CreateShader(type);
   if (shader) {
     context_->shaderSource(shader, source.data());
     gl_->CompileShader(shader);
 
     int compiled = 0;
     gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
     if (!compiled) {
       gl_->DeleteShader(shader);
       shader = 0;
     }
   }
   return shader;
 }
 
-GLuint TestPlugin::LoadProgram(const std::string& vertex_source,
-                               const std::string& fragment_source) {
-  GLuint vertex_shader = LoadShader(GL_VERTEX_SHADER, vertex_source);
-  GLuint fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
-  GLuint program = gl_->CreateProgram();
+unsigned TestPlugin::LoadProgram(const std::string& vertex_source,
+                                 const std::string& fragment_source) {
+  unsigned vertex_shader = LoadShader(GL_VERTEX_SHADER, vertex_source);
+  unsigned fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
+  unsigned program = gl_->CreateProgram();
   if (vertex_shader && fragment_shader && program) {
     gl_->AttachShader(program, vertex_shader);
     gl_->AttachShader(program, fragment_shader);
     gl_->LinkProgram(program);
 
     int linked = 0;
     gl_->GetProgramiv(program, GL_LINK_STATUS, &linked);
     if (!linked) {
       gl_->DeleteProgram(program);
       program = 0;
@@ skipping 193 matching lines @@
   return kPluginPersistsMimeType;
 }
 
 bool TestPlugin::IsSupportedMimeType(const blink::WebString& mime_type) {
   return mime_type == TestPlugin::MimeType() ||
          mime_type == PluginPersistsMimeType() ||
          mime_type == CanCreateWithoutRendererMimeType();
 }
 
 }  // namespace test_runner