Move gl_helper to content/browser/compositor

content/browser/compositor/gl_helper_scaling.h

 // Copyright (c) 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.
 
-#ifndef CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_
-#define CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_
+#ifndef CONTENT_BROWSER_COMPOSITOR_GL_HELPER_SCALING_H_
+#define CONTENT_BROWSER_COMPOSITOR_GL_HELPER_SCALING_H_
 
 #include <deque>
 #include <map>
 #include <vector>
 
 #include "base/macros.h"
-#include "content/common/gpu/client/gl_helper.h"
+#include "content/browser/compositor/gl_helper.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 class ShaderProgram;
 class ScalerImpl;
 class GLHelperTest;
 
 // Implements GPU texture scaling methods.
@@ skipping 21 matching lines @@
     ShaderInterface() {}
     virtual ~ShaderInterface() {}
     // Note that the src_texture will have the min/mag filter set to GL_LINEAR
     // and wrap_s/t set to CLAMP_TO_EDGE in this call.
     virtual void Execute(GLuint source_texture,
                          const std::vector<GLuint>& dest_textures) = 0;
   };
 
   typedef std::pair<ShaderType, bool> ShaderProgramKeyType;
 
-  GLHelperScaling(gpu::gles2::GLES2Interface* gl,
-                  GLHelper* helper);
+  GLHelperScaling(gpu::gles2::GLES2Interface* gl, GLHelper* helper);
   ~GLHelperScaling();
   void InitBuffer();
 
-  GLHelper::ScalerInterface* CreateScaler(
-      GLHelper::ScalerQuality quality,
-      gfx::Size src_size,
-      gfx::Rect src_subrect,
-      const gfx::Size& dst_size,
-      bool vertically_flip_texture,
-      bool swizzle);
+  GLHelper::ScalerInterface* CreateScaler(GLHelper::ScalerQuality quality,
+                                          gfx::Size src_size,
+                                          gfx::Rect src_subrect,
+                                          const gfx::Size& dst_size,
+                                          bool vertically_flip_texture,
+                                          bool swizzle);
 
-  GLHelper::ScalerInterface* 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]);
+  GLHelper::ScalerInterface* 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]);
 
-  ShaderInterface* CreateYuvMrtShader(
-      const gfx::Size& src_size,
-      const gfx::Rect& src_subrect,
-      const gfx::Size& dst_size,
-      bool vertically_flip_texture,
-      bool swizzle,
-      ShaderType shader);
+  ShaderInterface* CreateYuvMrtShader(const gfx::Size& src_size,
+                                      const gfx::Rect& src_subrect,
+                                      const gfx::Size& dst_size,
+                                      bool vertically_flip_texture,
+                                      bool swizzle,
+                                      ShaderType shader);
 
  private:
   // A ScaleOp represents a pass in a scaler pipeline, in one dimension.
   // Note that when quality is GOOD, multiple scaler passes will be
   // combined into one operation for increased performance.
   // Exposed in the header file for testing purposes.
   struct ScaleOp {
     ScaleOp(int factor, bool x, int size)
-        : scale_factor(factor), scale_x(x), scale_size(size) {
-    }
+        : scale_factor(factor), scale_x(x), scale_size(size) {}
 
     // Calculate a set of ScaleOp needed to convert an image of size
     // |src| into an image of size |dst|. If |scale_x| is true, then
     // the calculations are for the X axis of the image, otherwise Y.
     // If |allow3| is true, we can use a SHADER_BILINEAR3 to replace
     // a scale up and scale down with a 3-tap bilinear scale.
     // The calculated ScaleOps are added to |ops|.
     static void AddOps(int src,
                        int dst,
                        bool scale_x,
@@ skipping 28 matching lines @@
         subrect->set_width(scale_size);
       } else {
         subrect->set_height(scale_size);
       }
     }
 
     // A scale factor of 0 means upscale
     // 2 means 50% scale
     // 3 means 33% scale, etc.
     int scale_factor;
-    bool scale_x;  // Otherwise y
+    bool scale_x;    // Otherwise y
     int scale_size;  // Size to scale to.
   };
 
   // Full specification for a single scaling stage.
   struct ScalerStage {
     ScalerStage(ShaderType shader_,
                 gfx::Size src_size_,
                 gfx::Rect src_subrect_,
                 gfx::Size dst_size_,
                 bool scale_x_,
@@ skipping 10 matching lines @@
   };
 
   // Compute a vector of scaler stages for a particular
   // set of input/output parameters.
   void 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);
+                           std::vector<ScalerStage>* scaler_stages);
 
   // Take two queues of ScaleOp structs and generate a
   // vector of scaler stages. This is the second half of
   // ComputeScalerStages.
   void ConvertScalerOpsToScalerStages(
       GLHelper::ScalerQuality quality,
       gfx::Size src_size,
       gfx::Rect src_subrect,
       const gfx::Size& dst_size,
       bool vertically_flip_texture,
       bool swizzle,
       std::deque<GLHelperScaling::ScaleOp>* x_ops,
       std::deque<GLHelperScaling::ScaleOp>* y_ops,
-      std::vector<ScalerStage> *scaler_stages);
-
+      std::vector<ScalerStage>* scaler_stages);
 
   scoped_refptr<ShaderProgram> GetShaderProgram(ShaderType type, bool swizzle);
 
   // Interleaved array of 2-dimentional vertex positions (x, y) and
   // 2-dimentional texture coordinates (s, t).
   static const GLfloat kVertexAttributes[];
 
   gpu::gles2::GLES2Interface* gl_;
   GLHelper* helper_;
 
   // The buffer that holds the vertices and the texture coordinates data for
   // drawing a quad.
   ScopedBuffer vertex_attributes_buffer_;
 
-  std::map<ShaderProgramKeyType,
-           scoped_refptr<ShaderProgram> > shader_programs_;
+  std::map<ShaderProgramKeyType, scoped_refptr<ShaderProgram>> shader_programs_;
 
   friend class ShaderProgram;
   friend class ScalerImpl;
   friend class GLHelperTest;
   DISALLOW_COPY_AND_ASSIGN(GLHelperScaling);
 };
 
-
 }  // namespace content
 
-#endif  // CONTENT_COMMON_GPU_CLIENT_GL_HELPER_SCALING_H_
+#endif  // CONTENT_BROWSER_COMPOSITOR_GL_HELPER_SCALING_H_