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

cc/debug/frame_timing_tracker.h

 // Copyright 2015 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_DEBUG_FRAME_TIMING_TRACKER_H_
 #define CC_DEBUG_FRAME_TIMING_TRACKER_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <unordered_map>
 #include <utility>
 #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/delayed_unique_notifier.h"
 
 namespace cc {
 
 class LayerTreeHostImpl;
 
 // This class maintains a history of timestamps and rect IDs to communicate
 // frame events back to Blink
@@ skipping 18 matching lines @@
     ~MainFrameTimingEvent();
 
     int frame_id;
     base::TimeTicks timestamp;
     base::TimeTicks end_time;
   };
 
   using MainFrameTimingSet =
       std::unordered_map<int64_t, std::vector<MainFrameTimingEvent>>;
 
-  static scoped_ptr<FrameTimingTracker> Create(
+  static std::unique_ptr<FrameTimingTracker> Create(
       LayerTreeHostImpl* layer_tree_host_impl);
 
   ~FrameTimingTracker();
 
   // This routine takes all of the individual CompositeEvents stored in the
   // tracker and collects them by "rect_id", as in the example below.
   // [ {f_id1,r_id1,t1}, {f_id2,r_id1,t2}, {f_id3,r_id2,t3} ]
   // ====>
   // [ {r_id1,<{f_id1,t1},{f_id2,t2}>}, {r_id2,<{f_id3,t3}>} ]
-  scoped_ptr<CompositeTimingSet> GroupCompositeCountsByRectId();
+  std::unique_ptr<CompositeTimingSet> GroupCompositeCountsByRectId();
 
   // This routine takes all of the individual MainFrameEvents stored in the
   // tracker and collects them by "rect_id", as in the example below.
-  scoped_ptr<MainFrameTimingSet> GroupMainFrameCountsByRectId();
+  std::unique_ptr<MainFrameTimingSet> GroupMainFrameCountsByRectId();
 
   // This routine takes a timestamp and an array of frame_id,rect_id pairs
   // and generates CompositeTimingEvents (frame_id, timestamp) and adds them to
   // internal hash_map keyed on rect_id
   using FrameAndRectIds = std::pair<int, int64_t>;
   void SaveTimeStamps(base::TimeTicks timestamp,
                       const std::vector<FrameAndRectIds>& frame_ids);
 
   void SaveMainFrameTimeStamps(const std::vector<int64_t>& request_ids,
                                base::TimeTicks main_frame_time,
                                base::TimeTicks end_time,
                                int source_frame_number);
 
  private:
   explicit FrameTimingTracker(LayerTreeHostImpl* layer_tree_host_impl);
 
   void PostEvents();
 
-  scoped_ptr<CompositeTimingSet> composite_events_;
-  scoped_ptr<MainFrameTimingSet> main_frame_events_;
+  std::unique_ptr<CompositeTimingSet> composite_events_;
+  std::unique_ptr<MainFrameTimingSet> main_frame_events_;
 
   LayerTreeHostImpl* layer_tree_host_impl_;
   DelayedUniqueNotifier post_events_notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameTimingTracker);
 };
 
 }  // namespace cc
 
 #endif  // CC_DEBUG_FRAME_TIMING_TRACKER_H_