Move gl_helper to content/browser/compositor

content/browser/compositor/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 "content/browser/compositor/gl_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.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 "base/trace_event/trace_event.h"
-#include "content/common/gpu/client/gl_helper_readback_support.h"
-#include "content/common/gpu/client/gl_helper_scaling.h"
+#include "content/browser/compositor/gl_helper_readback_support.h"
+#include "content/browser/compositor/gl_helper_scaling.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ScopedFlush);
 };
 
 // Helper class for allocating and holding an RGBA texture of a given
 // size and an associated framebuffer.
 class TextureFrameBufferPair {
  public:
   TextureFrameBufferPair(GLES2Interface* gl, gfx::Size size)
       : texture_(gl), framebuffer_(gl), size_(size) {
     content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, texture_);
-    gl->TexImage2D(GL_TEXTURE_2D,
-                   0,
-                   GL_RGBA,
-                   size.width(),
-                   size.height(),
-                   0,
-                   GL_RGBA,
-                   GL_UNSIGNED_BYTE,
-                   NULL);
+    gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
+                   GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     content::ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
         gl, framebuffer_);
-    gl->FramebufferTexture2D(
-        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_, 0);
+    gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                             GL_TEXTURE_2D, texture_, 0);
   }
 
   GLuint texture() const { return texture_.id(); }
   GLuint framebuffer() const { return framebuffer_.id(); }
   gfx::Size size() const { return size_; }
 
  private:
   content::ScopedTexture texture_;
   content::ScopedFramebuffer framebuffer_;
   gfx::Size size_;
@@ skipping 167 matching lines @@
    public:
     FinishRequestHelper() {}
     ~FinishRequestHelper() {
       while (!requests_.empty()) {
         Request* request = requests_.front();
         requests_.pop();
         request->callback.Run(request->result);
         delete request;
       }
     }
