Introduce components/display_compositor

components/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 "content/browser/compositor/gl_helper.h"
+#include "components/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 "content/browser/compositor/gl_helper_readback_support.h"
-#include "content/browser/compositor/gl_helper_scaling.h"
+#include "components/display_compositor/gl_helper_readback_support.h"
+#include "components/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) {
-    content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, texture_);
+    display_compositor::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);
-    content::ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
-        gl, framebuffer_);
+    display_compositor::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:
-  content::ScopedTexture texture_;
-  content::ScopedFramebuffer framebuffer_;
+  display_compositor::ScopedTexture texture_;
+  display_compositor::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, content::GLHelper::ScalerInterface* scaler)
+  ScalerHolder(GLES2Interface* gl,
+               display_compositor::GLHelper::ScalerInterface* scaler)
       : texture_and_framebuffer_(gl, scaler->DstSize()), scaler_(scaler) {}
 
   void Scale(GLuint src_texture) {
     scaler_->Scale(src_texture, texture_and_framebuffer_.texture());
   }
 
-  content::GLHelper::ScalerInterface* scaler() const { return scaler_.get(); }
+  display_compositor::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<content::GLHelper::ScalerInterface> scaler_;
+  std::unique_ptr<display_compositor::GLHelper::ScalerInterface> scaler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScalerHolder);
 };
 
 }  // namespace
 
-namespace content {
+namespace display_compositor {
 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<content::GLHelperScaling::ShaderInterface> pass1_shader_;
-    std::unique_ptr<content::GLHelperScaling::ShaderInterface> pass2_shader_;
+    std::unique_ptr<display_compositor::GLHelperScaling::ShaderInterface>
+        pass1_shader_;
+    std::unique_ptr<display_compositor::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 516 matching lines @@
                              rect.width(), rect.height());
     }
     gl_->BindTexture(target, 0);
     gl_->Flush();
   }
 }
 
 GLuint GLHelper::CreateTexture() {
   GLuint texture = 0u;
   gl_->GenTextures(1, &texture);
-  content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
+  display_compositor::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) {
-  content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
+  display_compositor::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) {
-  content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
+  display_compositor::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) {
-  content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
+  display_compositor::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));
 
-  content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl, uv_);
+  display_compositor::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 content
+}  // namespace display_compositor