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

cc/trees/layer_tree_host_impl.h

 // Copyright 2011 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_TREES_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/synced_property.h"
 #include "cc/debug/frame_timing_tracker.h"
 #include "cc/debug/micro_benchmark_controller_impl.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/input/top_controls_manager_client.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/render_pass_sink.h"
@@ skipping 77 matching lines @@
   // Please call these 3 functions through
   // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and
   // SetNeedsOneBeginImplFrame().
   virtual void SetNeedsRedrawOnImplThread() = 0;
   virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0;
   virtual void SetNeedsOneBeginImplFrameOnImplThread() = 0;
   virtual void SetNeedsCommitOnImplThread() = 0;
   virtual void SetNeedsPrepareTilesOnImplThread() = 0;
   virtual void SetVideoNeedsBeginFrames(bool needs_begin_frames) = 0;
   virtual void PostAnimationEventsToMainThreadOnImplThread(
-      scoped_ptr<AnimationEvents> events) = 0;
+      std::unique_ptr<AnimationEvents> events) = 0;
   virtual bool IsInsideDraw() = 0;
   virtual void RenewTreePriority() = 0;
   virtual void PostDelayedAnimationTaskOnImplThread(const base::Closure& task,
                                                     base::TimeDelta delay) = 0;
   virtual void DidActivateSyncTree() = 0;
   virtual void WillPrepareTiles() = 0;
   virtual void DidPrepareTiles() = 0;
 
   // Called when page scale animation has completed on the impl thread.
   virtual void DidCompletePageScaleAnimationOnImplThread() = 0;
 
   // Called when output surface asks for a draw.
   virtual void OnDrawForOutputSurface(bool resourceless_software_draw) = 0;
 
   virtual void PostFrameTimingEventsOnImplThread(
-      scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-      scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) = 0;
+      std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
+      std::unique_ptr<FrameTimingTracker::MainFrameTimingSet>
+          main_frame_events) = 0;
 
  protected:
   virtual ~LayerTreeHostImplClient() {}
 };
 
 // LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
 // state.
 class CC_EXPORT LayerTreeHostImpl
     : public InputHandler,
       public RendererClient,
       public TileManagerClient,
       public OutputSurfaceClient,
       public TopControlsManagerClient,
       public ScrollbarAnimationControllerClient,
       public VideoFrameControllerClient,
       public MutatorHostClient,
       public base::SupportsWeakPtr<LayerTreeHostImpl> {
  public:
-  static scoped_ptr<LayerTreeHostImpl> Create(
+  static std::unique_ptr<LayerTreeHostImpl> Create(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
       TaskRunnerProvider* task_runner_provider,
       RenderingStatsInstrumentation* rendering_stats_instrumentation,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       int id);
   ~LayerTreeHostImpl() override;
 
@@ skipping 28 matching lines @@
                                float page_scale,
                                base::TimeDelta duration);
   void SetNeedsAnimateInput() override;
   bool IsCurrentlyScrollingInnerViewport() const override;
   bool IsCurrentlyScrollingLayerAt(
       const gfx::Point& viewport_point,
       InputHandler::ScrollInputType type) const override;
   EventListenerProperties GetEventListenerProperties(
       EventListenerClass event_class) const override;
   bool DoTouchEventsBlockScrollAt(const gfx::Point& viewport_port) override;
-  scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
+  std::unique_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
       ui::LatencyInfo* latency) override;
   ScrollElasticityHelper* CreateScrollElasticityHelper() override;
 
   // TopControlsManagerClient implementation.
   float TopControlsHeight() const override;
   void SetCurrentTopControlsShownRatio(float offset) override;
   float CurrentTopControlsShownRatio() const override;
   void DidChangeTopControlsPosition() override;
   bool HaveRootScrollLayer() const override;
 
   void UpdateViewportContainerSizes();
 
   struct CC_EXPORT FrameData : public RenderPassSink {
     FrameData();
     ~FrameData() override;
     void AsValueInto(base::trace_event::TracedValue* value) const;
 
     std::vector<gfx::Rect> occluding_screen_space_rects;
     std::vector<gfx::Rect> non_occluding_screen_space_rects;
     std::vector<FrameTimingTracker::FrameAndRectIds> composite_events;
     RenderPassList render_passes;
     const LayerImplList* render_surface_layer_list;
     LayerImplList will_draw_layers;
     bool has_no_damage;
 
     // RenderPassSink implementation.
-    void AppendRenderPass(scoped_ptr<RenderPass> render_pass) override;
+    void AppendRenderPass(std::unique_ptr<RenderPass> render_pass) override;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(FrameData);
   };
 
   virtual void BeginMainFrameAborted(CommitEarlyOutReason reason);
   virtual void BeginCommit();
   virtual void CommitComplete();
   virtual void UpdateAnimationState(bool start_ready_animations);
   void ActivateAnimations();