-    void Add(Request* r) {
-      requests_.push(r);
-    }
+    void Add(Request* r) { requests_.push(r); }
+
    private:
     std::queue<Request*> requests_;
     DISALLOW_COPY_AND_ASSIGN(FinishRequestHelper);
   };
 
   // A readback pipeline that also converts the data to YUV before
   // reading it back.
   class ReadbackYUVImpl : public ReadbackYUVInterface {
    public:
     ReadbackYUVImpl(GLES2Interface* gl,
@@ skipping 92 matching lines @@
   // useful data.
   // If swizzle is set to true, the transformed pixels are reordered:
   // R1G1B1A1 R2G2B2A2 R3G3B3A3 R4G4B4A4 -> X3X2X1X4.
   GLuint EncodeTextureAsGrayscale(GLuint src_texture,
                                   const gfx::Size& src_size,
                                   gfx::Size* const encoded_texture_size,
                                   bool vertically_flip_texture,
                                   bool swizzle);
 
   static void nullcallback(bool success) {}
-  void ReadbackDone(Request *request, int bytes_per_pixel);
+  void ReadbackDone(Request* request, int bytes_per_pixel);
   void FinishRequest(Request* request,
                      bool result,
                      FinishRequestHelper* helper);
   void CancelRequests();
 
   static const float kRGBtoYColorWeights[];
   static const float kRGBtoUColorWeights[];
   static const float kRGBtoVColorWeights[];
   static const float kRGBtoGrayscaleColorWeights[];
 
   GLES2Interface* gl_;
   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_;
   GLint 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();
-  return scaler_impl_->CreateScaler(quality,
-                                    src_size,
-                                    src_subrect,
-                                    dst_size,
-                                    vertically_flip_texture,
-                                    swizzle);
+  return scaler_impl_->CreateScaler(quality, src_size, src_subrect, dst_size,
+                                    vertically_flip_texture, swizzle);
 }
 
 GLuint GLHelper::CopyTextureToImpl::ScaleTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle,
     SkColorType color_type,
     GLHelper::ScalerQuality quality) {
   GLuint dst_texture = 0u;
   gl_->GenTextures(1, &dst_texture);
   {
     GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE;
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
 
     // Use GL_RGBA for destination/temporary texture unless we're working with
     // 16-bit data
     if (color_type == kRGB_565_SkColorType) {
       format = GL_RGB;
       type = GL_UNSIGNED_SHORT_5_6_5;
     }
 
-    gl_->TexImage2D(GL_TEXTURE_2D,
-                    0,
-                    format,
-                    dst_size.width(),
-                    dst_size.height(),
-                    0,
-                    format,
-                    type,
-                    NULL);
+    gl_->TexImage2D(GL_TEXTURE_2D, 0, format, dst_size.width(),
+                    dst_size.height(), 0, format, type, NULL);
   }
   scoped_ptr<ScalerInterface> scaler(
-      helper_->CreateScaler(quality,
-                            src_size,
-                            src_subrect,
-                            dst_size,
-                            vertically_flip_texture,
-                            swizzle));
+      helper_->CreateScaler(quality, src_size, src_subrect, dst_size,
+                            vertically_flip_texture, swizzle));
   scaler->Scale(src_texture, dst_texture);
   return dst_texture;
 }
 
 GLuint GLHelper::CopyTextureToImpl::EncodeTextureAsGrayscale(
     GLuint src_texture,
     const gfx::Size& src_size,
     gfx::Size* const encoded_texture_size,
     bool vertically_flip_texture,
     bool swizzle) {
   GLuint dst_texture = 0u;
   gl_->GenTextures(1, &dst_texture);
   // The size of the encoded texture.
   *encoded_texture_size =
       gfx::Size((src_size.width() + 3) / 4, src_size.height());
   {
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
-    gl_->TexImage2D(GL_TEXTURE_2D,
-                    0,
-                    GL_RGBA,
-                    encoded_texture_size->width(),
-                    encoded_texture_size->height(),
-                    0,
-                    GL_RGBA,
-                    GL_UNSIGNED_BYTE,
-                    NULL);
+    gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, encoded_texture_size->width(),
+                    encoded_texture_size->height(), 0, GL_RGBA,
+                    GL_UNSIGNED_BYTE, NULL);
   }
 
   helper_->InitScalerImpl();
   scoped_ptr<ScalerInterface> grayscale_scaler(
       helper_->scaler_impl_.get()->CreatePlanarScaler(
           src_size,
           gfx::Rect(0, 0, (src_size.width() + 3) & ~3, src_size.height()),
-          *encoded_texture_size,
-          vertically_flip_texture,
-          swizzle,
+          *encoded_texture_size, vertically_flip_texture, swizzle,
           kRGBtoGrayscaleColorWeights));
   grayscale_scaler->Scale(src_texture, dst_texture);
   return dst_texture;
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackAsync(
     const gfx::Size& dst_size,
     int32_t bytes_per_row,
     int32_t row_stride_bytes,
     unsigned char* out,
     GLenum format,
     GLenum type,
     size_t bytes_per_pixel,
     const base::Callback<void(bool)>& callback) {
   TRACE_EVENT0("gpu.capture", "GLHelper::CopyTextureToImpl::ReadbackAsync");
   Request* request =
       new Request(dst_size, bytes_per_row, row_stride_bytes, out, callback);
   request_queue_.push(request);
   request->buffer = 0u;
 
   gl_->GenBuffers(1, &request->buffer);
   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer);
   gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                  bytes_per_pixel * dst_size.GetArea(),
-                  NULL,
-                  GL_STREAM_READ);
+                  bytes_per_pixel * dst_size.GetArea(), NULL, GL_STREAM_READ);
 
   request->query = 0u;
   gl_->GenQueriesEXT(1, &request->query);
   gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, request->query);
