Convert //cc from scoped_ptr to std::unique_ptr.

cc/output/gl_renderer.h

 // Copyright 2010 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 CC_OUTPUT_GL_RENDERER_H_
 #define CC_OUTPUT_GL_RENDERER_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 31 matching lines @@
 class TextureMailboxDeleter;
 class StaticGeometryBinding;
 class DynamicGeometryBinding;
 class ScopedEnsureFramebufferAllocation;
 
 // Class that handles drawing of composited render layers using GL.
 class CC_EXPORT GLRenderer : public DirectRenderer {
  public:
   class ScopedUseGrContext;
 
-  static scoped_ptr<GLRenderer> Create(
+  static std::unique_ptr<GLRenderer> Create(
       RendererClient* client,
       const RendererSettings* settings,
       OutputSurface* output_surface,
       ResourceProvider* resource_provider,
       TextureMailboxDeleter* texture_mailbox_deleter,
       int highp_threshold_min);
 
   ~GLRenderer() override;
 
   const RendererCapabilitiesImpl& Capabilities() const override;
@@ skipping 18 matching lines @@
 
   bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
 
   const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; }
   const StaticGeometryBinding* SharedGeometry() const {
     return shared_geometry_.get();
   }
 
   void GetFramebufferPixelsAsync(const DrawingFrame* frame,
                                  const gfx::Rect& rect,
-                                 scoped_ptr<CopyOutputRequest> request);
+                                 std::unique_ptr<CopyOutputRequest> request);
   void GetFramebufferTexture(unsigned texture_id,
                              ResourceFormat texture_format,
                              const gfx::Rect& device_rect);
   void ReleaseRenderPassTextures();
   enum BoundGeometry { NO_BINDING, SHARED_BINDING, CLIPPED_BINDING };
   void PrepareGeometry(BoundGeometry geometry_to_bind);
   void SetStencilEnabled(bool enabled);
   bool stencil_enabled() const { return stencil_shadow_; }
   void SetBlendEnabled(bool enabled);
   bool blend_enabled() const { return blend_shadow_; }
 
   void BindFramebufferToOutputSurface(DrawingFrame* frame) override;
   bool BindFramebufferToTexture(DrawingFrame* frame,
                                 const ScopedResource* resource) override;
   void SetScissorTestRect(const gfx::Rect& scissor_rect) override;
   void PrepareSurfaceForPass(DrawingFrame* frame,
                              SurfaceInitializationMode initialization_mode,
                              const gfx::Rect& render_pass_scissor) override;
   void DoDrawQuad(DrawingFrame* frame,
                   const class DrawQuad*,
                   const gfx::QuadF* draw_region) override;
   void BeginDrawingFrame(DrawingFrame* frame) override;
   void FinishDrawingFrame(DrawingFrame* frame) override;
   bool FlippedFramebuffer(const DrawingFrame* frame) const override;
   bool FlippedRootFramebuffer() const;
   void EnsureScissorTestEnabled() override;
   void EnsureScissorTestDisabled() override;
   void CopyCurrentRenderPassToBitmap(
       DrawingFrame* frame,
-      scoped_ptr<CopyOutputRequest> request) override;
+      std::unique_ptr<CopyOutputRequest> request) override;
   void FinishDrawingQuadList() override;
 
   // Returns true if quad requires antialiasing and false otherwise.
   static bool ShouldAntialiasQuad(const gfx::QuadF& device_layer_quad,
                                   bool clipped,
                                   bool force_aa);
 
   // Inflate the quad and fill edge array for fragment shader.
   // |local_quad| is set to inflated quad. |edge| array is filled with
   // inflated quad's edge data.
@@ skipping 30 matching lines @@
   bool CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
   void ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
   void RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode);
 
   gfx::Rect GetBackdropBoundingBoxForRenderPassQuad(
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       const gfx::Transform& contents_device_transform,
       const gfx::QuadF* clip_region,
       bool use_aa);
