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

cc/tiles/picture_layer_tiling_set.cc

 // 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.
 
 #include "cc/tiles/picture_layer_tiling_set.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <set>
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "cc/playback/raster_source.h"
 
 namespace cc {
 
 namespace {
 
 class LargestToSmallestScaleFunctor {
  public:
-  bool operator()(const scoped_ptr<PictureLayerTiling>& left,
-                  const scoped_ptr<PictureLayerTiling>& right) {
+  bool operator()(const std::unique_ptr<PictureLayerTiling>& left,
+                  const std::unique_ptr<PictureLayerTiling>& right) {
     return left->contents_scale() > right->contents_scale();
   }
 };
 
 inline float LargerRatio(float float1, float float2) {
   DCHECK_GT(float1, 0.f);
   DCHECK_GT(float2, 0.f);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 }  // namespace
 
 // static
-scoped_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
+std::unique_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
     WhichTree tree,
     PictureLayerTilingClient* client,
     size_t tiling_interest_area_padding,
     float skewport_target_time_in_seconds,
     int skewport_extrapolation_limit_in_content_pixels) {
-  return make_scoped_ptr(new PictureLayerTilingSet(
+  return base::WrapUnique(new PictureLayerTilingSet(
       tree, client, tiling_interest_area_padding,
       skewport_target_time_in_seconds,
       skewport_extrapolation_limit_in_content_pixels));
 }
 
 PictureLayerTilingSet::PictureLayerTilingSet(
     WhichTree tree,
     PictureLayerTilingClient* client,
     size_t tiling_interest_area_padding,
     float skewport_target_time_in_seconds,
@@ skipping 18 matching lines @@
     // leaving behind unshared tilings that are all non-ideal.
     RemoveAllTilings();
     return;
   }
 
   bool tiling_sort_required = false;
   for (const auto& pending_twin_tiling : pending_twin_set->tilings_) {
     float contents_scale = pending_twin_tiling->contents_scale();
     PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
     if (!this_tiling) {
-      scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
-          tree_, contents_scale, raster_source, client_,
-          tiling_interest_area_padding_, skewport_target_time_in_seconds_,
-          skewport_extrapolation_limit_in_content_pixels_);
+      std::unique_ptr<PictureLayerTiling> new_tiling =
+          PictureLayerTiling::Create(
+              tree_, contents_scale, raster_source, client_,
+              tiling_interest_area_padding_, skewport_target_time_in_seconds_,
+              skewport_extrapolation_limit_in_content_pixels_);
       tilings_.push_back(std::move(new_tiling));
       this_tiling = tilings_.back().get();
       tiling_sort_required = true;
     }
     this_tiling->TakeTilesAndPropertiesFrom(pending_twin_tiling.get(),
                                             layer_invalidation);
   }
 
   if (tiling_sort_required) {
     std::sort(tilings_.begin(), tilings_.end(),
@@ skipping 42 matching lines @@
 
 void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForCommit(
     scoped_refptr<RasterSource> raster_source,
     const Region& layer_invalidation,
     float minimum_contents_scale,
     float maximum_contents_scale) {
   RemoveTilingsBelowScale(minimum_contents_scale);
   RemoveTilingsAboveScale(maximum_contents_scale);
 
   // Invalidate tiles and update them to the new raster source.
-  for (const scoped_ptr<PictureLayerTiling>& tiling : tilings_) {
+  for (const std::unique_ptr<PictureLayerTiling>& tiling : tilings_) {
     DCHECK(tree_ != PENDING_TREE || !tiling->has_tiles());
     tiling->SetRasterSourceAndResize(raster_source);
 
     // We can commit on either active or pending trees, but only active one can
     // have tiles at this point.
     if (tree_ == ACTIVE_TREE)
       tiling->Invalidate(layer_invalidation);
 
     // This is needed for cases where the live tiles rect didn't change but
     // recordings exist in the raster source that did not exist on the last
@@ skipping 71 matching lines @@
 
   for (auto* tiling : to_remove) {
     DCHECK_NE(HIGH_RESOLUTION, tiling->resolution());
     Remove(tiling);
   }
 }
 
 void PictureLayerTilingSet::RemoveNonIdealTilings() {
   auto to_remove =
       std::remove_if(tilings_.begin(), tilings_.end(),
-                     [](const scoped_ptr<PictureLayerTiling>& t) {
+                     [](const std::unique_ptr<PictureLayerTiling>& t) {
                        return t->resolution() == NON_IDEAL_RESOLUTION;
                      });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
   for (const auto& tiling : tilings_)
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
 }
 
@@ skipping 10 matching lines @@
       tiling_interest_area_padding_, skewport_target_time_in_seconds_,
       skewport_extrapolation_limit_in_content_pixels_));
   PictureLayerTiling* appended = tilings_.back().get();
 
   std::sort(tilings_.begin(), tilings_.end(), LargestToSmallestScaleFunctor());
   return appended;
 }
 
 int PictureLayerTilingSet::NumHighResTilings() const {
   return std::count_if(tilings_.begin(), tilings_.end(),
-                       [](const scoped_ptr<PictureLayerTiling>& tiling) {
+                       [](const std::unique_ptr<PictureLayerTiling>& tiling) {
                          return tiling->resolution() == HIGH_RESOLUTION;
                        });
 }
 
 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithScale(
     float scale) const {
   for (size_t i = 0; i < tilings_.size(); ++i) {
     if (tilings_[i]->contents_scale() == scale)
       return tilings_[i].get();
   }
   return nullptr;
 }
 
 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithResolution(
     TileResolution resolution) const {
-  auto iter =
-      std::find_if(tilings_.begin(), tilings_.end(),
-                   [resolution](const scoped_ptr<PictureLayerTiling>& tiling) {
-                     return tiling->resolution() == resolution;
-                   });
+  auto iter = std::find_if(
+      tilings_.begin(), tilings_.end(),
+      [resolution](const std::unique_ptr<PictureLayerTiling>& tiling) {
+        return tiling->resolution() == resolution;
+      });
   if (iter == tilings_.end())
     return nullptr;
   return iter->get();
 }
 
 void PictureLayerTilingSet::RemoveTilingsBelowScale(float minimum_scale) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
-      [minimum_scale](const scoped_ptr<PictureLayerTiling>& tiling) {
+      [minimum_scale](const std::unique_ptr<PictureLayerTiling>& tiling) {
         return tiling->contents_scale() < minimum_scale;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::RemoveTilingsAboveScale(float maximum_scale) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
-      [maximum_scale](const scoped_ptr<PictureLayerTiling>& tiling) {
+      [maximum_scale](const std::unique_ptr<PictureLayerTiling>& tiling) {
         return tiling->contents_scale() > maximum_scale;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::RemoveAllTilings() {
   tilings_.clear();
 }
 
 void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
-  auto iter =
-      std::find_if(tilings_.begin(), tilings_.end(),
-                   [tiling](const scoped_ptr<PictureLayerTiling>& candidate) {
-                     return candidate.get() == tiling;
-                   });
+  auto iter = std::find_if(
+      tilings_.begin(), tilings_.end(),
+      [tiling](const std::unique_ptr<PictureLayerTiling>& candidate) {
+        return candidate.get() == tiling;
+      });
   if (iter == tilings_.end())
     return;
   tilings_.erase(iter);
 }
 
 void PictureLayerTilingSet::RemoveAllTiles() {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->Reset();
 }
 
@@ skipping 252 matching lines @@
     case LOWER_THAN_LOW_RES:
       range = TilingRange(low_res_range.end, tilings_size);
       break;
   }
 
   DCHECK_LE(range.start, range.end);
   return range;
 }
 
 }  // namespace cc