-  gl_->ReadPixels(0,
-                  0,
-                  dst_size.width(),
-                  dst_size.height(),
-                  format,
-                  type,
+  gl_->ReadPixels(0, 0, dst_size.width(), dst_size.height(), format, type,
                   NULL);
   gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
   context_support_->SignalQuery(
-      request->query,
-      base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(),
-                 request, bytes_per_pixel));
+      request->query, base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(),
+                                 request, bytes_per_pixel));
 }
 
 void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   GLenum format, type;
   size_t bytes_per_pixel;
   SkColorType readback_color_type = out_color_type;
   // Single-component textures are not supported by all GPUs, so  we implement
   // kAlpha_8_SkColorType support here via a special encoding (see below) using
   // a 32-bit texture to represent an 8-bit image.
   // Thus we use generic 32-bit readback in this case.
   if (out_color_type == kAlpha_8_SkColorType) {
     readback_color_type = kRGBA_8888_SkColorType;
   }
 
-  FormatSupport supported = GetReadbackConfig(
-      readback_color_type, true, &format, &type, &bytes_per_pixel);
+  FormatSupport supported = GetReadbackConfig(readback_color_type, true,
+                                              &format, &type, &bytes_per_pixel);
 
   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
     callback.Run(false);
     return;
   }
 
   GLuint texture = src_texture;
 
   // Scale texture if needed
   // Optimization: SCALER_QUALITY_FAST is just a single bilinear pass, which we
   // can do just as well in EncodeTextureAsGrayscale, which we will do if
   // out_color_type is kAlpha_8_SkColorType, so let's skip the scaling step
   // in that case.
   bool scale_texture = out_color_type != kAlpha_8_SkColorType ||
                        quality != GLHelper::SCALER_QUALITY_FAST;
   if (scale_texture) {
     // Don't swizzle during the scale step for kAlpha_8_SkColorType.
     // We will swizzle in the encode step below if needed.
     bool scale_swizzle = out_color_type == kAlpha_8_SkColorType
                              ? false
                              : supported == GLHelperReadbackSupport::SWIZZLE;
-    texture =
-        ScaleTexture(src_texture,
-                     src_size,
-                     src_subrect,
-                     dst_size,
-                     true,
-                     scale_swizzle,
-                     out_color_type == kAlpha_8_SkColorType ? kN32_SkColorType
-                                                            : out_color_type,
-                     quality);
+    texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size, true,
+                           scale_swizzle, out_color_type == kAlpha_8_SkColorType
+                                              ? kN32_SkColorType
+                                              : out_color_type,
+                           quality);
     DCHECK(texture);
   }
 
   gfx::Size readback_texture_size = dst_size;
   // Encode texture to grayscale if needed.
   if (out_color_type == kAlpha_8_SkColorType) {
     // Do the vertical flip here if we haven't already done it when we scaled
     // the texture.
     bool encode_as_grayscale_vertical_flip = !scale_texture;
     // EncodeTextureAsGrayscale by default creates a texture which should be
     // read back as RGBA, so need to swizzle if the readback format is BGRA.
     bool encode_as_grayscale_swizzle = format == GL_BGRA_EXT;
-    GLuint tmp_texture =
-        EncodeTextureAsGrayscale(texture,
-                                 dst_size,
-                                 &readback_texture_size,
-                                 encode_as_grayscale_vertical_flip,
-                                 encode_as_grayscale_swizzle);
+    GLuint tmp_texture = EncodeTextureAsGrayscale(
+        texture, dst_size, &readback_texture_size,
+        encode_as_grayscale_vertical_flip, encode_as_grayscale_swizzle);
     // If the scaled texture was created - delete it
     if (scale_texture)
       gl_->DeleteTextures(1, &texture);
     texture = tmp_texture;
     DCHECK(texture);
   }
 
   // Readback the pixels of the resulting texture
   ScopedFramebuffer dst_framebuffer(gl_);
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
-                            GL_COLOR_ATTACHMENT0,
-                            GL_TEXTURE_2D,
-                            texture,
-                            0);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            texture, 0);
 
   int32_t bytes_per_row = out_color_type == kAlpha_8_SkColorType
                               ? dst_size.width()
                               : dst_size.width() * bytes_per_pixel;
 
