Move gl_helper to content/browser/compositor

content/browser/compositor/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 "content/browser/compositor/gl_helper_scaling.h"
 
 #include <stddef.h>
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 123 matching lines @@
       color_weights_[3] = 0.0;
     }
     shader_program_ =
         scaler_helper_->GetShaderProgram(spec_.shader, spec_.swizzle);
 
     if (subscaler_) {
       intermediate_texture_ = 0u;
       gl_->GenTextures(1, &intermediate_texture_);
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_,
                                                         intermediate_texture_);
-      gl_->TexImage2D(GL_TEXTURE_2D,
-                      0,
-                      GL_RGBA,
-                      spec_.src_size.width(),
-                      spec_.src_size.height(),
-                      0,
-                      GL_RGBA,
-                      GL_UNSIGNED_BYTE,
+      gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, spec_.src_size.width(),
+                      spec_.src_size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE,
                       NULL);
     }
   }
 
   ~ScalerImpl() override {
     if (intermediate_texture_) {
       gl_->DeleteTextures(1, &intermediate_texture_);
     }
   }
 
   // GLHelperShader::ShaderInterface implementation.
   void Execute(GLuint source_texture,
                const std::vector<GLuint>& dest_textures) override {
     if (subscaler_) {
       subscaler_->Scale(source_texture, intermediate_texture_);
       source_texture = intermediate_texture_;
     }
 
     ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
         gl_, dst_framebuffer_);
     DCHECK_GT(dest_textures.size(), 0U);
     scoped_ptr<GLenum[]> buffers(new GLenum[dest_textures.size()]);
     for (size_t t = 0; t < dest_textures.size(); t++) {
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dest_textures[t]);
-      gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
-                                GL_COLOR_ATTACHMENT0 + t,
-                                GL_TEXTURE_2D,
-                                dest_textures[t],
-                                0);
+      gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + t,
+                                GL_TEXTURE_2D, dest_textures[t], 0);
       buffers[t] = GL_COLOR_ATTACHMENT0 + t;
     }
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, source_texture);
 
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
     ScopedBufferBinder<GL_ARRAY_BUFFER> buffer_binder(
         gl_, scaler_helper_->vertex_attributes_buffer_);
-    shader_program_->UseProgram(spec_.src_size,
-                                spec_.src_subrect,
-                                spec_.dst_size,
-                                spec_.scale_x,
-                                spec_.vertically_flip_texture,
-                                color_weights_);
+    shader_program_->UseProgram(spec_.src_size, spec_.src_subrect,
+                                spec_.dst_size, spec_.scale_x,
+                                spec_.vertically_flip_texture, color_weights_);
     gl_->Viewport(0, 0, spec_.dst_size.width(), spec_.dst_size.height());
 
     if (dest_textures.size() > 1) {
       DCHECK_LE(static_cast<int>(dest_textures.size()),
                 scaler_helper_->helper_->MaxDrawBuffers());
       gl_->DrawBuffersEXT(dest_textures.size(), buffers.get());
     }
     // Conduct texture mapping by drawing a quad composed of two triangles.
     gl_->DrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     if (dest_textures.size() > 1) {
@@ skipping 162 matching lines @@
           x_passes = 1;
         }
 
         for (int i = 0; i < x_passes; i++) {
           x_ops->front().UpdateSize(&intermediate_size);
           x_ops->pop_front();
         }
       }
     }
 
