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

cc/output/direct_renderer.h

 // Copyright 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 CC_OUTPUT_DIRECT_RENDERER_H_
 #define CC_OUTPUT_DIRECT_RENDERER_H_
 
 #include <unordered_map>
 
 #include "base/callback.h"
@@ skipping 88 matching lines @@
                               const DrawQuad& quad,
                               const gfx::Rect& render_pass_scissor,
                               bool use_render_pass_scissor);
   bool ShouldSkipQuad(const DrawQuad& quad,
                       const gfx::Rect& render_pass_scissor);
   void SetScissorTestRectInDrawSpace(const DrawingFrame* frame,
                                      const gfx::Rect& draw_space_rect);
 
   static gfx::Size RenderPassTextureSize(const RenderPass* render_pass);
 
-  void FlushPolygons(std::deque<scoped_ptr<DrawPolygon>>* poly_list,
+  void FlushPolygons(std::deque<std::unique_ptr<DrawPolygon>>* poly_list,
                      DrawingFrame* frame,
                      const gfx::Rect& render_pass_scissor,
                      bool use_render_pass_scissor);
   void DrawRenderPassAndExecuteCopyRequests(DrawingFrame* frame,
                                             RenderPass* render_pass);
   void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
   bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
 
   virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) = 0;
   virtual bool BindFramebufferToTexture(DrawingFrame* frame,
@@ skipping 13 matching lines @@
   virtual void FinishDrawingFrame(DrawingFrame* frame) = 0;
   virtual void FinishDrawingQuadList();
   virtual bool FlippedFramebuffer(const DrawingFrame* frame) const = 0;
   virtual void EnsureScissorTestEnabled() = 0;
   virtual void EnsureScissorTestDisabled() = 0;
   virtual void DiscardBackbuffer() {}
   virtual void EnsureBackbuffer() {}
 
   virtual void CopyCurrentRenderPassToBitmap(
       DrawingFrame* frame,
-      scoped_ptr<CopyOutputRequest> request) = 0;
+      std::unique_ptr<CopyOutputRequest> request) = 0;
 
   // TODO(danakj): Just use a vector of pairs here? Hash map is way overkill.
-  std::unordered_map<RenderPassId, scoped_ptr<ScopedResource>, RenderPassIdHash>
+  std::unordered_map<RenderPassId,
+                     std::unique_ptr<ScopedResource>,
+                     RenderPassIdHash>
       render_pass_textures_;
   OutputSurface* output_surface_;
   ResourceProvider* resource_provider_;
-  scoped_ptr<OverlayProcessor> overlay_processor_;
+  std::unique_ptr<OverlayProcessor> overlay_processor_;
 
   // For use in coordinate conversion, this stores the output rect, viewport
   // rect (= unflipped version of glViewport rect), the size of target
   // framebuffer, and the current window space viewport. During a draw, this
   // stores the values for the current render pass; in between draws, they
   // retain the values for the root render pass of the last draw.
   gfx::Rect current_draw_rect_;
   gfx::Rect current_viewport_rect_;
   gfx::Size current_surface_size_;
   gfx::Rect current_window_space_viewport_;
 
  private:
   gfx::Vector2d enlarge_pass_texture_amount_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_DIRECT_RENDERER_H_