-  ReadbackAsync(readback_texture_size,
-                bytes_per_row,
-                bytes_per_row,
-                out,
-                format,
-                type,
-                bytes_per_pixel,
-                callback);
+  ReadbackAsync(readback_texture_size, bytes_per_row, bytes_per_row, out,
+                format, type, bytes_per_pixel, callback);
   gl_->DeleteTextures(1, &texture);
 }
 
-void GLHelper::CopyTextureToImpl::ReadbackTextureSync(
-    GLuint texture,
-    const gfx::Rect& src_rect,
-    unsigned char* out,
-    SkColorType color_type) {
+void GLHelper::CopyTextureToImpl::ReadbackTextureSync(GLuint texture,
+                                                      const gfx::Rect& src_rect,
+                                                      unsigned char* out,
+                                                      SkColorType color_type) {
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport supported =
       GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel);
   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
     return;
   }
 
   ScopedFramebuffer dst_framebuffer(gl_);
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->FramebufferTexture2D(
-      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
-  gl_->ReadPixels(src_rect.x(),
-                  src_rect.y(),
-                  src_rect.width(),
-                  src_rect.height(),
-                  format,
-                  type,
-                  out);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            texture, 0);
+  gl_->ReadPixels(src_rect.x(), src_rect.y(), src_rect.width(),
+                  src_rect.height(), format, type, out);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
     GLuint texture,
     const gfx::Size& dst_size,
     unsigned char* out,
     SkColorType color_type,
     const base::Callback<void(bool)>& callback) {
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport supported =
       GetReadbackConfig(color_type, false, &format, &type, &bytes_per_pixel);
   if (supported == GLHelperReadbackSupport::NOT_SUPPORTED) {
     callback.Run(false);
     return;
   }
 
   ScopedFramebuffer dst_framebuffer(gl_);
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
-                            GL_COLOR_ATTACHMENT0,
-                            GL_TEXTURE_2D,
-                            texture,
-                            0);
-  ReadbackAsync(dst_size,
-                dst_size.width() * bytes_per_pixel,
-                dst_size.width() * bytes_per_pixel,
-                out,
-                format,
-                type,
-                bytes_per_pixel,
-                callback);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            texture, 0);
+  ReadbackAsync(dst_size, dst_size.width() * bytes_per_pixel,
+                dst_size.width() * bytes_per_pixel, out, format, type,
+                bytes_per_pixel, callback);
 }
 
 GLuint GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
     GLuint 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,
-                      false,
+  return ScaleTexture(src_texture, src_size, gfx::Rect(src_size), dst_size,
+                      vertically_flip_texture, false,
                       kRGBA_8888_SkColorType,  // GL_RGBA
                       quality);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request,
                                                int bytes_per_pixel) {
   TRACE_EVENT0("gpu.capture",
                "GLHelper::CopyTextureToImpl::CheckReadbackFramebufferComplete");
   finished_request->done = true;
 
@@ skipping 82 matching lines @@
 void GLHelper::CropScaleReadbackAndCleanTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   InitCopyTextToImpl();
-  copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(src_texture,
-                                                          src_size,
-                                                          src_subrect,
-                                                          dst_size,
-                                                          out,
-                                                          out_color_type,
-                                                          callback,
-                                                          quality);
+  copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(
+      src_texture, src_size, src_subrect, dst_size, out, out_color_type,
+      callback, quality);
 }
 
 void GLHelper::CropScaleReadbackAndCleanMailbox(
     const gpu::Mailbox& src_mailbox,
     const gpu::SyncToken& sync_token,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_token);