@@ skipping 84 matching lines @@
   const gfx::Rect ViewportRectForTilePriority() const;
 
   // RendererClient implementation.
   void SetFullRootLayerDamage() override;
 
   // TileManagerClient implementation.
   void NotifyReadyToActivate() override;
   void NotifyReadyToDraw() override;
   void NotifyAllTileTasksCompleted() override;
   void NotifyTileStateChanged(const Tile* tile) override;
-  scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
+  std::unique_ptr<RasterTilePriorityQueue> BuildRasterQueue(
       TreePriority tree_priority,
       RasterTilePriorityQueue::Type type) override;
-  scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
+  std::unique_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
       TreePriority tree_priority) override;
   void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) override;
 
   // ScrollbarAnimationControllerClient implementation.
   void PostDelayedScrollbarAnimationTask(const base::Closure& task,
                                          base::TimeDelta delay) override;
   void SetNeedsAnimateForScrollbarAnimation() override;
   void SetNeedsRedrawForScrollbarAnimation() override;
   ScrollbarSet ScrollbarsFor(int scroll_layer_id) const override;
 
@@ skipping 89 matching lines @@
   LayerImpl* OuterViewportScrollLayer() const;
   LayerImpl* CurrentlyScrollingLayer() const;
 
   int scroll_layer_id_when_mouse_over_scrollbar() const {
     return scroll_layer_id_when_mouse_over_scrollbar_;
   }
   bool scroll_affects_scroll_handler() const {
     return scroll_affects_scroll_handler_;
   }
   void QueueSwapPromiseForMainThreadScrollUpdate(
-      scoped_ptr<SwapPromise> swap_promise);
+      std::unique_ptr<SwapPromise> swap_promise);
 
   bool IsActivelyScrolling() const;
 
   virtual void SetVisible(bool visible);
   bool visible() const { return visible_; }
 
   void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
   void SetNeedsOneBeginImplFrame();
   void SetNeedsRedraw();
 
   ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
 
   size_t memory_allocation_limit_bytes() const;
 
   void SetViewportSize(const gfx::Size& device_viewport_size);
   gfx::Size device_viewport_size() const { return device_viewport_size_; }
 
   const gfx::Transform& DrawTransform() const;
 
