Rename WebKit namespace to blink (part 3)

content/common/gpu/client/gl_helper_scaling.cc

 // Copyright (c) 2012 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 "content/common/gpu/client/gl_helper_scaling.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
-using WebKit::WebGLId;
-using WebKit::WebGraphicsContext3D;
+using blink::WebGLId;
+using blink::WebGraphicsContext3D;
 
 namespace content {
 
-GLHelperScaling::GLHelperScaling(WebKit::WebGraphicsContext3D* context,
+GLHelperScaling::GLHelperScaling(blink::WebGraphicsContext3D* context,
                 GLHelper* helper)
   : context_(context),
     helper_(helper),
     vertex_attributes_buffer_(context_, context_->createBuffer()) {
   InitBuffer();
 }
 
 GLHelperScaling::~GLHelperScaling() {
 }
 
 // Used to keep track of a generated shader program. The program
 // is passed in as text through Setup and is used by calling
 // UseProgram() with the right parameters. Note that |context_|
 // and |helper_| are assumed to live longer than this program.
 class ShaderProgram : public base::RefCounted<ShaderProgram> {
  public:
   ShaderProgram(WebGraphicsContext3D* context,
                 GLHelper* helper)
       : context_(context),
         helper_(helper),
         program_(context, context->createProgram()) {
   }
 
   // Compile shader program, return true if successful.
-  bool Setup(const WebKit::WGC3Dchar* vertex_shader_text,
-             const WebKit::WGC3Dchar* fragment_shader_text);
+  bool Setup(const blink::WGC3Dchar* vertex_shader_text,
+             const blink::WGC3Dchar* fragment_shader_text);
 
   // UseProgram must be called with GL_TEXTURE_2D bound to the
   // source texture and GL_ARRAY_BUFFER bound to a vertex
   // attribute buffer.
   void UseProgram(const gfx::Size& src_size,
                   const gfx::Rect& src_subrect,
                   const gfx::Size& dst_size,
                   bool scale_x,
                   bool flip_y,
                   GLfloat color_weights[4]);
 
  private:
   friend class base::RefCounted<ShaderProgram>;
   ~ShaderProgram() {}
 
   WebGraphicsContext3D* context_;
   GLHelper* helper_;
 
   // A program for copying a source texture into a destination texture.
   ScopedProgram program_;
 
   // The location of the position in the program.
-  WebKit::WGC3Dint position_location_;
+  blink::WGC3Dint position_location_;
   // The location of the texture coordinate in the program.
-  WebKit::WGC3Dint texcoord_location_;
+  blink::WGC3Dint texcoord_location_;
   // The location of the source texture in the program.
-  WebKit::WGC3Dint texture_location_;
+  blink::WGC3Dint texture_location_;
   // The location of the texture coordinate of
   // the sub-rectangle in the program.
-  WebKit::WGC3Dint src_subrect_location_;
+  blink::WGC3Dint src_subrect_location_;
   // Location of size of source image in pixels.
-  WebKit::WGC3Dint src_pixelsize_location_;
+  blink::WGC3Dint src_pixelsize_location_;
   // Location of size of destination image in pixels.
-  WebKit::WGC3Dint dst_pixelsize_location_;
+  blink::WGC3Dint dst_pixelsize_location_;
   // Location of vector for scaling direction.
-  WebKit::WGC3Dint scaling_vector_location_;
+  blink::WGC3Dint scaling_vector_location_;
   // Location of color weights.
-  WebKit::WGC3Dint color_weights_location_;
+  blink::WGC3Dint color_weights_location_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderProgram);
 };
 
 
 // Implementation of a single stage in a scaler pipeline. If the pipeline has
 // multiple stages, it calls Scale() on the subscaler, then further scales the
 // output. Caches textures and framebuffers to avoid allocating/deleting
 // them once per frame, which can be expensive on some drivers.
 class ScalerImpl :
@@ skipping 53 matching lines @@
   }
 
   virtual ~ScalerImpl() {
     if (intermediate_texture_) {
       context_->deleteTexture(intermediate_texture_);
     }
   }
 
   // GLHelperShader::ShaderInterface implementation.
   virtual void Execute(
-      WebKit::WebGLId source_texture,
-      const std::vector<WebKit::WebGLId>& dest_textures) OVERRIDE {
+      blink::WebGLId source_texture,
+      const std::vector<blink::WebGLId>& dest_textures) OVERRIDE {
     if (subscaler_) {
       subscaler_->Scale(source_texture, intermediate_texture_);
       source_texture = intermediate_texture_;
     }
 
     ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
         context_,
         dst_framebuffer_);
     DCHECK_GT(dest_textures.size(), 0U);
