Move components/display_compositor to components/viz/display_compositor

components/viz/display_compositor/gl_helper.h

 // 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.
 
-#ifndef COMPONENTS_DISPLAY_COMPOSITOR_GL_HELPER_H_
-#define COMPONENTS_DISPLAY_COMPOSITOR_GL_HELPER_H_
+#ifndef COMPONENTS_VIZ_DISPLAY_COMPOSITOR_GL_HELPER_H_
+#define COMPONENTS_VIZ_DISPLAY_COMPOSITOR_GL_HELPER_H_
 
 #include <memory>
 
 #include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "components/display_compositor/display_compositor_export.h"
+#include "components/viz/viz_export.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace gfx {
 class Point;
 class Rect;
 class Size;
 }
 
 namespace gpu {
 class ContextSupport;
 struct Mailbox;
 }
 
 class SkRegion;
 
-namespace display_compositor {
+namespace viz {
 
 class GLHelperScaling;
 
-class DISPLAY_COMPOSITOR_EXPORT ScopedGLuint {
+class VIZ_EXPORT ScopedGLuint {
  public:
   typedef void (gpu::gles2::GLES2Interface::*GenFunc)(GLsizei n, GLuint* ids);
   typedef void (gpu::gles2::GLES2Interface::*DeleteFunc)(GLsizei n,
                                                          const GLuint* ids);
   ScopedGLuint(gpu::gles2::GLES2Interface* gl,
                GenFunc gen_func,
                DeleteFunc delete_func)
       : gl_(gl), id_(0u), delete_func_(delete_func) {
     (gl_->*gen_func)(1, &id_);
   }
@@ skipping 81 matching lines @@
   ScopedTextureBinder(gpu::gles2::GLES2Interface* gl, GLuint id)
       : ScopedBinder<Target>(gl, id, &gpu::gles2::GLES2Interface::BindTexture) {
   }
 };
 
 class ReadbackYUVInterface;
 class GLHelperReadbackSupport;
 
 // Provides higher level operations on top of the gpu::gles2::GLES2Interface
 // interfaces.
-class DISPLAY_COMPOSITOR_EXPORT GLHelper {
+class VIZ_EXPORT GLHelper {
  public:
   GLHelper(gpu::gles2::GLES2Interface* gl,
            gpu::ContextSupport* context_support);
   ~GLHelper();
 
   enum ScalerQuality {
     // Bilinear single pass, fastest possible.
     SCALER_QUALITY_FAST = 1,
 
     // Bilinear upscale + N * 50% bilinear downscales.
@@ skipping 125 matching lines @@
 
   // Force commands in the current command buffer to be executed before commands
   // in other command buffers from the same process (ie channel to the GPU
   // process).
   void InsertOrderingBarrier();
 
   // A scaler will cache all intermediate textures and programs
   // needed to scale from a specified size to a destination size.
   // If the source or destination sizes changes, you must create
   // a new scaler.
-  class DISPLAY_COMPOSITOR_EXPORT ScalerInterface {
+  class VIZ_EXPORT ScalerInterface {
    public:
     ScalerInterface() {}
     virtual ~ScalerInterface() {}
 
     // 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 Scale(GLuint source_texture, GLuint dest_texture) = 0;
     virtual const gfx::Size& SrcSize() = 0;
     virtual const gfx::Rect& SrcSubrect() = 0;
     virtual const gfx::Size& DstSize() = 0;
@@ skipping 42 matching lines @@
   void InitScalerImpl();
 
   enum ReadbackSwizzle { kSwizzleNone = 0, kSwizzleBGRA };
 
   gpu::gles2::GLES2Interface* gl_;
   gpu::ContextSupport* context_support_;
   std::unique_ptr<CopyTextureToImpl> copy_texture_to_impl_;
   std::unique_ptr<GLHelperScaling> scaler_impl_;
   std::unique_ptr<GLHelperReadbackSupport> readback_support_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(GLHelper);
 };
 
 // Similar to a ScalerInterface, a yuv readback pipeline will
 // cache a scaler and all intermediate textures and frame buffers
 // needed to scale, crop, letterbox and read back a texture from
 // the GPU into CPU-accessible RAM. A single readback pipeline
 // can handle multiple outstanding readbacks at the same time, but
 // if the source or destination sizes change, you'll need to create
 // a new readback pipeline.
-class DISPLAY_COMPOSITOR_EXPORT ReadbackYUVInterface {
+class VIZ_EXPORT ReadbackYUVInterface {
  public:
   ReadbackYUVInterface() {}
   virtual ~ReadbackYUVInterface() {}
 
   // Note that |target| must use YV12 format.  |paste_location| specifies where
   // the captured pixels that are read back will be placed in the video frame.
   // The region defined by the |paste_location| and the |dst_size| specified in
   // the call to CreateReadbackPipelineYUV() must be fully contained within
   // |target->visible_rect()|.
   virtual void 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,
                            int u_plane_row_stride_bytes,
                            unsigned char* u_plane_data,
                            int v_plane_row_stride_bytes,
                            unsigned char* v_plane_data,
                            const gfx::Point& paste_location,
                            const base::Callback<void(bool)>& callback) = 0;
   virtual GLHelper::ScalerInterface* scaler() = 0;
 };
 
-}  // namespace display_compositor
+}  // namespace viz
 
-#endif  // COMPONENTS_DISPLAY_COMPOSITOR_GL_HELPER_H_
+#endif  // COMPONENTS_VIZ_DISPLAY_COMPOSITOR_GL_HELPER_H_