-  scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
+  std::unique_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
 
   void set_max_memory_needed_bytes(size_t bytes) {
     max_memory_needed_bytes_ = bytes;
   }
 
   FrameRateCounter* fps_counter() {
     return fps_counter_.get();
   }
   MemoryHistory* memory_history() {
     return memory_history_.get();
@@ skipping 31 matching lines @@
 
   // TODO(mithro): Remove this methods which exposes the internal
   // BeginFrameArgs to external callers.
   virtual BeginFrameArgs CurrentBeginFrameArgs() const;
 
   // Expected time between two begin impl frame calls.
   base::TimeDelta CurrentBeginFrameInterval() const;
 
   void AsValueWithFrameInto(FrameData* frame,
                             base::trace_event::TracedValue* value) const;
-  scoped_ptr<base::trace_event::ConvertableToTraceFormat> AsValueWithFrame(
+  std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValueWithFrame(
       FrameData* frame) const;
   void ActivationStateAsValueInto(base::trace_event::TracedValue* value) const;
 
   bool page_scale_animation_active() const { return !!page_scale_animation_; }
 
   virtual void CreateUIResource(UIResourceId uid,
                                 const UIResourceBitmap& bitmap);
   // Deletes a UI resource.  May safely be called more than once.
   virtual void DeleteUIResource(UIResourceId uid);
   void EvictAllUIResources();
   bool EvictedUIResourcesExist() const;
 
   virtual ResourceId ResourceIdForUIResource(UIResourceId uid) const;
 
   virtual bool IsUIResourceOpaque(UIResourceId uid) const;
 
   struct UIResourceData {
     ResourceId resource_id;
     gfx::Size size;
     bool opaque;
   };
 
   // Returns the amount of delta that can be applied to scroll_node, taking
   // page scale into account.
   gfx::Vector2dF ComputeScrollDelta(ScrollNode* scroll_node,
                                     const gfx::Vector2dF& delta);
 
-  void ScheduleMicroBenchmark(scoped_ptr<MicroBenchmarkImpl> benchmark);
+  void ScheduleMicroBenchmark(std::unique_ptr<MicroBenchmarkImpl> benchmark);
 
   CompositorFrameMetadata MakeCompositorFrameMetadata() const;
   // Viewport rectangle and clip in nonflipped window space.  These rects
   // should only be used by Renderer subclasses to populate glViewport/glClip
   // and their software-mode equivalents.
   gfx::Rect DeviceViewport() const;
   gfx::Rect DeviceClip() const;
 
   // When a SwapPromiseMonitor is created on the impl thread, it calls
   // InsertSwapPromiseMonitor() to register itself with LayerTreeHostImpl.
   // When the monitor is destroyed, it calls RemoveSwapPromiseMonitor()
   // to unregister itself.
   void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor);
   void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor);
 
   // TODO(weiliangc): Replace RequiresHighResToDraw with scheduler waits for
   // ReadyToDraw. crbug.com/469175
   void SetRequiresHighResToDraw() { requires_high_res_to_draw_ = true; }
   void ResetRequiresHighResToDraw() { requires_high_res_to_draw_ = false; }
   bool RequiresHighResToDraw() const { return requires_high_res_to_draw_; }
 
   // Only valid for synchronous (non-scheduled) single-threaded case.
   void SynchronouslyInitializeAllTiles();
 
   bool SupportsImplScrolling() const;
   bool CommitToActiveTree() const;
 
   virtual void CreateResourceAndTileTaskWorkerPool(
-      scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
-      scoped_ptr<ResourcePool>* resource_pool);
+      std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+      std::unique_ptr<ResourcePool>* resource_pool);
 
   bool prepare_tiles_needed() const { return tile_priorities_dirty_; }
 
   FrameTimingTracker* frame_timing_tracker() {
     return frame_timing_tracker_.get();
   }
 
   gfx::Vector2dF ScrollSingleNode(ScrollNode* scroll_node,
                                   const gfx::Vector2dF& delta,
                                   const gfx::Point& viewport_point,
@@ skipping 14 matching lines @@
   // other completion, such as early out). Note that if there is a main frame
   // scheduled in that frame, then this BeginFrameArgs will become the main
   // frame args. However, if no such frame is scheduled, then this _would_ be
   // the main frame args if it was scheduled.
   void RecordMainFrameTiming(
       const BeginFrameArgs& start_of_main_frame_args,
       const BeginFrameArgs& expected_next_main_frame_args);
 
   // Post the given frame timing events to the requester.
   void PostFrameTimingEvents(
-      scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-      scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events);
+      std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
+      std::unique_ptr<FrameTimingTracker::MainFrameTimingSet>
+          main_frame_events);
 
   base::SingleThreadTaskRunner* GetTaskRunner() const {
     DCHECK(task_runner_provider_);
     return task_runner_provider_->HasImplThread()
                ? task_runner_provider_->ImplThreadTaskRunner()
                : task_runner_provider_->MainThreadTaskRunner();
   }
 
   InputHandler::ScrollStatus TryScroll(const gfx::PointF& screen_space_point,
                                        InputHandler::ScrollInputType type,
@@ skipping 109 matching lines @@
   using UIResourceMap = std::unordered_map<UIResourceId, UIResourceData>;
   UIResourceMap ui_resource_map_;
 
   // Resources that were evicted by EvictAllUIResources. Resources are removed
   // from this when they are touched by a create or destroy from the UI resource
   // request queue.
   std::set<UIResourceId> evicted_ui_resources_;
 
   OutputSurface* output_surface_;
 
-  scoped_ptr<ResourceProvider> resource_provider_;
+  std::unique_ptr<ResourceProvider> resource_provider_;
   bool content_is_suitable_for_gpu_rasterization_;
   bool has_gpu_rasterization_trigger_;
   bool use_gpu_rasterization_;
   bool use_msaa_;
   GpuRasterizationStatus gpu_rasterization_status_;
   bool tree_resources_for_gpu_rasterization_dirty_;
-  scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
-  scoped_ptr<ResourcePool> resource_pool_;
-  scoped_ptr<Renderer> renderer_;
-  scoped_ptr<ImageDecodeController> image_decode_controller_;
+  std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+  std::unique_ptr<ResourcePool> resource_pool_;
+  std::unique_ptr<Renderer> renderer_;
+  std::unique_ptr<ImageDecodeController> image_decode_controller_;
 
   GlobalStateThatImpactsTilePriority global_tile_state_;
 
   // Tree currently being drawn.
-  scoped_ptr<LayerTreeImpl> active_tree_;
+  std::unique_ptr<LayerTreeImpl> active_tree_;
 
   // In impl-side painting mode, tree with possibly incomplete rasterized
   // content. May be promoted to active by ActivatePendingTree().
-  scoped_ptr<LayerTreeImpl> pending_tree_;
+  std::unique_ptr<LayerTreeImpl> pending_tree_;
 
   // In impl-side painting mode, inert tree with layers that can be recycled
   // by the next sync from the main thread.
-  scoped_ptr<LayerTreeImpl> recycle_tree_;
+  std::unique_ptr<LayerTreeImpl> recycle_tree_;
 
   InputHandlerClient* input_handler_client_;
   bool did_lock_scrolling_layer_;
   bool wheel_scrolling_;
   bool scroll_affects_scroll_handler_;
   int scroll_layer_id_when_mouse_over_scrollbar_;
-  std::vector<scoped_ptr<SwapPromise>>
+  std::vector<std::unique_ptr<SwapPromise>>
       swap_promises_for_main_thread_scroll_update_;
 
   // An object to implement the ScrollElasticityHelper interface and
   // hold all state related to elasticity. May be NULL if never requested.
-  scoped_ptr<ScrollElasticityHelper> scroll_elasticity_helper_;
+  std::unique_ptr<ScrollElasticityHelper> scroll_elasticity_helper_;
 
   bool tile_priorities_dirty_;
 
   const LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
   bool visible_;
   ManagedMemoryPolicy cached_managed_memory_policy_;
 
   const bool is_synchronous_single_threaded_;
-  scoped_ptr<TileManager> tile_manager_;
+  std::unique_ptr<TileManager> tile_manager_;
 
   gfx::Vector2dF accumulated_root_overscroll_;
 
   bool pinch_gesture_active_;
   bool pinch_gesture_end_should_clear_scrolling_layer_;
 
-  scoped_ptr<TopControlsManager> top_controls_manager_;
+  std::unique_ptr<TopControlsManager> top_controls_manager_;
 
-  scoped_ptr<PageScaleAnimation> page_scale_animation_;
+  std::unique_ptr<PageScaleAnimation> page_scale_animation_;
 
-  scoped_ptr<FrameRateCounter> fps_counter_;
-  scoped_ptr<MemoryHistory> memory_history_;
-  scoped_ptr<DebugRectHistory> debug_rect_history_;
+  std::unique_ptr<FrameRateCounter> fps_counter_;
+  std::unique_ptr<MemoryHistory> memory_history_;
+  std::unique_ptr<DebugRectHistory> debug_rect_history_;
 
-  scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
+  std::unique_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
 
   // The maximum memory that would be used by the prioritized resource
   // manager, if there were no limit on memory usage.
   size_t max_memory_needed_bytes_;
 
   // Viewport size passed in from the main thread, in physical pixels.  This
   // value is the default size for all concepts of physical viewport (draw
   // viewport, scrolling viewport and device viewport), but it can be
   // overridden.
   gfx::Size device_viewport_size_;
 
   // Optional top-level constraints that can be set by the OutputSurface.
   // - external_transform_ applies a transform above the root layer
   // - external_viewport_ is used DrawProperties, tile management and
   // glViewport/window projection matrix.
   // - external_clip_ specifies a top-level clip rect
   // - viewport_rect_for_tile_priority_ is the rect in view space used for
   // tiling priority.
   gfx::Transform external_transform_;
   gfx::Rect external_viewport_;
   gfx::Rect external_clip_;
   gfx::Rect viewport_rect_for_tile_priority_;
   bool resourceless_software_draw_;
 
   bool output_is_secure_;
 
   gfx::Rect viewport_damage_rect_;
 
-  scoped_ptr<AnimationHost> animation_host_;
+  std::unique_ptr<AnimationHost> animation_host_;
   std::set<VideoFrameController*> video_frame_controllers_;
 
   // Map from scroll layer ID to scrollbar animation controller.
   // There is one animation controller per pair of overlay scrollbars.
-  std::unordered_map<int, scoped_ptr<ScrollbarAnimationController>>
+  std::unordered_map<int, std::unique_ptr<ScrollbarAnimationController>>
       scrollbar_animation_controllers_;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
   MicroBenchmarkControllerImpl micro_benchmark_controller_;
-  scoped_ptr<SynchronousTaskGraphRunner>
+  std::unique_ptr<SynchronousTaskGraphRunner>
       single_thread_synchronous_task_graph_runner_;
 
   // Optional callback to notify of new tree activations.
   base::Closure tree_activation_callback_;
 
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
   int id_;
 
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
   bool requires_high_res_to_draw_;
   bool is_likely_to_require_a_draw_;
 
-  scoped_ptr<FrameTimingTracker> frame_timing_tracker_;
+  std::unique_ptr<FrameTimingTracker> frame_timing_tracker_;
 
-  scoped_ptr<Viewport> viewport_;
+  std::unique_ptr<Viewport> viewport_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_