-  CropScaleReadbackAndCleanTexture(mailbox_texture,
-                                   src_size,
-                                   src_subrect,
-                                   dst_size,
-                                   out,
-                                   out_color_type,
-                                   callback,
+  CropScaleReadbackAndCleanTexture(mailbox_texture, src_size, src_subrect,
+                                   dst_size, out, out_color_type, callback,
                                    quality);
   gl_->DeleteTextures(1, &mailbox_texture);
 }
 
 void GLHelper::ReadbackTextureSync(GLuint texture,
                                    const gfx::Rect& src_rect,
                                    unsigned char* out,
                                    SkColorType format) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->ReadbackTextureSync(texture, src_rect, out, format);
 }
 
 void GLHelper::ReadbackTextureAsync(
     GLuint texture,
     const gfx::Size& dst_size,
     unsigned char* out,
     SkColorType color_type,
     const base::Callback<void(bool)>& callback) {
   InitCopyTextToImpl();
-  copy_texture_to_impl_->ReadbackTextureAsync(texture,
-                                              dst_size,
-                                              out,
-                                              color_type,
-                                              callback);
+  copy_texture_to_impl_->ReadbackTextureAsync(texture, dst_size, out,
+                                              color_type, callback);
 }
 
 GLuint GLHelper::CopyTexture(GLuint texture, const gfx::Size& size) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(
       texture, size, size, false, GLHelper::SCALER_QUALITY_FAST);
 }
 
 GLuint GLHelper::CopyAndScaleTexture(GLuint texture,
                                      const gfx::Size& src_size,
@@ skipping 11 matching lines @@
   gl_->ShaderSource(shader, 1, &source, &length);
   gl_->CompileShader(shader);
   GLint compile_status = 0;
   gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     GLint log_length = 0;
     gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
     if (log_length) {
       scoped_ptr<GLchar[]> log(new GLchar[log_length]);
       GLsizei returned_log_length = 0;
-      gl_->GetShaderInfoLog(
-          shader, log_length, &returned_log_length, log.get());
+      gl_->GetShaderInfoLog(shader, log_length, &returned_log_length,
+                            log.get());
       LOG(ERROR) << std::string(log.get(), returned_log_length);
     }
     gl_->DeleteShader(shader);
     return 0;
   }
   return shader;
 }
 
 void GLHelper::InitCopyTextToImpl() {
   // Lazily initialize |copy_texture_to_impl_|
@@ skipping 79 matching lines @@
     return 0;
   if (sync_token.HasData())
     WaitSyncToken(sync_token);
   GLuint texture =
       gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   return texture;
 }
 
 void GLHelper::ResizeTexture(GLuint texture, const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->TexImage2D(GL_TEXTURE_2D,
-                  0,
-                  GL_RGB,
-                  size.width(),
-                  size.height(),
-                  0,
-                  GL_RGB,
-                  GL_UNSIGNED_BYTE,
-                  NULL);
+  gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0,
+                  GL_RGB, GL_UNSIGNED_BYTE, NULL);
 }
 
 void GLHelper::CopyTextureSubImage(GLuint texture, const gfx::Rect& rect) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->CopyTexSubImage2D(GL_TEXTURE_2D,
-                         0,
-                         rect.x(),
-                         rect.y(),
-                         rect.x(),
-                         rect.y(),
-                         rect.width(),
-                         rect.height());
+  gl_->CopyTexSubImage2D(GL_TEXTURE_2D, 0, rect.x(), rect.y(), rect.x(),
+                         rect.y(), rect.width(), rect.height());
 }
 
 void GLHelper::CopyTextureFullImage(GLuint texture, const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->CopyTexImage2D(
-      GL_TEXTURE_2D, 0, GL_RGB, 0, 0, size.width(), size.height(), 0);
+  gl_->CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, size.width(),
+                      size.height(), 0);
 }
 
 void GLHelper::Flush() {
   gl_->Flush();
 }
 
 void GLHelper::InsertOrderingBarrier() {
   gl_->OrderingBarrierCHROMIUM();
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackPlane(
     TextureFrameBufferPair* source,
     const scoped_refptr<media::VideoFrame>& target,
     int plane,
     int size_shift,
     const gfx::Rect& paste_rect,
     ReadbackSwizzle swizzle,
     const base::Callback<void(bool)>& callback) {
   gl_->BindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
   const size_t offset = target->stride(plane) * (paste_rect.y() >> size_shift) +
-      (paste_rect.x() >> size_shift);
-  ReadbackAsync(source->size(),
-                paste_rect.width() >> size_shift,
-                target->stride(plane),
-                target->data(plane) + offset,
+                        (paste_rect.x() >> size_shift);
+  ReadbackAsync(source->size(), paste_rect.width() >> size_shift,
+                target->stride(plane), target->data(plane) + offset,
                 (swizzle == kSwizzleBGRA) ? GL_BGRA_EXT : GL_RGBA,
-                GL_UNSIGNED_BYTE,
-                4,
-                callback);
+                GL_UNSIGNED_BYTE, 4, callback);
 }
 
 const float GLHelper::CopyTextureToImpl::kRGBtoYColorWeights[] = {
     0.257f, 0.504f, 0.098f, 0.0625f};
 const float GLHelper::CopyTextureToImpl::kRGBtoUColorWeights[] = {
     -0.148f, -0.291f, 0.439f, 0.5f};
 const float GLHelper::CopyTextureToImpl::kRGBtoVColorWeights[] = {
     0.439f, -0.368f, -0.071f, 0.5f};
 const float GLHelper::CopyTextureToImpl::kRGBtoGrayscaleColorWeights[] = {
     0.213f, 0.715f, 0.072f, 0.0f};
@@ skipping 17 matching lines @@
       scaler_(gl,
               scaler_impl->CreateScaler(quality,
                                         src_size,
                                         src_subrect,
                                         dst_size,
                                         flip_vertically,
                                         false)),
       y_(gl,
          scaler_impl->CreatePlanarScaler(
              dst_size,
-             gfx::Rect(0,
-                       0,
-                       (dst_size.width() + 3) & ~3,
-                       dst_size.height()),
+             gfx::Rect(0, 0, (dst_size.width() + 3) & ~3, dst_size.height()),
              gfx::Size((dst_size.width() + 3) / 4, dst_size.height()),
              false,
              (swizzle == kSwizzleBGRA),
              kRGBtoYColorWeights)),
       u_(gl,
          scaler_impl->CreatePlanarScaler(
              dst_size,
              gfx::Rect(0,
                        0,
                        (dst_size.width() + 7) & ~7,
                        (dst_size.height() + 1) & ~1),
-             gfx::Size((dst_size.width() + 7) / 8,
-                       (dst_size.height() + 1) / 2),
+             gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2),
              false,
              (swizzle == kSwizzleBGRA),
              kRGBtoUColorWeights)),
       v_(gl,
          scaler_impl->CreatePlanarScaler(
              dst_size,
              gfx::Rect(0,
                        0,
                        (dst_size.width() + 7) & ~7,
                        (dst_size.height() + 1) & ~1),
-             gfx::Size((dst_size.width() + 7) / 8,
-                       (dst_size.height() + 1) / 2),
+             gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2),
              false,
              (swizzle == kSwizzleBGRA),
              kRGBtoVColorWeights)) {
   DCHECK(!(dst_size.width() & 1));
   DCHECK(!(dst_size.height() & 1));
 }
 
 static void CallbackKeepingVideoFrameAlive(
     scoped_refptr<media::VideoFrame> video_frame,
     const base::Callback<void(bool)>& callback,
@@ skipping 24 matching lines @@
 
   const gfx::Rect paste_rect(paste_location, dst_size_);
   if (!target->visible_rect().Contains(paste_rect)) {
     LOG(DFATAL) << "Paste rect not inside VideoFrame's visible rect!";
     callback.Run(false);
     return;
   }
 
   // Read back planes, one at a time. Keep the video frame alive while doing the
   // readback.
-  copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(),
-                            target,
-                            media::VideoFrame::kYPlane,
-                            0,
-                            paste_rect,
-                            swizzle_,
+  copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(), target,
+                            media::VideoFrame::kYPlane, 0, paste_rect, swizzle_,
                             base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(),
-                            target,
-                            media::VideoFrame::kUPlane,
-                            1,
-                            paste_rect,
-                            swizzle_,
+  copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(), target,
+                            media::VideoFrame::kUPlane, 1, paste_rect, swizzle_,
                             base::Bind(&nullcallback));
   copy_impl_->ReadbackPlane(
-      v_.texture_and_framebuffer(),
-      target,
-      media::VideoFrame::kVPlane,
-      1,
-      paste_rect,
-      swizzle_,
+      v_.texture_and_framebuffer(), target, media::VideoFrame::kVPlane, 1,
+      paste_rect, swizzle_,
       base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
   media::LetterboxYUV(target.get(), paste_rect);
 }
 
 // YUV readback constructors. Initiates the main scaler pipeline and
 // one planar scaler for each of the Y, U and V planes.
 GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV_MRT(
     GLES2Interface* gl,
     CopyTextureToImpl* copy_impl,
@@ skipping 18 matching lines @@
                                         false)),
       pass1_shader_(scaler_impl->CreateYuvMrtShader(
           dst_size,
           gfx::Rect(0, 0, (dst_size.width() + 3) & ~3, dst_size.height()),
           gfx::Size((dst_size.width() + 3) / 4, dst_size.height()),
           flip_vertically,
           (swizzle == kSwizzleBGRA),
           GLHelperScaling::SHADER_YUV_MRT_PASS1)),
       pass2_shader_(scaler_impl->CreateYuvMrtShader(
           gfx::Size((dst_size.width() + 3) / 4, dst_size.height()),
-          gfx::Rect(0,
-                    0,
-                    (dst_size.width() + 7) / 8 * 2,
-                    dst_size.height()),
-          gfx::Size((dst_size.width() + 7) / 8,
-                    (dst_size.height() + 1) / 2),
+          gfx::Rect(0, 0, (dst_size.width() + 7) / 8 * 2, dst_size.height()),
+          gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2),
           false,
           (swizzle == kSwizzleBGRA),
           GLHelperScaling::SHADER_YUV_MRT_PASS2)),
       y_(gl, gfx::Size((dst_size.width() + 3) / 4, dst_size.height())),
       uv_(gl),
       u_(gl,
-         gfx::Size((dst_size.width() + 7) / 8,
-                   (dst_size.height() + 1) / 2)),
+         gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2)),
       v_(gl,
-         gfx::Size((dst_size.width() + 7) / 8,
-                   (dst_size.height() + 1) / 2)) {
+         gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2)) {
   DCHECK(!(dst_size.width() & 1));
   DCHECK(!(dst_size.height() & 1));
 
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, uv_);
-  gl->TexImage2D(GL_TEXTURE_2D,
-                 0,
-                 GL_RGBA,
-                 (dst_size.width() + 3) / 4,
-                 dst_size.height(),
-                 0,
-                 GL_RGBA,
-                 GL_UNSIGNED_BYTE,
-                 NULL);
+  gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (dst_size.width() + 3) / 4,
+                 dst_size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     const gpu::SyncToken& sync_token,
     const scoped_refptr<media::VideoFrame>& target,
     const gfx::Point& paste_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!(paste_location.x() & 1));
   DCHECK(!(paste_location.y() & 1));