-    scoped_ptr<WebKit::WGC3Denum[]> buffers(
-        new WebKit::WGC3Denum[dest_textures.size()]);
+    scoped_ptr<blink::WGC3Denum[]> buffers(
+        new blink::WGC3Denum[dest_textures.size()]);
     for (size_t t = 0; t < dest_textures.size(); t++) {
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_,
                                                         dest_textures[t]);
       context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                      GL_COLOR_ATTACHMENT0 + t,
                                      GL_TEXTURE_2D,
                                      dest_textures[t],
                                      0);
       buffers[t] = GL_COLOR_ATTACHMENT0 + t;
     }
@@ skipping 27 matching lines @@
     }
     // Conduct texture mapping by drawing a quad composed of two triangles.
     context_->drawArrays(GL_TRIANGLE_STRIP, 0, 4);
     if (dest_textures.size() > 1) {
       // Set the draw buffers back to not confuse others.
       context_->drawBuffersEXT(1, &buffers[0]);
     }
   }
 
   // GLHelper::ScalerInterface implementation.
-  virtual void Scale(WebKit::WebGLId source_texture,
-                     WebKit::WebGLId dest_texture) OVERRIDE {
-    std::vector<WebKit::WebGLId> tmp(1);
+  virtual void Scale(blink::WebGLId source_texture,
+                     blink::WebGLId dest_texture) OVERRIDE {
+    std::vector<blink::WebGLId> tmp(1);
     tmp[0] = dest_texture;
     Execute(source_texture, tmp);
   }
 
   virtual const gfx::Size& SrcSize() OVERRIDE {
     if (subscaler_) {
       return subscaler_->SrcSize();
     }
     return spec_.src_size;
   }
   virtual const gfx::Rect& SrcSubrect() OVERRIDE {
     if (subscaler_) {
       return subscaler_->SrcSubrect();
     }
     return spec_.src_subrect;
   }
   virtual const gfx::Size& DstSize() OVERRIDE {
     return spec_.dst_size;
   }
 
  private:
   WebGraphicsContext3D* context_;
   GLHelperScaling* scaler_helper_;
   GLHelperScaling::ScalerStage spec_;
   GLfloat color_weights_[4];
-  WebKit::WebGLId intermediate_texture_;
+  blink::WebGLId intermediate_texture_;
   scoped_refptr<ShaderProgram> shader_program_;
   ScopedFramebuffer dst_framebuffer_;
   scoped_ptr<ScalerImpl> subscaler_;
 };
 
 GLHelperScaling::ScalerStage::ScalerStage(
     ShaderType shader_,
     gfx::Size src_size_,
     gfx::Rect src_subrect_,
     gfx::Size dst_size_,
@@ skipping 237 matching lines @@
   ScalerStage stage(shader,
                     src_size,
                     src_subrect,
                     dst_size,
                     true,
                     vertically_flip_texture,
                     false);
   return new ScalerImpl(context_, this, stage, NULL, NULL);
 }
 
