Move components/display_compositor to components/viz/display_compositor

components/viz/display_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 "components/display_compositor/gl_helper.h"
+#include "components/viz/display_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 "components/display_compositor/gl_helper_readback_support.h"
-#include "components/display_compositor/gl_helper_scaling.h"
+#include "components/viz/display_compositor/gl_helper_readback_support.h"
+#include "components/viz/display_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 "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"
 
 using gpu::gles2::GLES2Interface;
@@ skipping 11 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) {
-    display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
-        gl, texture_);
+    viz::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);
-    display_compositor::ScopedFramebufferBinder<GL_FRAMEBUFFER>
-        framebuffer_binder(gl, framebuffer_);
+    viz::ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
+        gl, framebuffer_);
     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:
-  display_compositor::ScopedTexture texture_;
-  display_compositor::ScopedFramebuffer framebuffer_;
+  viz::ScopedTexture texture_;
+  viz::ScopedFramebuffer framebuffer_;
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureFrameBufferPair);
 };
 
 // Helper class for holding a scaler, a texture for the output of that
 // 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(GLES2Interface* gl,
-               display_compositor::GLHelper::ScalerInterface* scaler)
+  ScalerHolder(GLES2Interface* gl, viz::GLHelper::ScalerInterface* scaler)
       : texture_and_framebuffer_(gl, scaler->DstSize()), scaler_(scaler) {}
 
   void Scale(GLuint src_texture) {
     scaler_->Scale(src_texture, texture_and_framebuffer_.texture());
   }
 
-  display_compositor::GLHelper::ScalerInterface* scaler() const {
-    return scaler_.get();
-  }
+  viz::GLHelper::ScalerInterface* scaler() const { return scaler_.get(); }
   TextureFrameBufferPair* texture_and_framebuffer() {
     return &texture_and_framebuffer_;
   }
   GLuint texture() const { return texture_and_framebuffer_.texture(); }
 
  private:
   TextureFrameBufferPair texture_and_framebuffer_;
-  std::unique_ptr<display_compositor::GLHelper::ScalerInterface> scaler_;
+  std::unique_ptr<viz::GLHelper::ScalerInterface> scaler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScalerHolder);
 };
 
 }  // namespace
 
-namespace display_compositor {
+namespace viz {
 typedef GLHelperReadbackSupport::FormatSupport FormatSupport;
 
 // Implements GLHelper::CropScaleReadbackAndCleanTexture and encapsulates
 // the data needed for it.
 class GLHelper::CopyTextureToImpl
     : public base::SupportsWeakPtr<GLHelper::CopyTextureToImpl> {
  public:
   CopyTextureToImpl(GLES2Interface* gl,
                     gpu::ContextSupport* context_support,
                     GLHelper* helper)
@@ skipping 209 matching lines @@
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
     GLHelper::ScalerQuality quality_;
     ReadbackSwizzle swizzle_;
     ScalerHolder scaler_;
-    std::unique_ptr<display_compositor::GLHelperScaling::ShaderInterface>
-        pass1_shader_;
-    std::unique_ptr<display_compositor::GLHelperScaling::ShaderInterface>
-        pass2_shader_;
+    std::unique_ptr<GLHelperScaling::ShaderInterface> pass1_shader_;
+    std::unique_ptr<GLHelperScaling::ShaderInterface> pass2_shader_;
     TextureFrameBufferPair y_;
     ScopedTexture uv_;
     TextureFrameBufferPair u_;
     TextureFrameBufferPair v_;
 
     DISALLOW_COPY_AND_ASSIGN(ReadbackYUV_MRT);
   };
 
   // Copies the block of pixels specified with |src_subrect| from |src_texture|,
   // scales it to |dst_size|, writes it into a texture, and returns its ID.
@@ skipping 190 matching lines @@
   // 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
@@ skipping 301 matching lines @@
                              rect.width(), rect.height());
     }
     gl_->BindTexture(target, 0);
     gl_->Flush();
   }
 }
 
 GLuint GLHelper::CreateTexture() {
   GLuint texture = 0u;
   gl_->GenTextures(1, &texture);
-  display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
-      gl_, texture);
+  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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);
   return texture;
 }
 
 void GLHelper::DeleteTexture(GLuint texture_id) {
   gl_->DeleteTextures(1, &texture_id);
 }
@@ skipping 25 matching lines @@
   if (mailbox.IsZero())
     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) {
-  display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
-      gl_, texture);
+  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);
 }
 
 void GLHelper::CopyTextureSubImage(GLuint texture, const gfx::Rect& rect) {
-  display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
-      gl_, texture);
+  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());
 }
 
 void GLHelper::CopyTextureFullImage(GLuint texture, const gfx::Size& size) {
-  display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
-      gl_, texture);
+  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
   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();
@@ skipping 170 matching lines @@
           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)),
       v_(gl,
          gfx::Size((dst_size.width() + 7) / 8, (dst_size.height() + 1) / 2)) {
   DCHECK(!(dst_size.width() & 1));
   DCHECK(!(dst_size.height() & 1));
 
-  display_compositor::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl,
-                                                                        uv_);
+  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);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     const gpu::SyncToken& sync_token,
     const gfx::Rect& target_visible_rect,
     int y_plane_row_stride_bytes,
     unsigned char* y_plane_data,
@@ skipping 96 matching lines @@
     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);
 }
 
-}  // namespace display_compositor
+}  // namespace viz