Replace base::MakeUnique with std::make_unique in cc/.

Includes of base/memory/ptr_util.h are expected to be rewritten
in a followup CL, to reduce conflicts.

Bug: 755727
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I33b9866476d8df3a4f60ad7277ff1b43c1472aaf
Reviewed-on: https://chromium-review.googlesource.com/627171
Commit-Queue: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#497679}

cc/PRESUBMIT.py

@@ -162,7 +162,7 @@ def CheckUniquePtr(input_api, output_api,
       if re.search(r'(=|\breturn)\s*std::unique_ptr<.*?(?<!])>\([^)]+\)', line):
         errors.append(output_api.PresubmitError(
           ('%s:%d uses explicit std::unique_ptr constructor. ' +
-           'Use base::MakeUnique<T>() instead.') %
+           'Use std::make_unique<T>() instead.') %
           (f.LocalPath(), line_number)))
       # Disallow:
       # std::unique_ptr<T>()

cc/animation/animation_host.cc

@@ -49,9 +49,9 @@ AnimationHost::AnimationHost(ThreadInstance thread_instance)
       mutator_(nullptr) {
   if (thread_instance_ == ThreadInstance::IMPL) {
     scroll_offset_animations_impl_ =
-        base::MakeUnique<ScrollOffsetAnimationsImpl>(this);
+        std::make_unique<ScrollOffsetAnimationsImpl>(this);
   } else {
-    scroll_offset_animations_ = base::MakeUnique<ScrollOffsetAnimations>(this);
+    scroll_offset_animations_ = std::make_unique<ScrollOffsetAnimations>(this);
   }
 }
 
