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

cc/tiles/eviction_tile_priority_queue.cc

 // Copyright 2014 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.
 
 #include "cc/tiles/eviction_tile_priority_queue.h"
 
+#include "base/memory/ptr_util.h"
+
 namespace cc {
 
 namespace {
 
 class EvictionOrderComparator {
  public:
   explicit EvictionOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
-  bool operator()(const scoped_ptr<TilingSetEvictionQueue>& a_queue,
-                  const scoped_ptr<TilingSetEvictionQueue>& b_queue) const {
+  bool operator()(
+      const std::unique_ptr<TilingSetEvictionQueue>& a_queue,
+      const std::unique_ptr<TilingSetEvictionQueue>& b_queue) const {
     // Note that in this function, we have to return true if and only if
     // b is strictly lower priority than a.
     const PrioritizedTile& a_tile = a_queue->Top();
     const PrioritizedTile& b_tile = b_queue->Top();
 
     const TilePriority& a_priority = a_tile.priority();
     const TilePriority& b_priority = b_tile.priority();
     bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
 
     // If the priority bin differs, b is lower priority if it has the higher
@@ skipping 29 matching lines @@
     return b_priority.distance_to_visible > a_priority.distance_to_visible;
   }
 
  private:
   TreePriority tree_priority_;
 };
 
 void CreateTilingSetEvictionQueues(
     const std::vector<PictureLayerImpl*>& layers,
     TreePriority tree_priority,
-    std::vector<scoped_ptr<TilingSetEvictionQueue>>* queues) {
+    std::vector<std::unique_ptr<TilingSetEvictionQueue>>* queues) {
   DCHECK(queues->empty());
 
   for (auto* layer : layers) {
-    scoped_ptr<TilingSetEvictionQueue> tiling_set_queue = make_scoped_ptr(
+    std::unique_ptr<TilingSetEvictionQueue> tiling_set_queue = base::WrapUnique(
         new TilingSetEvictionQueue(layer->picture_layer_tiling_set()));
     // Queues will only contain non empty tiling sets.
     if (!tiling_set_queue->IsEmpty())
       queues->push_back(std::move(tiling_set_queue));
   }
   std::make_heap(queues->begin(), queues->end(),
                  EvictionOrderComparator(tree_priority));
 }
 
 }  // namespace
@@ skipping 36 matching lines @@
 
   // Remove empty queues.
   if (queue->IsEmpty()) {
     next_queues.pop_back();
   } else {
     std::push_heap(next_queues.begin(), next_queues.end(),
                    EvictionOrderComparator(tree_priority_));
   }
 }
 
-std::vector<scoped_ptr<TilingSetEvictionQueue>>&
+std::vector<std::unique_ptr<TilingSetEvictionQueue>>&
 EvictionTilePriorityQueue::GetNextQueues() {
   const EvictionTilePriorityQueue* const_this =
       static_cast<const EvictionTilePriorityQueue*>(this);
   const auto& const_queues = const_this->GetNextQueues();
-  return const_cast<std::vector<scoped_ptr<TilingSetEvictionQueue>>&>(
+  return const_cast<std::vector<std::unique_ptr<TilingSetEvictionQueue>>&>(
       const_queues);
 }
 
-const std::vector<scoped_ptr<TilingSetEvictionQueue>>&
+const std::vector<std::unique_ptr<TilingSetEvictionQueue>>&
 EvictionTilePriorityQueue::GetNextQueues() const {
   DCHECK(!IsEmpty());
 
   // If we only have one queue with tiles, return it.
   if (active_queues_.empty())
     return pending_queues_;
   if (pending_queues_.empty())
     return active_queues_;
 
   const PrioritizedTile& active_tile = active_queues_.front()->Top();
@@ skipping 11 matching lines @@
                                                          : active_queues_;
   }
 
   // Return tile with a lower priority.
   if (pending_priority.IsHigherPriorityThan(active_priority))
     return active_queues_;
   return pending_queues_;
 }
 
 }  // namespace cc