-const WebKit::WGC3Dfloat GLHelperScaling::kVertexAttributes[] = {
+const blink::WGC3Dfloat GLHelperScaling::kVertexAttributes[] = {
   -1.0f, -1.0f, 0.0f, 0.0f,
   1.0f, -1.0f, 1.0f, 0.0f,
   -1.0f, 1.0f, 0.0f, 1.0f,
   1.0f, 1.0f, 1.0f, 1.0f,
 };
 
 void GLHelperScaling::InitBuffer() {
   ScopedBufferBinder<GL_ARRAY_BUFFER> buffer_binder(
       context_, vertex_attributes_buffer_);
   context_->bufferData(GL_ARRAY_BUFFER,
                        sizeof(kVertexAttributes),
                        kVertexAttributes,
                        GL_STATIC_DRAW);
 }
 
 scoped_refptr<ShaderProgram>
 GLHelperScaling::GetShaderProgram(ShaderType type,
                                   bool swizzle) {
   ShaderProgramKeyType key(type, swizzle);
   scoped_refptr<ShaderProgram>& cache_entry(shader_programs_[key]);
   if (!cache_entry.get()) {
     cache_entry = new ShaderProgram(context_, helper_);
-    std::basic_string<WebKit::WGC3Dchar> vertex_program;
-    std::basic_string<WebKit::WGC3Dchar> fragment_program;
-    std::basic_string<WebKit::WGC3Dchar> vertex_header;
-    std::basic_string<WebKit::WGC3Dchar> fragment_directives;
-    std::basic_string<WebKit::WGC3Dchar> fragment_header;
-    std::basic_string<WebKit::WGC3Dchar> shared_variables;
+    std::basic_string<blink::WGC3Dchar> vertex_program;
+    std::basic_string<blink::WGC3Dchar> fragment_program;
+    std::basic_string<blink::WGC3Dchar> vertex_header;
+    std::basic_string<blink::WGC3Dchar> fragment_directives;
+    std::basic_string<blink::WGC3Dchar> fragment_header;
+    std::basic_string<blink::WGC3Dchar> shared_variables;
 
     vertex_header.append(
         "precision highp float;\n"
         "attribute vec2 a_position;\n"
         "attribute vec2 a_texcoord;\n"
         "uniform vec4 src_subrect;\n");
 
     fragment_header.append(
         "precision mediump float;\n"
         "uniform sampler2D s_texture;\n");
@@ skipping 312 matching lines @@
 
     bool result = cache_entry->Setup(vertex_program.c_str(),
                                      fragment_program.c_str());
     DCHECK(result || context_->isContextLost())
         << "vertex_program =\n" << vertex_program
         << "fragment_program =\n" << fragment_program;
   }
   return cache_entry;
 }
 
-bool ShaderProgram::Setup(const WebKit::WGC3Dchar* vertex_shader_text,
-                          const WebKit::WGC3Dchar* fragment_shader_text) {
+bool ShaderProgram::Setup(const blink::WGC3Dchar* vertex_shader_text,
+                          const blink::WGC3Dchar* fragment_shader_text) {
   // Shaders to map the source texture to |dst_texture_|.
   ScopedShader vertex_shader(context_, helper_->CompileShaderFromSource(
       vertex_shader_text, GL_VERTEX_SHADER));
   if (vertex_shader.id() == 0) {
     return false;
   }
   context_->attachShader(program_, vertex_shader);
   ScopedShader fragment_shader(context_, helper_->CompileShaderFromSource(
       fragment_shader_text, GL_FRAGMENT_SHADER));
   if (fragment_shader.id() == 0) {
     return false;
   }
   context_->attachShader(program_, fragment_shader);
   context_->linkProgram(program_);
 
-  WebKit::WGC3Dint link_status = 0;
+  blink::WGC3Dint link_status = 0;
   context_->getProgramiv(program_, GL_LINK_STATUS, &link_status);
   if (!link_status) {
     LOG(ERROR) << std::string(context_->getProgramInfoLog(program_).utf8());
     return false;
   }
   position_location_ = context_->getAttribLocation(program_, "a_position");
   texcoord_location_ = context_->getAttribLocation(program_, "a_texcoord");
   texture_location_ = context_->getUniformLocation(program_, "s_texture");
   src_subrect_location_ = context_->getUniformLocation(program_, "src_subrect");
   src_pixelsize_location_ = context_->getUniformLocation(program_,
                                                          "src_pixelsize");
   dst_pixelsize_location_ = context_->getUniformLocation(program_,
                                                          "dst_pixelsize");
   scaling_vector_location_ = context_->getUniformLocation(program_,
                                                           "scaling_vector");
   color_weights_location_ = context_->getUniformLocation(program_,
                                                          "color_weights");
   return true;
 }
 
 void ShaderProgram::UseProgram(
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool scale_x,
     bool flip_y,
     GLfloat color_weights[4]) {
   context_->useProgram(program_);
 
-  WebKit::WGC3Dintptr offset = 0;
+  blink::WGC3Dintptr offset = 0;
   context_->vertexAttribPointer(position_location_,
                                 2,
                                 GL_FLOAT,
                                 GL_FALSE,
-                                4 * sizeof(WebKit::WGC3Dfloat),
+                                4 * sizeof(blink::WGC3Dfloat),
                                 offset);
   context_->enableVertexAttribArray(position_location_);
 
-  offset += 2 * sizeof(WebKit::WGC3Dfloat);
+  offset += 2 * sizeof(blink::WGC3Dfloat);
   context_->vertexAttribPointer(texcoord_location_,
                                 2,
                                 GL_FLOAT,
                                 GL_FALSE,
-                                4 * sizeof(WebKit::WGC3Dfloat),
+                                4 * sizeof(blink::WGC3Dfloat),
                                 offset);
   context_->enableVertexAttribArray(texcoord_location_);
 
   context_->uniform1i(texture_location_, 0);
 
   // Convert |src_subrect| to texture coordinates.
   GLfloat src_subrect_texcoord[] = {
     static_cast<float>(src_subrect.x()) / src_size.width(),
     static_cast<float>(src_subrect.y()) / src_size.height(),
     static_cast<float>(src_subrect.width()) / src_size.width(),
@@ skipping 12 matching lines @@
                       static_cast<float>(dst_size.width()),
                       static_cast<float>(dst_size.height()));
 
   context_->uniform2f(scaling_vector_location_,
                       scale_x ? 1.0 : 0.0,
                       scale_x ? 0.0 : 1.0);
   context_->uniform4fv(color_weights_location_, 1, color_weights);
 }
 
 }  // namespace content