@@ skipping 26 matching lines @@
   pass2_shader_->Execute(uv_, outputs);
 
   const gfx::Rect paste_rect(paste_location, dst_size_);
   if (!target->visible_rect().Contains(paste_rect)) {
     LOG(DFATAL) << "Paste rect not inside VideoFrame's visible rect!";
     callback.Run(false);
     return;
   }
 
   // Read back planes, one at a time.
-  copy_impl_->ReadbackPlane(&y_,
-                            target,
-                            media::VideoFrame::kYPlane,
-                            0,
-                            paste_rect,
-                            swizzle_,
-                            base::Bind(&nullcallback));
-  copy_impl_->ReadbackPlane(&u_,
-                            target,
-                            media::VideoFrame::kUPlane,
-                            1,
-                            paste_rect,
-                            swizzle_,
-                            base::Bind(&nullcallback));
+  copy_impl_->ReadbackPlane(&y_, target, media::VideoFrame::kYPlane, 0,
+                            paste_rect, swizzle_, base::Bind(&nullcallback));
+  copy_impl_->ReadbackPlane(&u_, target, media::VideoFrame::kUPlane, 1,
+                            paste_rect, swizzle_, base::Bind(&nullcallback));
   copy_impl_->ReadbackPlane(
-      &v_,
-      target,
-      media::VideoFrame::kVPlane,
-      1,
-      paste_rect,
-      swizzle_,
+      &v_, target, media::VideoFrame::kVPlane, 1, paste_rect, swizzle_,
       base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
   media::LetterboxYUV(target.get(), paste_rect);
 }
 
 bool GLHelper::IsReadbackConfigSupported(SkColorType color_type) {
   DCHECK(readback_support_.get());
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport support = readback_support_->GetReadbackConfig(
       color_type, false, &format, &type, &bytes_per_pixel);
 
   return (support == GLHelperReadbackSupport::SUPPORTED);
 }
 
 ReadbackYUVInterface* GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV(
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   helper_->InitScalerImpl();
   // Just query if the best readback configuration needs a swizzle In
   // ReadbackPlane() we will choose GL_RGBA/GL_BGRA_EXT based on swizzle
   GLenum format, type;
   size_t bytes_per_pixel;
-  FormatSupport supported = GetReadbackConfig(
-      kRGBA_8888_SkColorType, true, &format, &type, &bytes_per_pixel);
+  FormatSupport supported = GetReadbackConfig(kRGBA_8888_SkColorType, true,
+                                              &format, &type, &bytes_per_pixel);
   DCHECK((format == GL_RGBA || format == GL_BGRA_EXT) &&
          type == GL_UNSIGNED_BYTE);
 
   ReadbackSwizzle swizzle = kSwizzleNone;
   if (supported == GLHelperReadbackSupport::SWIZZLE)
     swizzle = kSwizzleBGRA;
 
   if (max_draw_buffers_ >= 2 && use_mrt) {
-    return new ReadbackYUV_MRT(gl_,
-                               this,
-                               helper_->scaler_impl_.get(),
-                               quality,
-                               src_size,
-                               src_subrect,
-                               dst_size,
-                               flip_vertically,
+    return new ReadbackYUV_MRT(gl_, this, helper_->scaler_impl_.get(), quality,
+                               src_size, src_subrect, dst_size, flip_vertically,
                                swizzle);
   }
-  return new ReadbackYUVImpl(gl_,
-                             this,
-                             helper_->scaler_impl_.get(),
-                             quality,
-                             src_size,
-                             src_subrect,
-                             dst_size,
-                             flip_vertically,
+  return new ReadbackYUVImpl(gl_, this, helper_->scaler_impl_.get(), quality,
+                             src_size, src_subrect, dst_size, flip_vertically,
                              swizzle);
 }
 
 ReadbackYUVInterface* GLHelper::CreateReadbackPipelineYUV(
     ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   InitCopyTextToImpl();
-  return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
-                                                          src_size,
-                                                          src_subrect,
-                                                          dst_size,
-                                                          flip_vertically,
-                                                          use_mrt);
+  return copy_texture_to_impl_->CreateReadbackPipelineYUV(
+      quality, src_size, src_subrect, dst_size, flip_vertically, use_mrt);
 }
 
 }  // namespace content