Rename WebKit namespace to blink (part 3)

content/common/gpu/client/gl_helper.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.h"
 
 #include <queue>
 #include <string>
 
 #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/strings/string_util.h"
 #include "base/time/time.h"
 #include "content/common/gpu/client/gl_helper_scaling.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.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 {
 
 // Helper class for allocating and holding an RGBA texture of a given
 // size and an associated framebuffer.
 class TextureFrameBufferPair {
  public:
   TextureFrameBufferPair(WebGraphicsContext3D* context,
                          gfx::Size size)
       : texture_(context, context->createTexture()),
@@ skipping 36 matching lines @@
 // scaler and an associated frame buffer. This is inteded to be used
 // when the output of a scaler is to be sent to a readback.
 class ScalerHolder {
  public:
   ScalerHolder(WebGraphicsContext3D* context,
                content::GLHelper::ScalerInterface *scaler)
       : texture_and_framebuffer_(context, scaler->DstSize()),
         scaler_(scaler) {
   }
 
-  void Scale(WebKit::WebGLId src_texture) {
+  void Scale(blink::WebGLId src_texture) {
     scaler_->Scale(src_texture, texture_and_framebuffer_.texture());
   }
 
   content::GLHelper::ScalerInterface* scaler() const { return scaler_.get(); }
   TextureFrameBufferPair *texture_and_framebuffer() {
     return &texture_and_framebuffer_;
   }
   WebGLId texture() const { return texture_and_framebuffer_.texture(); }
 
  private:
@@ skipping 57 matching lines @@
       unsigned char* out,
       const base::Callback<void(bool)>& callback);
 
   void ReadbackPlane(TextureFrameBufferPair* source,
                      const scoped_refptr<media::VideoFrame>& target,
                      int plane,
                      int size_shift,
                      const gfx::Rect& dst_subrect,
                      const base::Callback<void(bool)>& callback);
 
-  WebKit::WebGLId CopyAndScaleTexture(WebGLId texture,
+  blink::WebGLId CopyAndScaleTexture(WebGLId texture,
                                       const gfx::Size& src_size,
                                       const gfx::Size& dst_size,
                                       bool vertically_flip_texture,
                                       GLHelper::ScalerQuality quality);
 
   ReadbackYUVInterface* CreateReadbackPipelineYUV(
       GLHelper::ScalerQuality quality,
       const gfx::Size& src_size,
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       const gfx::Rect& dst_subrect,
       bool flip_vertically,
       bool use_mrt);
 
   // Returns the maximum number of draw buffers available,
   // 0 if GL_EXT_draw_buffers is not available.
-  WebKit::WGC3Dint MaxDrawBuffers() const {
+  blink::WGC3Dint MaxDrawBuffers() const {
     return max_draw_buffers_;
   }
 
  private:
   // A single request to CropScaleReadbackAndCleanTexture.
   // The main thread can cancel the request, before it's handled by the helper
   // thread, by resetting the texture and pixels fields. Alternatively, the
   // thread marks that it handles the request by resetting the pixels field
   // (meaning it guarantees that the callback with be called).
   // In either case, the callback must be called exactly once, and the texture
@@ skipping 14 matching lines @@
           query(0) {
     }
 
     bool done;
     gfx::Size size;
     int bytes_per_row;
     int row_stride_bytes;
     unsigned char* pixels;
     base::Callback<void(bool)> callback;
     GLuint buffer;
-    WebKit::WebGLId query;
+    blink::WebGLId query;
   };
 
   // A readback pipeline that also converts the data to YUV before
   // reading it back.
   class ReadbackYUVImpl : public ReadbackYUVInterface {
    public:
     ReadbackYUVImpl(WebGraphicsContext3D* context,
                     CopyTextureToImpl* copy_impl,
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
@@ skipping 90 matching lines @@
 
   WebGraphicsContext3D* context_;
   gpu::ContextSupport* context_support_;
   GLHelper* helper_;
 
   // A scoped flush that will ensure all resource deletions are flushed when
   // this object is destroyed. Must be declared before other Scoped* fields.
   ScopedFlush flush_;
 
   std::queue<Request*> request_queue_;
-  WebKit::WGC3Dint max_draw_buffers_;
+  blink::WGC3Dint max_draw_buffers_;
 };
 
 GLHelper::ScalerInterface* GLHelper::CreateScaler(
     ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle) {
   InitScalerImpl();
@@ skipping 122 matching lines @@
                                  0);
   context_->readPixels(src_rect.x(),
                        src_rect.y(),
                        src_rect.width(),
                        src_rect.height(),
                        GL_RGBA,
                        GL_UNSIGNED_BYTE,
                        out);
 }
 
-WebKit::WebGLId GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
+blink::WebGLId GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     GLHelper::ScalerQuality quality) {
   return ScaleTexture(src_texture,
                       src_size,
                       gfx::Rect(src_size),
                       dst_size,
                       vertically_flip_texture,
@@ skipping 61 matching lines @@
   delete request;
 }
 
 void GLHelper::CopyTextureToImpl::CancelRequests() {
   while (!request_queue_.empty()) {
     Request* request = request_queue_.front();
     FinishRequest(request, false);
   }
 }
 
-GLHelper::GLHelper(WebKit::WebGraphicsContext3D* context,
+GLHelper::GLHelper(blink::WebGraphicsContext3D* context,
                    gpu::ContextSupport* context_support)
     : context_(context),
       context_support_(context_support) {
 }
 
 GLHelper::~GLHelper() {
 }
 
 void GLHelper::CropScaleReadbackAndCleanTexture(
     WebGLId src_texture,
@@ skipping 20 matching lines @@
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const base::Callback<void(bool)>& callback) {
   WebGLId mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_point);
   CropScaleReadbackAndCleanTexture(
       mailbox_texture, src_size, src_subrect, dst_size, out, callback);
   context_->deleteTexture(mailbox_texture);
 }
 
-void GLHelper::ReadbackTextureSync(WebKit::WebGLId texture,
+void GLHelper::ReadbackTextureSync(blink::WebGLId texture,
                                    const gfx::Rect& src_rect,
                                    unsigned char* out) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->ReadbackTextureSync(texture,
                                              src_rect,
                                              out);
 }
 
-WebKit::WebGLId GLHelper::CopyTexture(WebKit::WebGLId texture,
+blink::WebGLId GLHelper::CopyTexture(blink::WebGLId texture,
                                       const gfx::Size& size) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(
       texture,
       size,
       size,
       false,
       GLHelper::SCALER_QUALITY_FAST);
 }
 
-WebKit::WebGLId GLHelper::CopyAndScaleTexture(
-    WebKit::WebGLId texture,
+blink::WebGLId GLHelper::CopyAndScaleTexture(
+    blink::WebGLId texture,
     const gfx::Size& src_size,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     ScalerQuality quality) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(texture,
                                                     src_size,
                                                     dst_size,
                                                     vertically_flip_texture,
                                                     quality);
 }
 
 WebGLId GLHelper::CompileShaderFromSource(
-    const WebKit::WGC3Dchar* source,
-    WebKit::WGC3Denum type) {
+    const blink::WGC3Dchar* source,
+    blink::WGC3Denum type) {
   ScopedShader shader(context_, context_->createShader(type));
   context_->shaderSource(shader, source);
   context_->compileShader(shader);
-  WebKit::WGC3Dint compile_status = 0;
+  blink::WGC3Dint compile_status = 0;
   context_->getShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     LOG(ERROR) << std::string(context_->getShaderInfoLog(shader).utf8());
     return 0;
   }
   return shader.Detach();
 }
 
 void GLHelper::InitCopyTextToImpl() {
   // Lazily initialize |copy_texture_to_impl_|
   if (!copy_texture_to_impl_)
     copy_texture_to_impl_.reset(
         new CopyTextureToImpl(context_, context_support_, this));
 }
 
 void GLHelper::InitScalerImpl() {
   // Lazily initialize |scaler_impl_|
   if (!scaler_impl_)
     scaler_impl_.reset(new GLHelperScaling(context_, this));
 }
 
-WebKit::WGC3Dint GLHelper::MaxDrawBuffers() {
+blink::WGC3Dint GLHelper::MaxDrawBuffers() {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->MaxDrawBuffers();
 }
 
-void GLHelper::CopySubBufferDamage(WebKit::WebGLId texture,
-                                   WebKit::WebGLId previous_texture,
+void GLHelper::CopySubBufferDamage(blink::WebGLId texture,
+                                   blink::WebGLId previous_texture,
                                    const SkRegion& new_damage,
                                    const SkRegion& old_damage) {
   SkRegion region(old_damage);
   if (region.op(new_damage, SkRegion::kDifference_Op)) {
     ScopedFramebuffer dst_framebuffer(context_,
                                       context_->createFramebuffer());
     ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(context_,
                                                                dst_framebuffer);
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
     context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                    GL_COLOR_ATTACHMENT0,
                                    GL_TEXTURE_2D,
                                    previous_texture,
                                    0);
     for (SkRegion::Iterator it(region); !it.done(); it.next()) {
       const SkIRect& rect = it.rect();
       context_->copyTexSubImage2D(GL_TEXTURE_2D, 0,
                                   rect.x(), rect.y(),
                                   rect.x(), rect.y(),
                                   rect.width(), rect.height());
     }
     context_->flush();
   }
 }
 
-WebKit::WebGLId GLHelper::CreateTexture() {
-  WebKit::WebGLId texture = context_->createTexture();
+blink::WebGLId GLHelper::CreateTexture() {
+  blink::WebGLId texture = context_->createTexture();
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_,
                                                              texture);
   context_->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   context_->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   context_->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   context_->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   return texture;
 }
 
-WebKit::WebGLId GLHelper::ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
+blink::WebGLId GLHelper::ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
                                                   uint32 sync_point) {
   if (mailbox.IsZero())
     return 0;
   if (sync_point)
     context_->waitSyncPoint(sync_point);
-  WebKit::WebGLId texture = CreateTexture();
+  blink::WebGLId texture = CreateTexture();
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_,
                                                              texture);
   context_->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   return texture;
 }
 
-void GLHelper::ResizeTexture(WebKit::WebGLId texture, const gfx::Size& size) {
+void GLHelper::ResizeTexture(blink::WebGLId texture, const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->texImage2D(GL_TEXTURE_2D, 0, GL_RGB,
                        size.width(), size.height(), 0,
                        GL_RGB, GL_UNSIGNED_BYTE, NULL);
 }
 
-void GLHelper::CopyTextureSubImage(WebKit::WebGLId texture,
+void GLHelper::CopyTextureSubImage(blink::WebGLId texture,
                                    const gfx::Rect& rect) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->copyTexSubImage2D(GL_TEXTURE_2D, 0,
                               rect.x(), rect.y(),
                               rect.x(), rect.y(), rect.width(), rect.height());
 }
 
-void GLHelper::CopyTextureFullImage(WebKit::WebGLId texture,
+void GLHelper::CopyTextureFullImage(blink::WebGLId texture,
                                     const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->copyTexImage2D(GL_TEXTURE_2D, 0,
                            GL_RGB,
                            0, 0,
                            size.width(), size.height(), 0);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackPlane(
     TextureFrameBufferPair* source,
@@ skipping 222 matching lines @@
     // pass, which pass1_shader_ can do just as well, so let's skip
     // the actual scaling in that case.
     texture = mailbox_texture;
   } else {
     // Scale texture to right size.
     scaler_.Scale(mailbox_texture);
     texture = scaler_.texture();
   }
 
 
-  std::vector<WebKit::WebGLId> outputs(2);
+  std::vector<blink::WebGLId> outputs(2);
   // Convert the scaled texture in to Y, U and V planes.
   outputs[0] = y_.texture();
   outputs[1] = uv_;
   pass1_shader_->Execute(texture, outputs);
 
   context_->deleteTexture(mailbox_texture);
 
   outputs[0] = u_.texture();
   outputs[1] = v_.texture();
   pass2_shader_->Execute(uv_, outputs);
@@ skipping 78 matching lines @@
       quality,
       src_size,
       src_subrect,
       dst_size,
       dst_subrect,
       flip_vertically,
       use_mrt);
 }
 
 }  // namespace content