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

cc/trees/remote_channel_impl.h

 // Copyright 2016 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_REMOTE_CHANNEL_IMPL_H_
 #define CC_TREES_REMOTE_CHANNEL_IMPL_H_
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "cc/base/cc_export.h"
@@ skipping 60 matching lines @@
 // The RemoteChannelImpl receives and processes messages from the remote server
 // compositor on the main thread. The requests from ProxyImpl are received on
 // the impl thread which may be directed to the LayerTreeHost on the client
 // (for instance output surface requests) or sent to the LayerTreeHost on the
 // server. The messages to the server are created on the impl thread and sent
 // using the RemoteProtoChannel on the main thread.
 class CC_EXPORT RemoteChannelImpl : public ChannelImpl,
                                     public RemoteProtoChannel::ProtoReceiver,
                                     public Proxy {
  public:
-  static scoped_ptr<RemoteChannelImpl> Create(
+  static std::unique_ptr<RemoteChannelImpl> Create(
       LayerTreeHost* layer_tree_host,
       RemoteProtoChannel* remote_proto_channel,
       TaskRunnerProvider* task_runner_provider);
 
   ~RemoteChannelImpl() override;
 
  protected:
   RemoteChannelImpl(LayerTreeHost* layer_tree_host,
                     RemoteProtoChannel* remote_proto_channel,
                     TaskRunnerProvider* task_runner_provider);
 
   // virtual for testing.
-  virtual scoped_ptr<ProxyImpl> CreateProxyImpl(
+  virtual std::unique_ptr<ProxyImpl> CreateProxyImpl(
       ChannelImpl* channel_impl,
       LayerTreeHost* layer_tree_host,
       TaskRunnerProvider* task_runner_provider,
-      scoped_ptr<BeginFrameSource> external_begin_frame_source);
+      std::unique_ptr<BeginFrameSource> external_begin_frame_source);
 
  private:
   struct MainThreadOnly {
     LayerTreeHost* layer_tree_host;
     RemoteProtoChannel* remote_proto_channel;
 
     bool started;
 
     // This is set to true if we lost the output surface and can not push any
     // commits to the impl thread.
     bool waiting_for_output_surface_initialization;
 
     // The queue of messages received from the server. The messages are added to
     // this queue if we are waiting for a new output surface to be initialized.
     std::queue<proto::CompositorMessageToImpl> pending_messages;
 
     RendererCapabilities renderer_capabilities;
 
     base::WeakPtrFactory<RemoteChannelImpl> remote_channel_weak_factory;
 
     MainThreadOnly(RemoteChannelImpl*,
                    LayerTreeHost* layer_tree_host,
                    RemoteProtoChannel* remote_proto_channel);
     ~MainThreadOnly();
   };
 
   struct CompositorThreadOnly {
-    scoped_ptr<ProxyImpl> proxy_impl;
-    scoped_ptr<base::WeakPtrFactory<ProxyImpl>> proxy_impl_weak_factory;
+    std::unique_ptr<ProxyImpl> proxy_impl;
+    std::unique_ptr<base::WeakPtrFactory<ProxyImpl>> proxy_impl_weak_factory;
     base::WeakPtr<RemoteChannelImpl> remote_channel_weak_ptr;
 
     CompositorThreadOnly(
         base::WeakPtr<RemoteChannelImpl> remote_channel_weak_ptr);
     ~CompositorThreadOnly();
   };
 
   // called on main thread.
   // RemoteProtoChannel::ProtoReceiver implementation.
-  void OnProtoReceived(scoped_ptr<proto::CompositorMessage> proto) override;
+  void OnProtoReceived(
+      std::unique_ptr<proto::CompositorMessage> proto) override;
 
   // Proxy implementation
   void FinishAllRendering() override;
   bool IsStarted() const override;
   bool CommitToActiveTree() const override;
   void SetOutputSurface(OutputSurface* output_surface) override;
   void ReleaseOutputSurface() override;
   void SetVisible(bool visible) override;
   const RendererCapabilities& GetRendererCapabilities() const override;
   void SetNeedsAnimate() override;
   void SetNeedsUpdateLayers() override;
   void SetNeedsCommit() override;
   void SetNeedsRedraw(const gfx::Rect& damage_rect) override;
   void SetNextCommitWaitsForActivation() override;
   void NotifyInputThrottledUntilCommit() override;
   void SetDeferCommits(bool defer_commits) override;
   void MainThreadHasStoppedFlinging() override;
   bool CommitRequested() const override;
   bool BeginMainFrameRequested() const override;
-  void Start(scoped_ptr<BeginFrameSource> external_begin_frame_source) override;
+  void Start(
+      std::unique_ptr<BeginFrameSource> external_begin_frame_source) override;
   void Stop() override;
   bool SupportsImplScrolling() const override;
   void SetChildrenNeedBeginFrames(bool children_need_begin_frames) override;
   void SetAuthoritativeVSyncInterval(const base::TimeDelta& interval) override;
   void UpdateTopControlsState(TopControlsState constraints,
                               TopControlsState current,
                               bool animate) override;
   void SetOutputIsSecure(bool output_is_secure) override;
   bool MainFrameWillHappenForTesting() override;
 
   // Called on impl thread.
   // ChannelImpl implementation
   void DidCompleteSwapBuffers() override;
   void SetRendererCapabilitiesMainCopy(
       const RendererCapabilities& capabilities) override;
   void BeginMainFrameNotExpectedSoon() override;
   void DidCommitAndDrawFrame() override;
-  void SetAnimationEvents(scoped_ptr<AnimationEvents> queue) override;
+  void SetAnimationEvents(std::unique_ptr<AnimationEvents> queue) override;
   void DidLoseOutputSurface() override;
   void RequestNewOutputSurface() override;
   void DidInitializeOutputSurface(
       bool success,
       const RendererCapabilities& capabilities) override;
   void DidCompletePageScaleAnimation() override;
   void PostFrameTimingEventsOnMain(
-      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)
       override;
-  void BeginMainFrame(
-      scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) override;
+  void BeginMainFrame(std::unique_ptr<BeginMainFrameAndCommitState>
+                          begin_main_frame_state) override;
 
-  void SendMessageProto(scoped_ptr<proto::CompositorMessage> proto);
+  void SendMessageProto(std::unique_ptr<proto::CompositorMessage> proto);
 
   // called on main thread.
   void HandleProto(const proto::CompositorMessageToImpl& proto);
   void DidLoseOutputSurfaceOnMain();
   void RequestNewOutputSurfaceOnMain();
   void DidInitializeOutputSurfaceOnMain(
       bool success,
       const RendererCapabilities& capabilities);
-  void SendMessageProtoOnMain(scoped_ptr<proto::CompositorMessage> proto);
+  void SendMessageProtoOnMain(std::unique_ptr<proto::CompositorMessage> proto);
   void PostSetNeedsRedrawToImpl(const gfx::Rect& damaged_rect);
 
   void InitializeImplOnImpl(CompletionEvent* completion,
                             LayerTreeHost* layer_tree_host);
   void ShutdownImplOnImpl(CompletionEvent* completion);
 
   MainThreadOnly& main();
   const MainThreadOnly& main() const;
   CompositorThreadOnly& impl();
   const CompositorThreadOnly& impl() const;
 
   base::SingleThreadTaskRunner* MainThreadTaskRunner() const;
   base::SingleThreadTaskRunner* ImplThreadTaskRunner() const;
 
   TaskRunnerProvider* task_runner_provider_;
 
   // use accessors instead of these variables directly
   MainThreadOnly main_thread_vars_unsafe_;
   CompositorThreadOnly compositor_thread_vars_unsafe_;
 
   base::WeakPtr<ProxyImpl> proxy_impl_weak_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteChannelImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_REMOTE_CHANNEL_IMPL_H_