-    scaler_stages->push_back(ScalerStage(current_shader,
-                                         src_size,
-                                         src_subrect,
-                                         intermediate_size,
-                                         scale_x,
-                                         vertically_flip_texture,
-                                         swizzle));
+    scaler_stages->push_back(ScalerStage(current_shader, src_size, src_subrect,
+                                         intermediate_size, scale_x,
+                                         vertically_flip_texture, swizzle));
     src_size = intermediate_size;
     src_subrect = gfx::Rect(intermediate_size);
     vertically_flip_texture = false;
     swizzle = false;
   }
 }
 
 void GLHelperScaling::ComputeScalerStages(
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle,
     std::vector<ScalerStage>* scaler_stages) {
   if (quality == GLHelper::SCALER_QUALITY_FAST ||
       src_subrect.size() == dst_size) {
-    scaler_stages->push_back(ScalerStage(SHADER_BILINEAR,
-                                         src_size,
-                                         src_subrect,
-                                         dst_size,
-                                         false,
-                                         vertically_flip_texture,
-                                         swizzle));
+    scaler_stages->push_back(ScalerStage(SHADER_BILINEAR, src_size, src_subrect,
+                                         dst_size, false,
+                                         vertically_flip_texture, swizzle));
     return;
   }
 
   std::deque<GLHelperScaling::ScaleOp> x_ops, y_ops;
-  GLHelperScaling::ScaleOp::AddOps(src_subrect.width(),
-                                   dst_size.width(),
-                                   true,
+  GLHelperScaling::ScaleOp::AddOps(src_subrect.width(), dst_size.width(), true,
                                    quality == GLHelper::SCALER_QUALITY_GOOD,
                                    &x_ops);
-  GLHelperScaling::ScaleOp::AddOps(src_subrect.height(),
-                                   dst_size.height(),
-                                   false,
-                                   quality == GLHelper::SCALER_QUALITY_GOOD,
-                                   &y_ops);
+  GLHelperScaling::ScaleOp::AddOps(
+      src_subrect.height(), dst_size.height(), false,
+      quality == GLHelper::SCALER_QUALITY_GOOD, &y_ops);
 
-  ConvertScalerOpsToScalerStages(quality,
-                                 src_size,
-                                 src_subrect,
-                                 dst_size,
-                                 vertically_flip_texture,
-                                 swizzle,
-                                 &x_ops,
-                                 &y_ops,
-                                 scaler_stages);
+  ConvertScalerOpsToScalerStages(quality, src_size, src_subrect, dst_size,
+                                 vertically_flip_texture, swizzle, &x_ops,
+                                 &y_ops, scaler_stages);
 }
 
 GLHelper::ScalerInterface* GLHelperScaling::CreateScaler(
     GLHelper::ScalerQuality quality,
     gfx::Size src_size,
     gfx::Rect src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle) {
   std::vector<ScalerStage> scaler_stages;
-  ComputeScalerStages(quality,
-                      src_size,
-                      src_subrect,
-                      dst_size,
-                      vertically_flip_texture,
-                      swizzle,
-                      &scaler_stages);
+  ComputeScalerStages(quality, src_size, src_subrect, dst_size,
+                      vertically_flip_texture, swizzle, &scaler_stages);
 
   ScalerImpl* ret = NULL;
   for (unsigned int i = 0; i < scaler_stages.size(); i++) {
     ret = new ScalerImpl(gl_, this, scaler_stages[i], ret, NULL);
   }
   return ret;
 }
 
 GLHelper::ScalerInterface* GLHelperScaling::CreatePlanarScaler(
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle,
     const float color_weights[4]) {
-  ScalerStage stage(SHADER_PLANAR,
-                    src_size,
-                    src_subrect,
-                    dst_size,
-                    true,
-                    vertically_flip_texture,
-                    swizzle);
+  ScalerStage stage(SHADER_PLANAR, src_size, src_subrect, dst_size, true,
+                    vertically_flip_texture, swizzle);
   return new ScalerImpl(gl_, this, stage, NULL, color_weights);
 }
 
 GLHelperScaling::ShaderInterface* GLHelperScaling::CreateYuvMrtShader(
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle,
     ShaderType shader) {
   DCHECK(shader == SHADER_YUV_MRT_PASS1 || shader == SHADER_YUV_MRT_PASS2);
-  ScalerStage stage(shader,
-                    src_size,
-                    src_subrect,
-                    dst_size,
-                    true,
-                    vertically_flip_texture,
-                    swizzle);
+  ScalerStage stage(shader, src_size, src_subrect, dst_size, true,
+                    vertically_flip_texture, swizzle);
   return new ScalerImpl(gl_, this, stage, NULL, NULL);
 }
 
 const GLfloat GLHelperScaling::kVertexAttributes[] = {
-    -1.0f, -1.0f, 0.0f, 0.0f,     // vertex 0
-    1.0f,  -1.0f, 1.0f, 0.0f,     // vertex 1
-    -1.0f, 1.0f,  0.0f, 1.0f,     // vertex 2
-    1.0f,  1.0f,  1.0f, 1.0f, };  // vertex 3
+    -1.0f, -1.0f, 0.0f, 0.0f,  // vertex 0
+    1.0f,  -1.0f, 1.0f, 0.0f,  // vertex 1
+    -1.0f, 1.0f,  0.0f, 1.0f,  // vertex 2
+    1.0f,  1.0f,  1.0f, 1.0f,
+};  // vertex 3
 
 void GLHelperScaling::InitBuffer() {
   ScopedBufferBinder<GL_ARRAY_BUFFER> buffer_binder(gl_,
                                                     vertex_attributes_buffer_);
-  gl_->BufferData(GL_ARRAY_BUFFER,
-                  sizeof(kVertexAttributes),
-                  kVertexAttributes,
+  gl_->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(gl_, helper_);
     std::basic_string<GLchar> vertex_program;
@@ skipping 283 matching lines @@
             "  v_texcoords.zw = texcoord + step * 0.5;\n");
         fragment_directives.append("#extension GL_EXT_draw_buffers : enable\n");
         fragment_program.append(
             "  vec4 lo_uuvv = texture2D(s_texture, v_texcoords.xy);\n"
             "  vec4 hi_uuvv = texture2D(s_texture, v_texcoords.zw);\n"
             "  gl_FragData[0] = vec4(lo_uuvv.rg, hi_uuvv.rg);\n"
             "  gl_FragData[1] = vec4(lo_uuvv.ba, hi_uuvv.ba);\n");
         break;
     }
     if (swizzle) {
-      switch(type) {
+      switch (type) {
         case SHADER_YUV_MRT_PASS1:
           fragment_program.append("  gl_FragData[0] = gl_FragData[0].bgra;\n");
           break;
         case SHADER_YUV_MRT_PASS2:
           fragment_program.append("  gl_FragData[0] = gl_FragData[0].bgra;\n");
           fragment_program.append("  gl_FragData[1] = gl_FragData[1].bgra;\n");
           break;
         default:
           fragment_program.append("  gl_FragColor = gl_FragColor.bgra;\n");
           break;
@@ skipping 56 matching lines @@
                                const gfx::Rect& src_subrect,
                                const gfx::Size& dst_size,
                                bool scale_x,
                                bool flip_y,
                                GLfloat color_weights[4]) {
   gl_->UseProgram(program_);
 
   // OpenGL defines the last parameter to VertexAttribPointer as type
   // "const GLvoid*" even though it is actually an offset into the buffer
   // object's data store and not a pointer to the client's address space.
-  const void* offsets[2] = {
-      0, reinterpret_cast<const void*>(2 * sizeof(GLfloat))
-  };
+  const void* offsets[2] = {0,
+                            reinterpret_cast<const void*>(2 * sizeof(GLfloat))};
 
-  gl_->VertexAttribPointer(position_location_,
-                           2,
-                           GL_FLOAT,
-                           GL_FALSE,
-                           4 * sizeof(GLfloat),
-                           offsets[0]);
+  gl_->VertexAttribPointer(position_location_, 2, GL_FLOAT, GL_FALSE,
+                           4 * sizeof(GLfloat), offsets[0]);
   gl_->EnableVertexAttribArray(position_location_);
 
-  gl_->VertexAttribPointer(texcoord_location_,
-                           2,
-                           GL_FLOAT,
-                           GL_FALSE,
-                           4 * sizeof(GLfloat),
-                           offsets[1]);
+  gl_->VertexAttribPointer(texcoord_location_, 2, GL_FLOAT, GL_FALSE,
+                           4 * sizeof(GLfloat), offsets[1]);
   gl_->EnableVertexAttribArray(texcoord_location_);
 
   gl_->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(),
-      static_cast<float>(src_subrect.height()) / src_size.height(), };
+      static_cast<float>(src_subrect.height()) / src_size.height(),
+  };
   if (flip_y) {
     src_subrect_texcoord[1] += src_subrect_texcoord[3];
     src_subrect_texcoord[3] *= -1.0;
   }
   gl_->Uniform4fv(src_subrect_location_, 1, src_subrect_texcoord);
 
   gl_->Uniform2f(src_pixelsize_location_, src_size.width(), src_size.height());
-  gl_->Uniform2f(dst_pixelsize_location_,
-                 static_cast<float>(dst_size.width()),
+  gl_->Uniform2f(dst_pixelsize_location_, static_cast<float>(dst_size.width()),
                  static_cast<float>(dst_size.height()));
 
-  gl_->Uniform2f(
-      scaling_vector_location_, scale_x ? 1.0 : 0.0, scale_x ? 0.0 : 1.0);
+  gl_->Uniform2f(scaling_vector_location_, scale_x ? 1.0 : 0.0,
+                 scale_x ? 0.0 : 1.0);
   gl_->Uniform4fv(color_weights_location_, 1, color_weights);
 }
 
 }  // namespace content