-  scoped_ptr<ScopedResource> GetBackdropTexture(const gfx::Rect& bounding_rect);
+  std::unique_ptr<ScopedResource> GetBackdropTexture(
+      const gfx::Rect& bounding_rect);
 
   static bool ShouldApplyBackgroundFilters(const RenderPassDrawQuad* quad);
   skia::RefPtr<SkImage> ApplyBackgroundFilters(
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       ScopedResource* background_texture,
       const gfx::RectF& rect);
 
   void DrawRenderPassQuad(DrawingFrame* frame,
                           const RenderPassDrawQuad* quadi,
@@ skipping 50 matching lines @@
                         const gfx::Transform& draw_transform,
                         const gfx::RectF& quad_rect,
                         int matrix_location);
   void SetUseProgram(unsigned program);
 
   bool MakeContextCurrent();
 
   void InitializeSharedObjects();
   void CleanupSharedObjects();
 
-  typedef base::Callback<void(scoped_ptr<CopyOutputRequest> copy_request,
+  typedef base::Callback<void(std::unique_ptr<CopyOutputRequest> copy_request,
                               bool success)>
       AsyncGetFramebufferPixelsCleanupCallback;
   void FinishedReadback(unsigned source_buffer,
                         unsigned query,
                         const gfx::Size& size);
 
   void ReinitializeGLState();
   void RestoreGLState();
   void RestoreFramebuffer(DrawingFrame* frame);
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
   using OverlayResourceLockList =
-      std::vector<scoped_ptr<ResourceProvider::ScopedReadLockGL>>;
+      std::vector<std::unique_ptr<ResourceProvider::ScopedReadLockGL>>;
   OverlayResourceLockList pending_overlay_resources_;
   std::deque<OverlayResourceLockList> swapped_overlay_resources_;
 
   RendererCapabilitiesImpl capabilities_;
 
   unsigned offscreen_framebuffer_id_;
 
-  scoped_ptr<StaticGeometryBinding> shared_geometry_;
-  scoped_ptr<DynamicGeometryBinding> clipped_geometry_;
+  std::unique_ptr<StaticGeometryBinding> shared_geometry_;
+  std::unique_ptr<DynamicGeometryBinding> clipped_geometry_;
   gfx::QuadF shared_geometry_quad_;
 
   // This block of bindings defines all of the programs used by the compositor
   // itself.  Add any new programs here to GLRendererShaderTest.
 
   // Tiled layer shaders.
   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexAlpha>
       TileProgram;
   typedef ProgramBinding<VertexShaderTileAA, FragmentShaderRGBATexClampAlphaAA>
       TileProgramAA;
@@ skipping 209 matching lines @@
   bool is_scissor_enabled_;
   bool scissor_rect_needs_reset_;
   bool stencil_shadow_;
   bool blend_shadow_;
   unsigned program_shadow_;
   TexturedQuadDrawCache draw_cache_;
   int highp_threshold_min_;
   int highp_threshold_cache_;
 
   struct PendingAsyncReadPixels;
-  std::vector<scoped_ptr<PendingAsyncReadPixels>> pending_async_read_pixels_;
+  std::vector<std::unique_ptr<PendingAsyncReadPixels>>
+      pending_async_read_pixels_;
 
-  scoped_ptr<ResourceProvider::ScopedWriteLockGL> current_framebuffer_lock_;
+  std::unique_ptr<ResourceProvider::ScopedWriteLockGL>
+      current_framebuffer_lock_;
 
   class SyncQuery;
-  std::deque<scoped_ptr<SyncQuery>> pending_sync_queries_;
-  std::deque<scoped_ptr<SyncQuery>> available_sync_queries_;
-  scoped_ptr<SyncQuery> current_sync_query_;
+  std::deque<std::unique_ptr<SyncQuery>> pending_sync_queries_;
+  std::deque<std::unique_ptr<SyncQuery>> available_sync_queries_;
+  std::unique_ptr<SyncQuery> current_sync_query_;
   bool use_sync_query_;
   bool use_blend_equation_advanced_;
   bool use_blend_equation_advanced_coherent_;
 
   SkBitmap on_demand_tile_raster_bitmap_;
   ResourceId on_demand_tile_raster_resource_id_;
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_