@@ -355,7 +355,7 @@ base::Closure AnimationHost::TakeMutations() {
 }
 
 std::unique_ptr<MutatorEvents> AnimationHost::CreateEvents() {
-  return base::MakeUnique<AnimationEvents>();
+  return std::make_unique<AnimationEvents>();
 }
 
 void AnimationHost::SetAnimationEvents(

cc/animation/animation_player_unittest.cc

@@ -419,7 +419,7 @@ TEST_F(AnimationPlayerTest, ToString) {
       player_->ToString());
 
   player_->AddAnimation(
-      Animation::Create(base::MakeUnique<FakeFloatAnimationCurve>(15), 42, 73,
+      Animation::Create(std::make_unique<FakeFloatAnimationCurve>(15), 42, 73,
                         TargetProperty::OPACITY));
   EXPECT_EQ(base::StringPrintf("AnimationPlayer{id=%d, element_id=%s, "
                                "animations=[Animation{id=42, "
@@ -429,7 +429,7 @@ TEST_F(AnimationPlayerTest, ToString) {
             player_->ToString());
 
   player_->AddAnimation(
-      Animation::Create(base::MakeUnique<FakeFloatAnimationCurve>(18), 45, 76,
+      Animation::Create(std::make_unique<FakeFloatAnimationCurve>(18), 45, 76,
                         TargetProperty::BOUNDS));
   EXPECT_EQ(
       base::StringPrintf(

cc/animation/animation_unittest.cc

@@ -23,7 +23,7 @@ std::unique_ptr<Animation> CreateAnimation(double iterations,
                                            double duration,
                                            double playback_rate) {
   std::unique_ptr<Animation> to_return(
-      Animation::Create(base::MakeUnique<FakeFloatAnimationCurve>(duration), 0,
+      Animation::Create(std::make_unique<FakeFloatAnimationCurve>(duration), 0,
                         1, TargetProperty::OPACITY));
   to_return->set_iterations(iterations);
   to_return->set_playback_rate(playback_rate);
@@ -1006,7 +1006,7 @@ TEST(AnimationTest, ToString) {
   EXPECT_EQ(
       "Animation{id=42, group=73, target_property_id=1, "
       "run_state=WAITING_FOR_TARGET_AVAILABILITY}",
-      Animation::Create(base::MakeUnique<FakeFloatAnimationCurve>(15), 42, 73,
+      Animation::Create(std::make_unique<FakeFloatAnimationCurve>(15), 42, 73,
                         TargetProperty::OPACITY)
           ->ToString());
 }

cc/animation/transform_operations_unittest.cc

@@ -58,23 +58,23 @@ TEST(TransformOperationTest, TransformTypesAreUnique) {
   std::vector<std::unique_ptr<TransformOperations>> transforms;
 
   std::unique_ptr<TransformOperations> to_add(
-      base::MakeUnique<TransformOperations>());
+      std::make_unique<TransformOperations>());
   to_add->AppendTranslate(1, 0, 0);
   transforms.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendRotate(0, 0, 1, 2);
   transforms.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendScale(2, 2, 2);
   transforms.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendSkew(1, 0);
   transforms.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendPerspective(800);
   transforms.push_back(std::move(to_add));
 
@@ -130,50 +130,50 @@ TEST(TransformOperationTest, MatchTypesDifferentLength) {
 std::vector<std::unique_ptr<TransformOperations>> GetIdentityOperations() {
   std::vector<std::unique_ptr<TransformOperations>> operations;
   std::unique_ptr<TransformOperations> to_add(
-      base::MakeUnique<TransformOperations>());
+      std::make_unique<TransformOperations>());
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendTranslate(0, 0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendTranslate(0, 0, 0);
   to_add->AppendTranslate(0, 0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendScale(1, 1, 1);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendScale(1, 1, 1);
   to_add->AppendScale(1, 1, 1);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendSkew(0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendSkew(0, 0);
   to_add->AppendSkew(0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendRotate(0, 0, 1, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendRotate(0, 0, 1, 0);
   to_add->AppendRotate(0, 0, 1, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendMatrix(gfx::Transform());
   operations.push_back(std::move(to_add));
 
-  to_add = base::MakeUnique<TransformOperations>();
+  to_add = std::make_unique<TransformOperations>();
   to_add->AppendMatrix(gfx::Transform());
   to_add->AppendMatrix(gfx::Transform());
   operations.push_back(std::move(to_add));

cc/benchmarks/invalidation_benchmark.cc

@@ -124,7 +124,7 @@ bool InvalidationBenchmark::ProcessMessage(std::unique_ptr<base::Value> value) {
   if (message->HasKey("notify_done")) {
     message->GetBoolean("notify_done", &notify_done);
     if (notify_done)
-      NotifyDone(base::MakeUnique<base::Value>());
+      NotifyDone(std::make_unique<base::Value>());
     return true;
   }
   return false;

cc/benchmarks/micro_benchmark_controller.cc

@@ -29,12 +29,12 @@ std::unique_ptr<MicroBenchmark> CreateBenchmark(
     std::unique_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   if (name == "invalidation_benchmark") {
-    return base::MakeUnique<InvalidationBenchmark>(std::move(value), callback);
+    return std::make_unique<InvalidationBenchmark>(std::move(value), callback);
   } else if (name == "rasterize_and_record_benchmark") {
-    return base::MakeUnique<RasterizeAndRecordBenchmark>(std::move(value),
+    return std::make_unique<RasterizeAndRecordBenchmark>(std::move(value),
                                                          callback);
   } else if (name == "unittest_only_benchmark") {
-    return base::MakeUnique<UnittestOnlyBenchmark>(std::move(value), callback);
+    return std::make_unique<UnittestOnlyBenchmark>(std::move(value), callback);
   }
   return nullptr;
 }

cc/benchmarks/micro_benchmark_controller_unittest.cc

@@ -27,7 +27,7 @@ class MicroBenchmarkControllerTest : public testing::Test {
   void SetUp() override {
     impl_task_runner_provider_ =
         base::WrapUnique(new FakeImplTaskRunnerProvider);
-    layer_tree_host_impl_ = base::MakeUnique<FakeLayerTreeHostImpl>(
+    layer_tree_host_impl_ = std::make_unique<FakeLayerTreeHostImpl>(
         impl_task_runner_provider_.get(), &task_graph_runner_);
 
     animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);

cc/blink/web_compositor_support_impl.cc

@@ -37,36 +37,36 @@ WebCompositorSupportImpl::~WebCompositorSupportImpl() {
 }
 
 std::unique_ptr<WebLayer> WebCompositorSupportImpl::CreateLayer() {
-  return base::MakeUnique<WebLayerImpl>();
+  return std::make_unique<WebLayerImpl>();
 }
 
 std::unique_ptr<WebLayer> WebCompositorSupportImpl::CreateLayerFromCCLayer(
     cc::Layer* layer) {
-  return base::MakeUnique<WebLayerImpl>(layer);
+  return std::make_unique<WebLayerImpl>(layer);
 }
 
 std::unique_ptr<WebContentLayer> WebCompositorSupportImpl::CreateContentLayer(
     WebContentLayerClient* client) {
-  return base::MakeUnique<WebContentLayerImpl>(client);
+  return std::make_unique<WebContentLayerImpl>(client);
 }
 
 std::unique_ptr<WebExternalTextureLayer>
 WebCompositorSupportImpl::CreateExternalTextureLayer(
     cc::TextureLayerClient* client) {
-  return base::MakeUnique<WebExternalTextureLayerImpl>(client);
+  return std::make_unique<WebExternalTextureLayerImpl>(client);
 }
 
 std::unique_ptr<blink::WebImageLayer>
 WebCompositorSupportImpl::CreateImageLayer() {
-  return base::MakeUnique<WebImageLayerImpl>();
+  return std::make_unique<WebImageLayerImpl>();
 }
 
 std::unique_ptr<WebScrollbarLayer>
 WebCompositorSupportImpl::CreateScrollbarLayer(
     std::unique_ptr<WebScrollbar> scrollbar,
     WebScrollbarThemePainter painter,
     std::unique_ptr<WebScrollbarThemeGeometry> geometry) {
-  return base::MakeUnique<WebScrollbarLayerImpl>(std::move(scrollbar), painter,
+  return std::make_unique<WebScrollbarLayerImpl>(std::move(scrollbar), painter,
                                                  std::move(geometry),
                                                  /* is overlay */ false);
 }
@@ -76,7 +76,7 @@ WebCompositorSupportImpl::CreateOverlayScrollbarLayer(
     std::unique_ptr<WebScrollbar> scrollbar,
     WebScrollbarThemePainter painter,
     std::unique_ptr<WebScrollbarThemeGeometry> geometry) {
-  return base::MakeUnique<WebScrollbarLayerImpl>(std::move(scrollbar), painter,
+  return std::make_unique<WebScrollbarLayerImpl>(std::move(scrollbar), painter,
                                                  std::move(geometry),
                                                  /* is overlay */ true);
 }
@@ -87,7 +87,7 @@ WebCompositorSupportImpl::CreateSolidColorScrollbarLayer(
     int thumb_thickness,
     int track_start,
     bool is_left_side_vertical_scrollbar) {
-  return base::MakeUnique<WebScrollbarLayerImpl>(
+  return std::make_unique<WebScrollbarLayerImpl>(
       orientation, thumb_thickness, track_start,
       is_left_side_vertical_scrollbar);
 }

cc/blink/web_content_layer_impl.cc

@@ -47,7 +47,7 @@ PaintingControlToWeb(
 
 WebContentLayerImpl::WebContentLayerImpl(blink::WebContentLayerClient* client)
     : client_(client) {
-  layer_ = base::MakeUnique<WebLayerImpl>(PictureLayer::Create(this));
+  layer_ = std::make_unique<WebLayerImpl>(PictureLayer::Create(this));
   layer_->layer()->SetIsDrawable(true);
 }
 

cc/blink/web_scrollbar_layer_impl.cc

@@ -39,12 +39,12 @@ WebScrollbarLayerImpl::WebScrollbarLayerImpl(
     bool is_overlay)
     : layer_(is_overlay
                  ? new WebLayerImpl(PaintedOverlayScrollbarLayer::Create(
-                       base::MakeUnique<ScrollbarImpl>(std::move(scrollbar),
+                       std::make_unique<ScrollbarImpl>(std::move(scrollbar),
                                                        painter,
                                                        std::move(geometry)),
                        cc::ElementId()))
                  : new WebLayerImpl(PaintedScrollbarLayer::Create(
-                       base::MakeUnique<ScrollbarImpl>(std::move(scrollbar),
+                       std::make_unique<ScrollbarImpl>(std::move(scrollbar),
                                                        painter,
                                                        std::move(geometry)),
                        cc::ElementId()))) {}

cc/input/browser_controls_offset_manager_unittest.cc

@@ -38,7 +38,7 @@ class MockBrowserControlsOffsetManagerClient
         top_controls_height_(top_controls_height),
         browser_controls_show_threshold_(browser_controls_show_threshold),
         browser_controls_hide_threshold_(browser_controls_hide_threshold) {
-    active_tree_ = base::MakeUnique<LayerTreeImpl>(
+    active_tree_ = std::make_unique<LayerTreeImpl>(
         &host_impl_, new SyncedProperty<ScaleGroup>, new SyncedBrowserControls,
         new SyncedElasticOverscroll);
     root_scroll_layer_ = LayerImpl::Create(active_tree_.get(), 1);

cc/ipc/copy_output_request_struct_traits.cc

@@ -55,7 +55,7 @@ StructTraits<cc::mojom::CopyOutputRequestDataView,
              std::unique_ptr<viz::CopyOutputRequest>>::
     result_sender(const std::unique_ptr<viz::CopyOutputRequest>& request) {
   cc::mojom::CopyOutputResultSenderPtr result_sender;
-  auto impl = base::MakeUnique<CopyOutputResultSenderImpl>(
+  auto impl = std::make_unique<CopyOutputResultSenderImpl>(
       std::move(request->result_callback_));
   MakeStrongBinding(std::move(impl), MakeRequest(&result_sender));
   return result_sender;

cc/ipc/copy_output_result_struct_traits.cc

@@ -69,7 +69,7 @@ StructTraits<cc::mojom::CopyOutputResultDataView,
   if (!result->release_callback_)
     return {};
   cc::mojom::TextureMailboxReleaserPtr releaser;
-  auto impl = base::MakeUnique<TextureMailboxReleaserImpl>(
+  auto impl = std::make_unique<TextureMailboxReleaserImpl>(
       std::move(result->release_callback_));
   MakeStrongBinding(std::move(impl), MakeRequest(&releaser));
   return releaser;
@@ -83,7 +83,7 @@ bool StructTraits<cc::mojom::CopyOutputResultDataView,
   // We first read into local variables and then call the appropriate
   // constructor of viz::CopyOutputResult.
   gfx::Size size;
-  auto bitmap = base::MakeUnique<SkBitmap>();
+  auto bitmap = std::make_unique<SkBitmap>();
   viz::TextureMailbox texture_mailbox;
   std::unique_ptr<viz::SingleReleaseCallback> release_callback;
 

cc/ipc/struct_traits_unittest.cc

@@ -112,7 +112,7 @@ TEST_F(StructTraitsTest, CopyOutputRequest_BitmapRequest) {
   const auto source =
       base::UnguessableToken::Deserialize(0xdeadbeef, 0xdeadf00d);
   gfx::Size size(9, 8);
-  auto bitmap = base::MakeUnique<SkBitmap>();
+  auto bitmap = std::make_unique<SkBitmap>();
   bitmap->allocN32Pixels(size.width(), size.height());
   base::RunLoop run_loop;
   std::unique_ptr<viz::CopyOutputRequest> input =
@@ -191,10 +191,10 @@ TEST_F(StructTraitsTest, CopyOutputRequest_MessagePipeBroken) {
 }
 
 TEST_F(StructTraitsTest, CopyOutputResult_Bitmap) {
-  auto bitmap = base::MakeUnique<SkBitmap>();
+  auto bitmap = std::make_unique<SkBitmap>();
   bitmap->allocN32Pixels(7, 8);
   bitmap->eraseARGB(123, 213, 77, 33);
-  auto in_bitmap = base::MakeUnique<SkBitmap>();
+  auto in_bitmap = std::make_unique<SkBitmap>();
   in_bitmap->allocN32Pixels(7, 8);
   in_bitmap->eraseARGB(123, 213, 77, 33);
   auto input = viz::CopyOutputResult::CreateBitmapResult(std::move(bitmap));

cc/layers/heads_up_display_layer_impl.cc

@@ -95,7 +95,7 @@ void HeadsUpDisplayLayerImpl::AcquireResource(
     }
   }
 
-  auto resource = base::MakeUnique<ScopedResource>(resource_provider);
+  auto resource = std::make_unique<ScopedResource>(resource_provider);
   resource->Allocate(internal_content_bounds_,
                      ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
                      resource_provider->best_render_buffer_format(),

cc/layers/layer_impl.cc

@@ -384,20 +384,20 @@ std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() {
   result->SetInteger("LayerId", id());
   result->SetString("LayerType", LayerTypeAsString());
 
-  auto list = base::MakeUnique<base::ListValue>();
+  auto list = std::make_unique<base::ListValue>();
   list->AppendInteger(bounds().width());
   list->AppendInteger(bounds().height());
   result->Set("Bounds", std::move(list));
 
-  list = base::MakeUnique<base::ListValue>();
+  list = std::make_unique<base::ListValue>();
   list->AppendDouble(position_.x());
   list->AppendDouble(position_.y());
   result->Set("Position", std::move(list));
 
   const gfx::Transform& gfx_transform = test_properties()->transform;
   double transform[16];
   gfx_transform.matrix().asColMajord(transform);
-  list = base::MakeUnique<base::ListValue>();
+  list = std::make_unique<base::ListValue>();
   for (int i = 0; i < 16; ++i)
     list->AppendDouble(transform[i]);
   result->Set("Transform", std::move(list));
@@ -416,7 +416,7 @@ std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() {
     result->Set("TouchRegion", std::move(region));
   }
 
-  list = base::MakeUnique<base::ListValue>();
+  list = std::make_unique<base::ListValue>();
   for (size_t i = 0; i < test_properties()->children.size(); ++i)
     list->Append(test_properties()->children[i]->LayerTreeAsJson());
   result->Set("Children", std::move(list));

cc/layers/scrollbar_layer_unittest.cc

@@ -124,7 +124,7 @@ class BaseScrollbarLayerTest : public testing::Test {
 
     std::unique_ptr<FakeResourceTrackingUIResourceManager>
         fake_ui_resource_manager =
-            base::MakeUnique<FakeResourceTrackingUIResourceManager>();
+            std::make_unique<FakeResourceTrackingUIResourceManager>();
     fake_ui_resource_manager_ = fake_ui_resource_manager.get();
 
     layer_tree_host_.reset(new FakeLayerTreeHost(

cc/layers/surface_layer.cc

@@ -131,7 +131,7 @@ void SurfaceLayer::PushPropertiesTo(LayerImpl* layer) {
 void SurfaceLayer::RemoveReference(base::Closure reference_returner) {
   if (!reference_returner)
     return;
-  auto swap_promise = base::MakeUnique<SatisfySwapPromise>(
+  auto swap_promise = std::make_unique<SatisfySwapPromise>(
       std::move(reference_returner),
       layer_tree_host()->GetTaskRunnerProvider()->MainThreadTaskRunner());
   layer_tree_host()->GetSwapPromiseManager()->QueueSwapPromise(