Port content::GLHelper over to GLES2Interface

content/common/gpu/client/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_
 
+#include <deque>
+#include <map>
 #include <vector>
 
 #include "content/common/gpu/client/gl_helper.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/size.h"
 
 namespace content {
 
 class ShaderProgram;
 class ScalerImpl;
 class GLHelperTest;
 
 // Implements GPU texture scaling methods.
 // Note that you should probably not use this class directly.
 // See gl_helper.cc::CreateScaler instead.
@@ skipping 13 matching lines @@
   };
 
   // Similar to ScalerInterface, but can generate multiple outputs.
   // Used for YUV conversion in gl_helper.c
   class CONTENT_EXPORT ShaderInterface {
    public:
     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(blink::WebGLId source_texture,
-                         const std::vector<blink::WebGLId>& dest_textures) = 0;
+    virtual void Execute(GLuint source_texture,
+                         const std::vector<GLuint>& dest_textures) = 0;
   };
 
   typedef std::pair<ShaderType, bool> ShaderProgramKeyType;
 
-  GLHelperScaling(blink::WebGraphicsContext3D* context,
+  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,
@@ skipping 114 matching lines @@
       bool swizzle,
       std::deque<GLHelperScaling::ScaleOp>* x_ops,
       std::deque<GLHelperScaling::ScaleOp>* y_ops,
       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 blink::WGC3Dfloat kVertexAttributes[];
+  static const GLfloat kVertexAttributes[];
 
-  blink::WebGraphicsContext3D* context_;
+  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_;
 
   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_