diff --git a/cc/PRESUBMIT.py b/cc/PRESUBMIT.py
index 0f556cc..241a440 100644
--- a/cc/PRESUBMIT.py
+++ b/cc/PRESUBMIT.py

@@ -162,7 +162,7 @@
       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>()

diff --git a/cc/animation/animation_host.cc b/cc/animation/animation_host.cc
index 1e24514f..c3ec776 100644
--- a/cc/animation/animation_host.cc
+++ b/cc/animation/animation_host.cc

@@ -49,9 +49,9 @@
       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 @@
 }
 
 std::unique_ptr<MutatorEvents> AnimationHost::CreateEvents() {
-  return base::MakeUnique<AnimationEvents>();
+  return std::make_unique<AnimationEvents>();
 }
 
 void AnimationHost::SetAnimationEvents(

diff --git a/cc/animation/animation_player_unittest.cc b/cc/animation/animation_player_unittest.cc
index 0a66109..9189156 100644
--- a/cc/animation/animation_player_unittest.cc
+++ b/cc/animation/animation_player_unittest.cc

@@ -419,7 +419,7 @@
       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 @@
             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(

diff --git a/cc/animation/animation_unittest.cc b/cc/animation/animation_unittest.cc
index 8f4d22a..6321b5c 100644
--- a/cc/animation/animation_unittest.cc
+++ b/cc/animation/animation_unittest.cc

@@ -23,7 +23,7 @@
                                            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 @@
   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());
 }

diff --git a/cc/animation/transform_operations_unittest.cc b/cc/animation/transform_operations_unittest.cc
index ca4c1e5..ca73a5a 100644
--- a/cc/animation/transform_operations_unittest.cc
+++ b/cc/animation/transform_operations_unittest.cc

@@ -58,23 +58,23 @@
   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 @@
 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));

diff --git a/cc/benchmarks/invalidation_benchmark.cc b/cc/benchmarks/invalidation_benchmark.cc
index c44a157..f863849 100644
--- a/cc/benchmarks/invalidation_benchmark.cc
+++ b/cc/benchmarks/invalidation_benchmark.cc

@@ -124,7 +124,7 @@
   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;

diff --git a/cc/benchmarks/micro_benchmark_controller.cc b/cc/benchmarks/micro_benchmark_controller.cc
index f55a607..bd83e7e 100644
--- a/cc/benchmarks/micro_benchmark_controller.cc
+++ b/cc/benchmarks/micro_benchmark_controller.cc

@@ -29,12 +29,12 @@
     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;
 }

diff --git a/cc/benchmarks/micro_benchmark_controller_unittest.cc b/cc/benchmarks/micro_benchmark_controller_unittest.cc
index 08f3de6e..f3f497d 100644
--- a/cc/benchmarks/micro_benchmark_controller_unittest.cc
+++ b/cc/benchmarks/micro_benchmark_controller_unittest.cc

@@ -27,7 +27,7 @@
   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);

diff --git a/cc/blink/web_compositor_support_impl.cc b/cc/blink/web_compositor_support_impl.cc
index 8ff9a836..b96dccb 100644
--- a/cc/blink/web_compositor_support_impl.cc
+++ b/cc/blink/web_compositor_support_impl.cc

@@ -37,28 +37,28 @@
 }
 
 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>
@@ -66,7 +66,7 @@
     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 @@
     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 @@
     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);
 }

diff --git a/cc/blink/web_content_layer_impl.cc b/cc/blink/web_content_layer_impl.cc
index 82d152a..fe7d016 100644
--- a/cc/blink/web_content_layer_impl.cc
+++ b/cc/blink/web_content_layer_impl.cc

@@ -47,7 +47,7 @@
 
 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);
 }
 

diff --git a/cc/blink/web_scrollbar_layer_impl.cc b/cc/blink/web_scrollbar_layer_impl.cc
index 0db9d0f..c9cf9c30 100644
--- a/cc/blink/web_scrollbar_layer_impl.cc
+++ b/cc/blink/web_scrollbar_layer_impl.cc

@@ -39,12 +39,12 @@
     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()))) {}

diff --git a/cc/input/browser_controls_offset_manager_unittest.cc b/cc/input/browser_controls_offset_manager_unittest.cc
index c141b83..0d436502 100644
--- a/cc/input/browser_controls_offset_manager_unittest.cc
+++ b/cc/input/browser_controls_offset_manager_unittest.cc

@@ -38,7 +38,7 @@
         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);

diff --git a/cc/ipc/copy_output_request_struct_traits.cc b/cc/ipc/copy_output_request_struct_traits.cc
index 889d962..b24f662 100644
--- a/cc/ipc/copy_output_request_struct_traits.cc
+++ b/cc/ipc/copy_output_request_struct_traits.cc

@@ -55,7 +55,7 @@
              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;

diff --git a/cc/ipc/copy_output_result_struct_traits.cc b/cc/ipc/copy_output_result_struct_traits.cc
index f6480c8..a5e5629 100644
--- a/cc/ipc/copy_output_result_struct_traits.cc
+++ b/cc/ipc/copy_output_result_struct_traits.cc

@@ -69,7 +69,7 @@
   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 @@
   // 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;
 

diff --git a/cc/ipc/struct_traits_unittest.cc b/cc/ipc/struct_traits_unittest.cc
index 3273897..c5c51ee 100644
--- a/cc/ipc/struct_traits_unittest.cc
+++ b/cc/ipc/struct_traits_unittest.cc

@@ -112,7 +112,7 @@
   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, 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));

diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index 65e3319..892d243 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc

@@ -95,7 +95,7 @@
     }
   }
 
-  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(),

diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index e0ec09b..4193566 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc

@@ -384,12 +384,12 @@
   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));
@@ -397,7 +397,7 @@
   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 @@
     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));

diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 400d3f0..14d0363 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc

@@ -124,7 +124,7 @@
 
     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(

diff --git a/cc/layers/surface_layer.cc b/cc/layers/surface_layer.cc
index ec81333..ade8f040 100644
--- a/cc/layers/surface_layer.cc
+++ b/cc/layers/surface_layer.cc

@@ -131,7 +131,7 @@
 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(

diff --git a/cc/layers/texture_layer.cc b/cc/layers/texture_layer.cc
index d92c3e71..df6e6c1 100644
--- a/cc/layers/texture_layer.cc
+++ b/cc/layers/texture_layer.cc

@@ -259,7 +259,7 @@
 TextureLayer::TextureMailboxHolder::Create(
     const viz::TextureMailbox& mailbox,
     std::unique_ptr<viz::SingleReleaseCallback> release_callback) {
-  return base::MakeUnique<MainThreadReference>(
+  return std::make_unique<MainThreadReference>(
       new TextureMailboxHolder(mailbox, std::move(release_callback)));
 }
 

diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 10bdf93..1f0be41 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc

@@ -106,7 +106,7 @@
     // Have to upload a copy to a texture for it to be used in a
     // hardware draw.
     if (!texture_copy_)
-      texture_copy_ = base::MakeUnique<ScopedResource>(resource_provider);
+      texture_copy_ = std::make_unique<ScopedResource>(resource_provider);
     if (texture_copy_->size() != texture_mailbox_.size_in_pixels() ||
         resource_provider->InUseByConsumer(texture_copy_->id()))
       texture_copy_->Free();

diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index b9cc894a..ed4de24d 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc

@@ -646,7 +646,7 @@
     bool synchronous_composite =
         !HasImplThread() &&
         !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
-    return base::MakeUnique<viz::TestLayerTreeFrameSink>(
+    return std::make_unique<viz::TestLayerTreeFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
         ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,

diff --git a/cc/layers/touch_action_region.cc b/cc/layers/touch_action_region.cc
index 783b9fa8..9d516a0 100644
--- a/cc/layers/touch_action_region.cc
+++ b/cc/layers/touch_action_region.cc

@@ -9,17 +9,17 @@
 
 namespace cc {
 
-TouchActionRegion::TouchActionRegion() : region_(base::MakeUnique<Region>()) {}
+TouchActionRegion::TouchActionRegion() : region_(std::make_unique<Region>()) {}
 TouchActionRegion::TouchActionRegion(
     const TouchActionRegion& touch_action_region)
     : map_(touch_action_region.map_),
-      region_(base::MakeUnique<Region>(touch_action_region.region())) {}
+      region_(std::make_unique<Region>(touch_action_region.region())) {}
 TouchActionRegion::TouchActionRegion(TouchActionRegion&& touch_action_region) =
     default;
 
 TouchActionRegion::TouchActionRegion(
     const base::flat_map<TouchAction, Region>& region_map)
-    : map_(region_map), region_(base::MakeUnique<Region>()) {
+    : map_(region_map), region_(std::make_unique<Region>()) {
   for (const auto& pair : region_map) {
     region_->Union(pair.second);
   }

diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 8ae67e8..caa1551 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc

@@ -146,7 +146,7 @@
 
   result->Set("ImageBounds", MathUtil::AsValue(image_bounds_));
 
-  auto list = base::MakeUnique<base::ListValue>();
+  auto list = std::make_unique<base::ListValue>();
   list->AppendDouble(vertex_opacity_[0]);
   list->AppendDouble(vertex_opacity_[1]);
   list->AppendDouble(vertex_opacity_[2]);

diff --git a/cc/output/bsp_tree.cc b/cc/output/bsp_tree.cc
index 1d203f3f..964b488 100644
--- a/cc/output/bsp_tree.cc
+++ b/cc/output/bsp_tree.cc

@@ -24,7 +24,7 @@
   if (list->size() == 0)
     return;
 
-  root_ = base::MakeUnique<BspNode>(PopFront(list));
+  root_ = std::make_unique<BspNode>(PopFront(list));
   BuildTree(root_.get(), list);
 }
 
@@ -67,13 +67,13 @@
 
   // Build the back subtree using the front of the back_list as our splitter.
   if (back_list.size() > 0) {
-    node->back_child = base::MakeUnique<BspNode>(PopFront(&back_list));
+    node->back_child = std::make_unique<BspNode>(PopFront(&back_list));
     BuildTree(node->back_child.get(), &back_list);
   }
 
   // Build the front subtree using the front of the front_list as our splitter.
   if (front_list.size() > 0) {
-    node->front_child = base::MakeUnique<BspNode>(PopFront(&front_list));
+    node->front_child = std::make_unique<BspNode>(PopFront(&front_list));
     BuildTree(node->front_child.get(), &front_list);
   }
 }

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index f05440bd..ee9e5b5 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc

@@ -219,7 +219,7 @@
   for (auto& pass : render_passes_in_draw_order) {
     auto& resource = render_pass_textures_[pass->id];
     if (!resource) {
-      resource = base::MakeUnique<ScopedResource>(resource_provider_);
+      resource = std::make_unique<ScopedResource>(resource_provider_);
 
       // |has_damage_from_contributing_content| is used to determine if previous
       // contents can be reused when caching render pass and as a result needs

diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index c5017a8..4443d02 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc

@@ -74,7 +74,7 @@
 class FullscreenOverlayValidator : public OverlayCandidateValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(base::MakeUnique<OverlayStrategyFullscreen>(this));
+    strategies->push_back(std::make_unique<OverlayStrategyFullscreen>(this));
   }
   bool AllowCALayerOverlays() override { return false; }
   bool AllowDCLayerOverlays() override { return false; }
@@ -86,8 +86,8 @@
   SingleOverlayValidator() : expected_rects_(1, gfx::RectF(kOverlayRect)) {}
 
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this));
-    strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this));
+    strategies->push_back(std::make_unique<OverlayStrategySingleOnTop>(this));
+    strategies->push_back(std::make_unique<OverlayStrategyUnderlay>(this));
   }
 
   bool AllowCALayerOverlays() override { return false; }
@@ -149,21 +149,21 @@
 class SingleOnTopOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this));
+    strategies->push_back(std::make_unique<OverlayStrategySingleOnTop>(this));
   }
 };
 
 class UnderlayOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this));
+    strategies->push_back(std::make_unique<OverlayStrategyUnderlay>(this));
   }
 };
 
 class UnderlayCastOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(base::MakeUnique<OverlayStrategyUnderlayCast>(this));
+    strategies->push_back(std::make_unique<OverlayStrategyUnderlayCast>(this));
   }
 };
 
@@ -466,7 +466,7 @@
   void SetUp() override {
     provider_ = TestContextProvider::Create();
     provider_->BindToCurrentThread();
-    output_surface_ = base::MakeUnique<OutputSurfaceType>(provider_);
+    output_surface_ = std::make_unique<OutputSurfaceType>(provider_);
     output_surface_->BindToClient(&client_);
     output_surface_->SetOverlayCandidateValidator(
         new OverlayCandidateValidatorType);
@@ -2341,7 +2341,7 @@
     if (use_validator)
       output_surface_->SetOverlayCandidateValidator(new SingleOverlayValidator);
 
-    renderer_ = base::MakeUnique<OverlayInfoRendererGL>(
+    renderer_ = std::make_unique<OverlayInfoRendererGL>(
         &settings_, output_surface_.get(), resource_provider_.get());
     renderer_->Initialize();
     renderer_->SetVisible(true);

diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 40620564..b907126 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc

@@ -119,10 +119,10 @@
   // same texture again.
   current_framebuffer_lock_ = nullptr;
   current_framebuffer_lock_ =
-      base::MakeUnique<ResourceProvider::ScopedWriteLockSoftware>(
+      std::make_unique<ResourceProvider::ScopedWriteLockSoftware>(
           resource_provider_, texture->id());
   current_framebuffer_canvas_ =
-      base::MakeUnique<SkCanvas>(current_framebuffer_lock_->sk_bitmap());
+      std::make_unique<SkCanvas>(current_framebuffer_lock_->sk_bitmap());
   current_canvas_ = current_framebuffer_canvas_.get();
   return true;
 }

diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 8a63764..818b43a5 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc

@@ -44,7 +44,7 @@
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create<DisplayResourceProvider>(
         nullptr, shared_bitmap_manager_.get());
-    renderer_ = base::MakeUnique<SoftwareRenderer>(
+    renderer_ = std::make_unique<SoftwareRenderer>(
         &settings_, output_surface_.get(), resource_provider());
     renderer_->Initialize();
     renderer_->SetVisible(true);
@@ -429,7 +429,7 @@
 
   settings_.partial_swap_enabled = true;
 
-  auto device_owned = base::MakeUnique<PartialSwapSoftwareOutputDevice>();
+  auto device_owned = std::make_unique<PartialSwapSoftwareOutputDevice>();
   auto* device = device_owned.get();
   InitializeRenderer(std::move(device_owned));
 

diff --git a/cc/paint/display_item_list.cc b/cc/paint/display_item_list.cc
index 260e17a..bf6fbefc 100644
--- a/cc/paint/display_item_list.cc
+++ b/cc/paint/display_item_list.cc

@@ -115,7 +115,7 @@
 
 std::unique_ptr<base::trace_event::TracedValue>
 DisplayItemList::CreateTracedValue(bool include_items) const {
-  auto state = base::MakeUnique<base::trace_event::TracedValue>();
+  auto state = std::make_unique<base::trace_event::TracedValue>();
   state->BeginDictionary("params");
 
   if (include_items) {

diff --git a/cc/paint/paint_image.cc b/cc/paint/paint_image.cc
index 4059ce9d..96811f6 100644
--- a/cc/paint/paint_image.cc
+++ b/cc/paint/paint_image.cc

@@ -52,7 +52,7 @@
         nullptr, nullptr, SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB());
   } else if (paint_image_generator_) {
     cached_sk_image_ = SkImage::MakeFromGenerator(
-        base::MakeUnique<SkiaPaintImageGenerator>(paint_image_generator_));
+        std::make_unique<SkiaPaintImageGenerator>(paint_image_generator_));
   }
 
   if (!subset_rect_.IsEmpty() && cached_sk_image_) {

diff --git a/cc/paint/paint_image_builder.h b/cc/paint/paint_image_builder.h
index 36c3e0f6..c3b72c75 100644
--- a/cc/paint/paint_image_builder.h
+++ b/cc/paint/paint_image_builder.h

@@ -70,7 +70,7 @@
     paint_image_.paint_image_generator_ = std::move(generator);
 
     paint_image_.cached_sk_image_ =
-        SkImage::MakeFromGenerator(base::MakeUnique<SkiaPaintImageGenerator>(
+        SkImage::MakeFromGenerator(std::make_unique<SkiaPaintImageGenerator>(
             paint_image_.paint_image_generator_, unique_id));
     if (allocated_unique_id)
       *allocated_unique_id = paint_image_.cached_sk_image_->uniqueID();

diff --git a/cc/quads/draw_polygon.cc b/cc/quads/draw_polygon.cc
index 98da20ec..2b664f0 100644
--- a/cc/quads/draw_polygon.cc
+++ b/cc/quads/draw_polygon.cc

@@ -295,7 +295,7 @@
     out_points.push_back(pre_neg_intersection);
   }
   *front =
-      base::MakeUnique<DrawPolygon>(polygon->original_ref_, out_points,
+      std::make_unique<DrawPolygon>(polygon->original_ref_, out_points,
                                     polygon->normal_, polygon->order_index_);
 
   out_points.clear();
@@ -308,7 +308,7 @@
     out_points.push_back(pre_pos_intersection);
   }
   *back =
-      base::MakeUnique<DrawPolygon>(polygon->original_ref_, out_points,
+      std::make_unique<DrawPolygon>(polygon->original_ref_, out_points,
                                     polygon->normal_, polygon->order_index_);
 
   DCHECK_GE((*front)->points().size(), 3u);

diff --git a/cc/quads/draw_polygon_unittest.cc b/cc/quads/draw_polygon_unittest.cc
index 6a5ff18..870a867 100644
--- a/cc/quads/draw_polygon_unittest.cc
+++ b/cc/quads/draw_polygon_unittest.cc

@@ -72,7 +72,7 @@
   DrawPolygon name(NULL, points_vector, normal, polygon_id)
 
 #define CREATE_NEW_DRAW_POLYGON_PTR(name, points_vector, normal, polygon_id) \
-  std::unique_ptr<DrawPolygon> name(base::MakeUnique<DrawPolygon>(           \
+  std::unique_ptr<DrawPolygon> name(std::make_unique<DrawPolygon>(           \
       nullptr, points_vector, normal, polygon_id))
 
 #define CREATE_TEST_DRAW_FORWARD_POLYGON(name, points_vector, id)        \

diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index dcd8be4..779a6602 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc

@@ -44,11 +44,11 @@
   SkBlendMode blend_mode = SkBlendMode::kMultiply;
   int sorting_context_id = 65536;
 
-  auto state = base::MakeUnique<viz::SharedQuadState>();
+  auto state = std::make_unique<viz::SharedQuadState>();
   state->SetAll(quad_transform, layer_rect, visible_layer_rect, clip_rect,
                 is_clipped, opacity, blend_mode, sorting_context_id);
 
-  auto copy = base::MakeUnique<viz::SharedQuadState>(*state);
+  auto copy = std::make_unique<viz::SharedQuadState>(*state);
   EXPECT_EQ(quad_transform, copy->quad_to_target_transform);
   EXPECT_EQ(visible_layer_rect, copy->visible_quad_layer_rect);
   EXPECT_EQ(opacity, copy->opacity);

diff --git a/cc/quads/nine_patch_generator.cc b/cc/quads/nine_patch_generator.cc
index 5644a518..65e034d 100644
--- a/cc/quads/nine_patch_generator.cc
+++ b/cc/quads/nine_patch_generator.cc

@@ -370,14 +370,14 @@
 }
 
 void NinePatchGenerator::AsJson(base::DictionaryValue* dictionary) const {
-  auto list = base::MakeUnique<base::ListValue>();
+  auto list = std::make_unique<base::ListValue>();
   list->AppendInteger(image_aperture_.origin().x());
   list->AppendInteger(image_aperture_.origin().y());
   list->AppendInteger(image_aperture_.size().width());
   list->AppendInteger(image_aperture_.size().height());
   dictionary->Set("ImageAperture", std::move(list));
 
-  list = base::MakeUnique<base::ListValue>();
+  list = std::make_unique<base::ListValue>();
   list->AppendInteger(image_bounds_.width());
   list->AppendInteger(image_bounds_.height());
   dictionary->Set("ImageBounds", std::move(list));
@@ -386,7 +386,7 @@
 
   dictionary->SetBoolean("FillCenter", fill_center_);
 
-  list = base::MakeUnique<base::ListValue>();
+  list = std::make_unique<base::ListValue>();
   list->AppendInteger(output_occlusion_.x());
   list->AppendInteger(output_occlusion_.y());
   list->AppendInteger(output_occlusion_.width());

diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc
index c113113..a73eabf 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc

@@ -290,7 +290,7 @@
 
 TEST(RenderPassTest, ReplacedQuadsShouldntMove) {
   std::unique_ptr<viz::SharedQuadState> quad_state =
-      base::MakeUnique<viz::SharedQuadState>();
+      std::make_unique<viz::SharedQuadState>();
   QuadList quad_list;
   SolidColorDrawQuad* quad =
       quad_list.AllocateAndConstruct<SolidColorDrawQuad>();

diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index 4c0e4a01..0baf3619 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc

@@ -156,7 +156,7 @@
     uint64_t previous_content_id) {
   bool resource_has_previous_content =
       resource_content_id && resource_content_id == previous_content_id;
-  return base::MakeUnique<RasterBufferImpl>(
+  return std::make_unique<RasterBufferImpl>(
       this, resource_provider_, resource->id(), resource_has_previous_content);
 }
 

diff --git a/cc/raster/one_copy_raster_buffer_provider.cc b/cc/raster/one_copy_raster_buffer_provider.cc
index 7d861219..23f0d7e 100644
--- a/cc/raster/one_copy_raster_buffer_provider.cc
+++ b/cc/raster/one_copy_raster_buffer_provider.cc

@@ -108,7 +108,7 @@
     uint64_t previous_content_id) {
   // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
   // the dirty rect.
-  return base::MakeUnique<RasterBufferImpl>(this, resource_provider_, resource,
+  return std::make_unique<RasterBufferImpl>(this, resource_provider_, resource,
                                             previous_content_id);
 }
 

diff --git a/cc/raster/raster_buffer_provider_perftest.cc b/cc/raster/raster_buffer_provider_perftest.cc
index 12e48a14..0f036e3 100644
--- a/cc/raster/raster_buffer_provider_perftest.cc
+++ b/cc/raster/raster_buffer_provider_perftest.cc

@@ -243,7 +243,7 @@
 
     for (unsigned i = 0; i < num_raster_tasks; ++i) {
       auto resource =
-          base::MakeUnique<ScopedResource>(resource_provider_.get());
+          std::make_unique<ScopedResource>(resource_provider_.get());
       resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                          viz::RGBA_8888, gfx::ColorSpace());
 
@@ -330,7 +330,7 @@
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<OneCopyRasterBufferProvider>(
             task_runner_.get(), compositor_context_provider_.get(),
             worker_context_provider_.get(), resource_provider_.get(),
             std::numeric_limits<int>::max(), false,
@@ -339,7 +339,7 @@
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<GpuRasterBufferProvider>(
             compositor_context_provider_.get(), worker_context_provider_.get(),
             resource_provider_.get(), false, 0,
             viz::PlatformColor::BestTextureFormat(), false);

diff --git a/cc/raster/raster_buffer_provider_unittest.cc b/cc/raster/raster_buffer_provider_unittest.cc
index 018b954..2890ec3 100644
--- a/cc/raster/raster_buffer_provider_unittest.cc
+++ b/cc/raster/raster_buffer_provider_unittest.cc

@@ -163,7 +163,7 @@
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<OneCopyRasterBufferProvider>(
             base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
             worker_context_provider_.get(), resource_provider_.get(),
             kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
@@ -171,7 +171,7 @@
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<OneCopyRasterBufferProvider>(
             base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
             worker_context_provider_.get(), resource_provider_.get(),
             kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
@@ -179,14 +179,14 @@
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<GpuRasterBufferProvider>(
             context_provider_.get(), worker_context_provider_.get(),
             resource_provider_.get(), false, 0,
             viz::PlatformColor::BestTextureFormat(), false);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU:
         Create3dResourceProvider();
-        raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
+        raster_buffer_provider_ = std::make_unique<GpuRasterBufferProvider>(
             context_provider_.get(), worker_context_provider_.get(),
             resource_provider_.get(), false, 0,
             viz::PlatformColor::BestTextureFormat(), true);
@@ -237,7 +237,7 @@
   }
 
   void AppendTask(unsigned id, const gfx::Size& size) {
-    auto resource = base::MakeUnique<ScopedResource>(resource_provider_.get());
+    auto resource = std::make_unique<ScopedResource>(resource_provider_.get());
     resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                        viz::RGBA_8888, gfx::ColorSpace());
 
@@ -256,7 +256,7 @@
   void AppendBlockingTask(unsigned id, base::Lock* lock) {
     const gfx::Size size(1, 1);
 
-    auto resource = base::MakeUnique<ScopedResource>(resource_provider_.get());
+    auto resource = std::make_unique<ScopedResource>(resource_provider_.get());
     resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                        viz::RGBA_8888, gfx::ColorSpace());
 

diff --git a/cc/raster/staging_buffer_pool.cc b/cc/raster/staging_buffer_pool.cc
index e5951e7..81b0e7e 100644
--- a/cc/raster/staging_buffer_pool.cc
+++ b/cc/raster/staging_buffer_pool.cc

@@ -333,7 +333,7 @@
   // Create new staging buffer if necessary.
   if (!staging_buffer) {
     staging_buffer =
-        base::MakeUnique<StagingBuffer>(resource->size(), resource->format());
+        std::make_unique<StagingBuffer>(resource->size(), resource->format());
     AddStagingBuffer(staging_buffer.get(), resource->format());
   }
 

diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 6f21946..097cc07 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc

@@ -466,12 +466,12 @@
         gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();
 
     viz::ResourceSettings resource_settings = CreateResourceSettings();
-    resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
+    resource_provider_ = std::make_unique<DisplayResourceProvider>(
         context_provider_.get(), shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
         kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
         resource_settings);
-    child_resource_provider_ = base::MakeUnique<LayerTreeResourceProvider>(
+    child_resource_provider_ = std::make_unique<LayerTreeResourceProvider>(
         child_context_provider_.get(), shared_bitmap_manager_.get(),
         child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
         child_needs_sync_token, kEnableColorCorrectRendering,
@@ -1144,7 +1144,7 @@
   std::vector<std::unique_ptr<ResourceProvider::ScopedReadLockGL>> read_locks;
   for (auto& parent_resource : list) {
     resource_provider_->WaitSyncToken(parent_resource.id);
-    read_locks.push_back(base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
+    read_locks.push_back(std::make_unique<ResourceProvider::ScopedReadLockGL>(
         resource_provider_.get(), parent_resource.id));
   }
 
@@ -1152,7 +1152,7 @@
                                                     viz::ResourceIdSet());
   std::unique_ptr<DisplayResourceProvider::ScopedBatchReturnResources>
       returner =
-          base::MakeUnique<DisplayResourceProvider::ScopedBatchReturnResources>(
+          std::make_unique<DisplayResourceProvider::ScopedBatchReturnResources>(
               resource_provider_.get());
   EXPECT_EQ(0u, returned_to_child.size());
 
@@ -1622,7 +1622,7 @@
   child_context_provider->BindToCurrentThread();
 
   std::unique_ptr<LayerTreeResourceProvider> child_resource_provider(
-      base::MakeUnique<LayerTreeResourceProvider>(
+      std::make_unique<LayerTreeResourceProvider>(
           child_context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -1899,11 +1899,11 @@
     auto child_context_provider =
         TestContextProvider::Create(std::move(child_context_owned));
     child_context_provider->BindToCurrentThread();
-    auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
+    auto shared_bitmap_manager = std::make_unique<TestSharedBitmapManager>();
 
     viz::ResourceSettings resource_settings = CreateResourceSettings();
     std::unique_ptr<LayerTreeResourceProvider> child_resource_provider(
-        base::MakeUnique<LayerTreeResourceProvider>(
+        std::make_unique<LayerTreeResourceProvider>(
             child_context_provider.get(), shared_bitmap_manager.get(), nullptr,
             nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
             resource_settings));
@@ -1917,7 +1917,7 @@
     parent_context_provider->BindToCurrentThread();
 
     std::unique_ptr<DisplayResourceProvider> parent_resource_provider(
-        base::MakeUnique<DisplayResourceProvider>(
+        std::make_unique<DisplayResourceProvider>(
             parent_context_provider.get(), shared_bitmap_manager.get(), nullptr,
             nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
             resource_settings));
@@ -2406,7 +2406,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2485,7 +2485,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2528,7 +2528,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2572,7 +2572,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2627,7 +2627,7 @@
       CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, kBadBeef));
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           nullptr, shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2677,7 +2677,7 @@
     context_provider->BindToCurrentThread();
 
     std::unique_ptr<ResourceProvider> resource_provider(
-        base::MakeUnique<ResourceProvider>(
+        std::make_unique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager,
             gpu_memory_buffer_manager, main_thread_task_runner,
             kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2821,7 +2821,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2890,7 +2890,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2945,7 +2945,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -2994,7 +2994,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<LayerTreeResourceProvider> resource_provider(
-      base::MakeUnique<LayerTreeResourceProvider>(
+      std::make_unique<LayerTreeResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3108,7 +3108,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3165,7 +3165,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3221,7 +3221,7 @@
   context_provider->BindToCurrentThread();
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3277,7 +3277,7 @@
   const unsigned kImageId = 234u;
 
   std::unique_ptr<LayerTreeResourceProvider> resource_provider(
-      base::MakeUnique<LayerTreeResourceProvider>(
+      std::make_unique<LayerTreeResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3349,7 +3349,7 @@
 
   gfx::Size size(4, 4);
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3381,7 +3381,7 @@
 
   gfx::Size size(4, 4);
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3429,7 +3429,7 @@
   TextureIdAllocationTrackingContext* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
-  auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
+  auto shared_bitmap_manager = std::make_unique<TestSharedBitmapManager>();
 
   gfx::Size size(1, 1);
   viz::ResourceFormat format = viz::RGBA_8888;
@@ -3437,7 +3437,7 @@
   {
     size_t kTextureAllocationChunkSize = 1;
     std::unique_ptr<ResourceProvider> resource_provider(
-        base::MakeUnique<ResourceProvider>(
+        std::make_unique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager.get(), nullptr,
             nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
             CreateResourceSettings(kTextureAllocationChunkSize)));
@@ -3455,7 +3455,7 @@
   {
     size_t kTextureAllocationChunkSize = 8;
     std::unique_ptr<ResourceProvider> resource_provider(
-        base::MakeUnique<ResourceProvider>(
+        std::make_unique<ResourceProvider>(
             context_provider.get(), shared_bitmap_manager.get(), nullptr,
             nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
             CreateResourceSettings(kTextureAllocationChunkSize)));
@@ -3516,7 +3516,7 @@
   const unsigned kTextureId = 123u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3566,7 +3566,7 @@
   const unsigned kImageId = 234u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3619,7 +3619,7 @@
   const unsigned kWorkerTextureId = 234u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3704,7 +3704,7 @@
   const unsigned kImageId = 345u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
-      base::MakeUnique<ResourceProvider>(
+      std::make_unique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,

diff --git a/cc/resources/scoped_resource_unittest.cc b/cc/resources/scoped_resource_unittest.cc
index ca76b41d..42b2e367 100644
--- a/cc/resources/scoped_resource_unittest.cc
+++ b/cc/resources/scoped_resource_unittest.cc

@@ -24,7 +24,7 @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(context_provider.get(),
                                    shared_bitmap_manager.get());
-  auto texture = base::MakeUnique<ScopedResource>(resource_provider.get());
+  auto texture = std::make_unique<ScopedResource>(resource_provider.get());
 
   // New scoped textures do not hold a texture yet.
   EXPECT_EQ(0u, texture->id());
@@ -45,7 +45,7 @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(context_provider.get(),
                                    shared_bitmap_manager.get());
-  auto texture = base::MakeUnique<ScopedResource>(resource_provider.get());
+  auto texture = std::make_unique<ScopedResource>(resource_provider.get());
   texture->Allocate(gfx::Size(30, 30), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                     viz::RGBA_8888, gfx::ColorSpace());
 
@@ -70,7 +70,7 @@
       FakeResourceProvider::Create(context_provider.get(),
                                    shared_bitmap_manager.get());
   {
-    auto texture = base::MakeUnique<ScopedResource>(resource_provider.get());
+    auto texture = std::make_unique<ScopedResource>(resource_provider.get());
 
     EXPECT_EQ(0u, resource_provider->num_resources());
     texture->Allocate(gfx::Size(30, 30),
@@ -82,7 +82,7 @@
 
   EXPECT_EQ(0u, resource_provider->num_resources());
   {
-    auto texture = base::MakeUnique<ScopedResource>(resource_provider.get());
+    auto texture = std::make_unique<ScopedResource>(resource_provider.get());
     EXPECT_EQ(0u, resource_provider->num_resources());
     texture->Allocate(gfx::Size(30, 30),
                       ResourceProvider::TEXTURE_HINT_IMMUTABLE, viz::RGBA_8888,

diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index e30613f..a3331aa 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc

@@ -705,7 +705,7 @@
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 Scheduler::AsValue() const {
-  auto state = base::MakeUnique<base::trace_event::TracedValue>();
+  auto state = std::make_unique<base::trace_event::TracedValue>();
   AsValueInto(state.get());
   return std::move(state);
 }

diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 1744eb2c..0358b479 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc

@@ -263,13 +263,13 @@
   TestScheduler* CreateScheduler(BeginFrameSourceType bfs_type) {
     viz::BeginFrameSource* frame_source = nullptr;
     unthrottled_frame_source_.reset(new viz::BackToBackBeginFrameSource(
-        base::MakeUnique<viz::FakeDelayBasedTimeSource>(now_src_.get(),
+        std::make_unique<viz::FakeDelayBasedTimeSource>(now_src_.get(),
                                                         task_runner_.get())));
     fake_external_begin_frame_source_.reset(
         new viz::FakeExternalBeginFrameSource(0.f, false));
     fake_external_begin_frame_source_->SetClient(client_.get());
     synthetic_frame_source_.reset(new viz::DelayBasedBeginFrameSource(
-        base::MakeUnique<viz::FakeDelayBasedTimeSource>(now_src_.get(),
+        std::make_unique<viz::FakeDelayBasedTimeSource>(now_src_.get(),
                                                         task_runner_.get())));
     switch (bfs_type) {
       case EXTERNAL_BFS:
@@ -309,11 +309,11 @@
   }
 
   void SetUpScheduler(BeginFrameSourceType bfs_type) {
-    SetUpScheduler(bfs_type, base::MakeUnique<FakeSchedulerClient>());
+    SetUpScheduler(bfs_type, std::make_unique<FakeSchedulerClient>());
   }
 
   void SetUpSchedulerWithNoLayerTreeFrameSink(BeginFrameSourceType bfs_type) {
-    client_ = base::MakeUnique<FakeSchedulerClient>();
+    client_ = std::make_unique<FakeSchedulerClient>();
     CreateScheduler(bfs_type);
   }
 

diff --git a/cc/test/fake_layer_tree_frame_sink.cc b/cc/test/fake_layer_tree_frame_sink.cc
index 34679e5..dfc59ba 100644
--- a/cc/test/fake_layer_tree_frame_sink.cc
+++ b/cc/test/fake_layer_tree_frame_sink.cc

@@ -34,8 +34,8 @@
 bool FakeLayerTreeFrameSink::BindToClient(LayerTreeFrameSinkClient* client) {
   if (!LayerTreeFrameSink::BindToClient(client))
     return false;
-  begin_frame_source_ = base::MakeUnique<viz::BackToBackBeginFrameSource>(
-      base::MakeUnique<viz::DelayBasedTimeSource>(
+  begin_frame_source_ = std::make_unique<viz::BackToBackBeginFrameSource>(
+      std::make_unique<viz::DelayBasedTimeSource>(
           base::ThreadTaskRunnerHandle::Get().get()));
   client_->SetBeginFrameSource(begin_frame_source_.get());
   return true;

diff --git a/cc/test/fake_painted_scrollbar_layer.cc b/cc/test/fake_painted_scrollbar_layer.cc
index 0440a70..34e02bd 100644
--- a/cc/test/fake_painted_scrollbar_layer.cc
+++ b/cc/test/fake_painted_scrollbar_layer.cc

@@ -59,7 +59,7 @@
 
 std::unique_ptr<base::AutoReset<bool>>
 FakePaintedScrollbarLayer::IgnoreSetNeedsCommit() {
-  return base::MakeUnique<base::AutoReset<bool>>(&ignore_set_needs_commit_,
+  return std::make_unique<base::AutoReset<bool>>(&ignore_set_needs_commit_,
                                                  true);
 }
 

diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index e4bd8810..3d29ef1 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc

@@ -49,7 +49,7 @@
                GetGlobalRasterBufferProvider(),
                std::numeric_limits<size_t>::max(),
                false /* use_gpu_rasterization */);
-  SetTileTaskManagerForTesting(base::MakeUnique<FakeTileTaskManagerImpl>());
+  SetTileTaskManagerForTesting(std::make_unique<FakeTileTaskManagerImpl>());
 }
 
 FakeTileManager::~FakeTileManager() {}

diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index 36913ce..f42b857 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc

@@ -154,7 +154,7 @@
       EXPECT_TRUE(worker_context_provider);
       EXPECT_EQ(PIXEL_TEST_GL, test_type_);
 
-      *raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
+      *raster_buffer_provider = std::make_unique<GpuRasterBufferProvider>(
           compositor_context_provider, worker_context_provider,
           resource_provider, false, 0, viz::PlatformColor::BestTextureFormat(),
           false);
@@ -171,7 +171,7 @@
       EXPECT_TRUE(worker_context_provider);
       EXPECT_EQ(PIXEL_TEST_GL, test_type_);
 
-      *raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
+      *raster_buffer_provider = std::make_unique<OneCopyRasterBufferProvider>(
           task_runner, compositor_context_provider, worker_context_provider,
           resource_provider, max_bytes_per_copy_operation, false,
           max_staging_buffer_usage_in_bytes,

diff --git a/cc/test/layer_tree_pixel_test.cc b/cc/test/layer_tree_pixel_test.cc
index f571dbd..ee5866d5 100644
--- a/cc/test/layer_tree_pixel_test.cc
+++ b/cc/test/layer_tree_pixel_test.cc

@@ -56,7 +56,7 @@
       !HasImplThread() &&
       !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
   auto delegating_output_surface =
-      base::MakeUnique<viz::TestLayerTreeFrameSink>(
+      std::make_unique<viz::TestLayerTreeFrameSink>(
           compositor_context_provider, std::move(worker_context_provider),
           shared_bitmap_manager(), gpu_memory_buffer_manager(),
           viz::RendererSettings(), ImplThreadTaskRunner(),
@@ -79,11 +79,11 @@
     display_context_provider->BindToCurrentThread();
 
     bool flipped_output_surface = false;
-    display_output_surface = base::MakeUnique<PixelTestOutputSurface>(
+    display_output_surface = std::make_unique<PixelTestOutputSurface>(
         std::move(display_context_provider), flipped_output_surface);
   } else {
-    display_output_surface = base::MakeUnique<PixelTestOutputSurface>(
-        base::MakeUnique<SoftwareOutputDevice>());
+    display_output_surface = std::make_unique<PixelTestOutputSurface>(
+        std::make_unique<SoftwareOutputDevice>());
   }
   return std::move(display_output_surface);
 }

diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 799832b..8616bbb 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc

@@ -419,7 +419,7 @@
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
-        proxy = base::MakeUnique<ProxyMain>(layer_tree_host.get(),
+        proxy = std::make_unique<ProxyMain>(layer_tree_host.get(),
                                             task_runner_provider.get());
         break;
     }
@@ -820,7 +820,7 @@
     ASSERT_TRUE(impl_thread_->Start());
   }
 
-  image_worker_ = base::MakeUnique<base::Thread>("ImageWorker");
+  image_worker_ = std::make_unique<base::Thread>("ImageWorker");
   ASSERT_TRUE(image_worker_->Start());
 
   shared_bitmap_manager_.reset(new TestSharedBitmapManager);
@@ -887,7 +887,7 @@
   bool synchronous_composite =
       !HasImplThread() &&
       !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
-  return base::MakeUnique<viz::TestLayerTreeFrameSink>(
+  return std::make_unique<viz::TestLayerTreeFrameSink>(
       compositor_context_provider, std::move(worker_context_provider),
       shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
       impl_task_runner_, synchronous_composite, disable_display_vsync,

diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 83a5a65..ddffab4f 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc

@@ -167,17 +167,17 @@
       std::make_unique<viz::TestGpuMemoryBufferManager>();
   // Not relevant for display compositor since it's not delegated.
   constexpr bool delegated_sync_points_required = false;
-  resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
+  resource_provider_ = std::make_unique<DisplayResourceProvider>(
       output_surface_->context_provider(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
       delegated_sync_points_required,
       settings_.enable_color_correct_rasterization,
       settings_.resource_settings);
 
-  texture_mailbox_deleter_ = base::MakeUnique<TextureMailboxDeleter>(
+  texture_mailbox_deleter_ = std::make_unique<TextureMailboxDeleter>(
       base::ThreadTaskRunnerHandle::Get());
 
-  renderer_ = base::MakeUnique<viz::GLRenderer>(
+  renderer_ = std::make_unique<viz::GLRenderer>(
       &renderer_settings_, output_surface_.get(), resource_provider_.get(),
       texture_mailbox_deleter_.get());
   renderer_->Initialize();
@@ -191,17 +191,17 @@
 
 void PixelTest::SetUpSoftwareRenderer() {
   output_surface_.reset(
-      new PixelTestOutputSurface(base::MakeUnique<SoftwareOutputDevice>()));
+      new PixelTestOutputSurface(std::make_unique<SoftwareOutputDevice>()));
   output_surface_->BindToClient(output_surface_client_.get());
   shared_bitmap_manager_.reset(new TestSharedBitmapManager());
   constexpr bool delegated_sync_points_required =
       false;  // Meaningless for software.
-  resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
+  resource_provider_ = std::make_unique<DisplayResourceProvider>(
       nullptr, shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),
       main_thread_task_runner_.get(), delegated_sync_points_required,
       settings_.enable_color_correct_rasterization,
       settings_.resource_settings);
-  auto renderer = base::MakeUnique<SoftwareRenderer>(
+  auto renderer = std::make_unique<SoftwareRenderer>(
       &renderer_settings_, output_surface_.get(), resource_provider_.get());
   software_renderer_ = renderer.get();
   renderer_ = std::move(renderer);

diff --git a/cc/test/test_context_provider.cc b/cc/test/test_context_provider.cc
index 49444a9..1243e35 100644
--- a/cc/test/test_context_provider.cc
+++ b/cc/test/test_context_provider.cc

@@ -90,8 +90,8 @@
 // static
 scoped_refptr<TestContextProvider> TestContextProvider::Create() {
   return new TestContextProvider(
-      base::MakeUnique<TestContextSupport>(),
-      base::MakeUnique<TestGLES2InterfaceForContextProvider>(),
+      std::make_unique<TestContextSupport>(),
+      std::make_unique<TestGLES2InterfaceForContextProvider>(),
       TestWebGraphicsContext3D::Create());
 }
 
@@ -99,8 +99,8 @@
 scoped_refptr<TestContextProvider> TestContextProvider::CreateWorker() {
   scoped_refptr<TestContextProvider> worker_context_provider(
       new TestContextProvider(
-          base::MakeUnique<TestContextSupport>(),
-          base::MakeUnique<TestGLES2InterfaceForContextProvider>(),
+          std::make_unique<TestContextSupport>(),
+          std::make_unique<TestGLES2InterfaceForContextProvider>(),
           TestWebGraphicsContext3D::Create()));
   // Worker contexts are bound to the thread they are created on.
   if (!worker_context_provider->BindToCurrentThread())
@@ -113,8 +113,8 @@
     std::unique_ptr<TestWebGraphicsContext3D> context) {
   DCHECK(context);
   return new TestContextProvider(
-      base::MakeUnique<TestContextSupport>(),
-      base::MakeUnique<TestGLES2InterfaceForContextProvider>(),
+      std::make_unique<TestContextSupport>(),
+      std::make_unique<TestGLES2InterfaceForContextProvider>(),
       std::move(context));
 }
 
@@ -122,7 +122,7 @@
 scoped_refptr<TestContextProvider> TestContextProvider::Create(
     std::unique_ptr<TestGLES2Interface> gl) {
   DCHECK(gl);
-  return new TestContextProvider(base::MakeUnique<TestContextSupport>(),
+  return new TestContextProvider(std::make_unique<TestContextSupport>(),
                                  std::move(gl),
                                  TestWebGraphicsContext3D::Create());
 }
@@ -135,7 +135,7 @@
   DCHECK(support);
   return new TestContextProvider(
       std::move(support),
-      base::MakeUnique<TestGLES2InterfaceForContextProvider>(),
+      std::make_unique<TestGLES2InterfaceForContextProvider>(),
       std::move(context));
 }
 
@@ -213,7 +213,7 @@
   if (gr_context_)
     return gr_context_->get();
 
-  gr_context_ = base::MakeUnique<skia_bindings::GrContextForGLES2Interface>(
+  gr_context_ = std::make_unique<skia_bindings::GrContextForGLES2Interface>(
       context_gl_.get(), context3d_->test_capabilities());
   cache_controller_->SetGrContext(gr_context_->get());
 

diff --git a/cc/test/test_layer_tree_host_base.cc b/cc/test/test_layer_tree_host_base.cc
index 153b812..b59b3f5 100644
--- a/cc/test/test_layer_tree_host_base.cc
+++ b/cc/test/test_layer_tree_host_base.cc

@@ -45,7 +45,7 @@
     const LayerTreeSettings& settings,
     TaskRunnerProvider* task_runner_provider,
     TaskGraphRunner* task_graph_runner) {
-  return base::MakeUnique<FakeLayerTreeHostImpl>(settings, task_runner_provider,
+  return std::make_unique<FakeLayerTreeHostImpl>(settings, task_runner_provider,
                                                  task_graph_runner);
 }
 

diff --git a/cc/test/test_shared_bitmap_manager.cc b/cc/test/test_shared_bitmap_manager.cc
index bc30dd5d..0c54deb 100644
--- a/cc/test/test_shared_bitmap_manager.cc
+++ b/cc/test/test_shared_bitmap_manager.cc

@@ -57,7 +57,7 @@
   memory->CreateAndMapAnonymous(size.GetArea() * 4);
   viz::SharedBitmapId id = viz::SharedBitmap::GenerateId();
   bitmap_map_[id] = memory.get();
-  return base::MakeUnique<OwnedSharedBitmap>(std::move(memory), id);
+  return std::make_unique<OwnedSharedBitmap>(std::move(memory), id);
 }
 
 std::unique_ptr<viz::SharedBitmap>
@@ -67,7 +67,7 @@
   if (bitmap_map_.find(id) == bitmap_map_.end())
     return nullptr;
   uint8_t* pixels = static_cast<uint8_t*>(bitmap_map_[id]->memory());
-  return base::MakeUnique<UnownedSharedBitmap>(pixels, id);
+  return std::make_unique<UnownedSharedBitmap>(pixels, id);
 }
 
 }  // namespace cc

diff --git a/cc/tiles/checker_image_tracker.cc b/cc/tiles/checker_image_tracker.cc
index b55ee2ae..5a4e1cf8 100644
--- a/cc/tiles/checker_image_tracker.cc
+++ b/cc/tiles/checker_image_tracker.cc

@@ -413,7 +413,7 @@
           draw_image, base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                                  weak_factory_.GetWeakPtr(), image_id));
 
-  image_id_to_decode_.emplace(image_id, base::MakeUnique<ScopedDecodeHolder>(
+  image_id_to_decode_.emplace(image_id, std::make_unique<ScopedDecodeHolder>(
                                             image_controller_, request_id));
 }
 

diff --git a/cc/tiles/checker_image_tracker_unittest.cc b/cc/tiles/checker_image_tracker_unittest.cc
index 0cf4b400..525760c 100644
--- a/cc/tiles/checker_image_tracker_unittest.cc
+++ b/cc/tiles/checker_image_tracker_unittest.cc

@@ -85,7 +85,7 @@
 
   void SetUpTracker(bool checker_images_enabled) {
     size_t size_to_checker = 512 * 1024;
-    checker_image_tracker_ = base::MakeUnique<CheckerImageTracker>(
+    checker_image_tracker_ = std::make_unique<CheckerImageTracker>(
         &image_controller_, this, checker_images_enabled, size_to_checker);
     checker_image_tracker_->SetMaxDecodePriorityAllowed(
         CheckerImageTracker::DecodeType::kPreDecode);

diff --git a/cc/tiles/eviction_tile_priority_queue.cc b/cc/tiles/eviction_tile_priority_queue.cc
index 44066bbf..acf2da9 100644
--- a/cc/tiles/eviction_tile_priority_queue.cc
+++ b/cc/tiles/eviction_tile_priority_queue.cc

@@ -79,7 +79,7 @@
 
   for (auto* layer : layers) {
     std::unique_ptr<TilingSetEvictionQueue> tiling_set_queue =
-        base::MakeUnique<TilingSetEvictionQueue>(
+        std::make_unique<TilingSetEvictionQueue>(
             layer->picture_layer_tiling_set(),
             layer->contributes_to_drawn_render_surface());
     // Queues will only contain non empty tiling sets.

diff --git a/cc/tiles/picture_layer_tiling_set.cc b/cc/tiles/picture_layer_tiling_set.cc
index 26efb9b..2d4b29e 100644
--- a/cc/tiles/picture_layer_tiling_set.cc
+++ b/cc/tiles/picture_layer_tiling_set.cc

@@ -280,7 +280,7 @@
   }
 #endif  // DCHECK_IS_ON()
 
-  tilings_.push_back(base::MakeUnique<PictureLayerTiling>(
+  tilings_.push_back(std::make_unique<PictureLayerTiling>(
       tree_, raster_transform, raster_source, client_,
       kMaxSoonBorderDistanceInScreenPixels, max_preraster_distance_));
   PictureLayerTiling* appended = tilings_.back().get();

diff --git a/cc/tiles/picture_layer_tiling_set_unittest.cc b/cc/tiles/picture_layer_tiling_set_unittest.cc
index eb4ccdae..b485b7a 100644
--- a/cc/tiles/picture_layer_tiling_set_unittest.cc
+++ b/cc/tiles/picture_layer_tiling_set_unittest.cc

@@ -47,7 +47,7 @@
 std::unique_ptr<TestablePictureLayerTilingSet> CreateTilingSetWithSettings(
     PictureLayerTilingClient* client,
     const LayerTreeSettings& settings) {
-  return base::MakeUnique<TestablePictureLayerTilingSet>(
+  return std::make_unique<TestablePictureLayerTilingSet>(
       ACTIVE_TREE, client, settings.tiling_interest_area_padding,
       settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_screen_pixels,
@@ -248,7 +248,7 @@
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();
     ASSERT_TRUE(context_provider->BindToCurrentThread());
-    auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
+    auto shared_bitmap_manager = std::make_unique<TestSharedBitmapManager>();
     std::unique_ptr<ResourceProvider> resource_provider =
         FakeResourceProvider::Create<LayerTreeResourceProvider>(
             context_provider.get(), shared_bitmap_manager.get());

diff --git a/cc/tiles/raster_tile_priority_queue_all.cc b/cc/tiles/raster_tile_priority_queue_all.cc
index c09da4a..0b9a1af 100644
--- a/cc/tiles/raster_tile_priority_queue_all.cc
+++ b/cc/tiles/raster_tile_priority_queue_all.cc

@@ -70,7 +70,7 @@
     PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
     bool prioritize_low_res = tree_priority == SMOOTHNESS_TAKES_PRIORITY;
     std::unique_ptr<TilingSetRasterQueueAll> tiling_set_queue =
-        base::MakeUnique<TilingSetRasterQueueAll>(
+        std::make_unique<TilingSetRasterQueueAll>(
             tiling_set, prioritize_low_res,
             layer->contributes_to_drawn_render_surface());
     // Queues will only contain non empty tiling sets.

diff --git a/cc/tiles/software_image_decode_cache.cc b/cc/tiles/software_image_decode_cache.cc
index 896ef7b1..59d682b3 100644
--- a/cc/tiles/software_image_decode_cache.cc
+++ b/cc/tiles/software_image_decode_cache.cc

@@ -605,7 +605,7 @@
     }
   }
 
-  return base::MakeUnique<DecodedImage>(decoded_info, std::move(decoded_pixels),
+  return std::make_unique<DecodedImage>(decoded_info, std::move(decoded_pixels),
                                         SkSize::Make(0, 0),
                                         next_tracing_id_.GetNext());
 }
@@ -751,7 +751,7 @@
     DCHECK(result) << key.ToString();
   }
 
-  return base::MakeUnique<DecodedImage>(
+  return std::make_unique<DecodedImage>(
       scaled_info.makeColorSpace(decoded_draw_image.image()->refColorSpace()),
       std::move(scaled_pixels),
       SkSize::Make(-key.src_rect().x(), -key.src_rect().y()),

diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 83bff78e..d93617d 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc

@@ -1584,7 +1584,7 @@
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 TileManager::ActivationStateAsValue() {
-  auto state = base::MakeUnique<base::trace_event::TracedValue>();
+  auto state = std::make_unique<base::trace_event::TracedValue>();
   ActivationStateAsValueInto(state.get());
   return std::move(state);
 }

diff --git a/cc/tiles/tile_manager_perftest.cc b/cc/tiles/tile_manager_perftest.cc
index 6a1d067..952e0a90 100644
--- a/cc/tiles/tile_manager_perftest.cc
+++ b/cc/tiles/tile_manager_perftest.cc

@@ -50,7 +50,7 @@
     host_impl()->SetVisible(true);
     host_impl()->InitializeRenderer(layer_tree_frame_sink());
     tile_manager()->SetTileTaskManagerForTesting(
-        base::MakeUnique<FakeTileTaskManagerImpl>());
+        std::make_unique<FakeTileTaskManagerImpl>());
   }
 
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,

diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index c5847b8..1ddc0306 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc

@@ -1544,7 +1544,7 @@
       const LayerTreeSettings& settings,
       TaskRunnerProvider* task_runner_provider,
       TaskGraphRunner* task_graph_runner) override {
-    return base::MakeUnique<testing::NiceMock<MockLayerTreeHostImpl>>(
+    return std::make_unique<testing::NiceMock<MockLayerTreeHostImpl>>(
         settings, task_runner_provider, task_graph_runner);
   }
 
@@ -1751,7 +1751,7 @@
 class ActivationTasksDoNotBlockReadyToDrawTest : public TileManagerTest {
  protected:
   std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner() override {
-    return base::MakeUnique<SynchronousTaskGraphRunner>();
+    return std::make_unique<SynchronousTaskGraphRunner>();
   }
 
   std::unique_ptr<LayerTreeFrameSink> CreateLayerTreeFrameSink() override {
@@ -1828,7 +1828,7 @@
   // scheduled work is immediately cancelled.
 
   host_impl()->tile_manager()->SetTileTaskManagerForTesting(
-      base::MakeUnique<FakeTileTaskManagerImpl>());
+      std::make_unique<FakeTileTaskManagerImpl>());
 
   // Pick arbitrary IDs - they don't really matter as long as they're constant.
   const int kLayerId = 7;
@@ -1915,7 +1915,7 @@
   // Create a VerifyResourceContentIdTileTaskManager to ensure that the
   // raster task we see is created with |kExpectedId|.
   host_impl->tile_manager()->SetTileTaskManagerForTesting(
-      base::MakeUnique<FakeTileTaskManagerImpl>());
+      std::make_unique<FakeTileTaskManagerImpl>());
 
   VerifyResourceContentIdRasterBufferProvider raster_buffer_provider(
       kExpectedId);
@@ -1992,7 +1992,7 @@
       const Resource* resource,
       uint64_t resource_content_id,
       uint64_t previous_content_id) override {
-    return base::MakeUnique<FakeRasterBuffer>();
+    return std::make_unique<FakeRasterBuffer>();
   }
 
  private:
@@ -2337,12 +2337,12 @@
       TaskRunnerProvider* task_runner_provider,
       TaskGraphRunner* task_graph_runner) override {
     task_runner_ = make_scoped_refptr(new SynchronousSimpleTaskRunner);
-    return base::MakeUnique<FakeLayerTreeHostImpl>(
+    return std::make_unique<FakeLayerTreeHostImpl>(
         settings, task_runner_provider, task_graph_runner, task_runner_);
   }
 
   std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner() override {
-    return base::MakeUnique<SynchronousTaskGraphRunner>();
+    return std::make_unique<SynchronousTaskGraphRunner>();
   }
 
   void FlushDecodeTasks() {

diff --git a/cc/trees/clip_node.cc b/cc/trees/clip_node.cc
index 76272e39..aed3746 100644
--- a/cc/trees/clip_node.cc
+++ b/cc/trees/clip_node.cc

@@ -26,7 +26,7 @@
       transform_id(other.transform_id) {
   if (other.clip_expander) {
     DCHECK_EQ(clip_type, ClipType::EXPANDS_CLIP);
-    clip_expander = base::MakeUnique<ClipExpander>(*other.clip_expander);
+    clip_expander = std::make_unique<ClipExpander>(*other.clip_expander);
   }
   cached_clip_rects = other.cached_clip_rects;
   cached_accumulated_rect_in_screen_space =
@@ -42,7 +42,7 @@
 
   if (other.clip_expander) {
     DCHECK_EQ(clip_type, ClipType::EXPANDS_CLIP);
-    clip_expander = base::MakeUnique<ClipExpander>(*other.clip_expander);
+    clip_expander = std::make_unique<ClipExpander>(*other.clip_expander);
   } else {
     clip_expander.reset();
   }

diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 4a29d03..693ab2d1 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc

@@ -97,7 +97,7 @@
     : micro_benchmark_controller_(this),
       image_worker_task_runner_(params->image_worker_task_runner),
       compositor_mode_(mode),
-      ui_resource_manager_(base::MakeUnique<UIResourceManager>()),
+      ui_resource_manager_(std::make_unique<UIResourceManager>()),
       client_(params->client),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       settings_(*params->settings),
@@ -122,7 +122,7 @@
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
   std::unique_ptr<ProxyMain> proxy_main =
-      base::MakeUnique<ProxyMain>(this, task_runner_provider_.get());
+      std::make_unique<ProxyMain>(this, task_runner_provider_.get());
   InitializeProxy(std::move(proxy_main));
 }
 

diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index e0e9c06..1ab182a 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc

@@ -2777,7 +2777,7 @@
   clip->SetMasksToBounds(true);
 
   root->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   root->test_properties()->clip_children->insert(filter_child_1);
   filter_child_1->test_properties()->clip_parent = root;
 
@@ -3340,7 +3340,7 @@
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->SetMasksToBounds(true);
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   render_surface1->SetBounds(gfx::Size(20, 20));
@@ -3375,7 +3375,7 @@
   clip_parent->SetPosition(gfx::PointF(2.f, 2.f));
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   clip_layer->SetBounds(gfx::Size(50, 50));
@@ -3445,7 +3445,7 @@
 
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   unclipped_desc_surface->SetBounds(gfx::Size(20, 20));
@@ -3486,7 +3486,7 @@
 
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
@@ -5388,7 +5388,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   root->SetBounds(gfx::Size(50, 50));
@@ -5435,7 +5435,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   clip_parent->SetMasksToBounds(true);
@@ -5710,7 +5710,7 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   root->SetBounds(gfx::Size(50, 50));
@@ -5740,7 +5740,7 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   root->SetBounds(gfx::Size(50, 50));
@@ -5842,7 +5842,7 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -5885,12 +5885,12 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
   scroll_grandparent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_grandparent->test_properties()->scroll_children->insert(
       scroll_parent_border);
 
@@ -5958,12 +5958,12 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
   scroll_grandparent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_grandparent->test_properties()->scroll_children->insert(
       scroll_parent_border);
 
@@ -8594,7 +8594,7 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9175,7 +9175,7 @@
 
   render_surface->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(render_surface);
 
   ExecuteCalculateDrawProperties(root);
@@ -9208,7 +9208,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9240,7 +9240,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9268,7 +9268,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9316,7 +9316,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9363,7 +9363,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9400,7 +9400,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9459,7 +9459,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   float device_scale_factor = 1.f;
@@ -9491,7 +9491,7 @@
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9568,7 +9568,7 @@
 
   clip_child->test_properties()->clip_parent = root;
   root->test_properties()->clip_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   root->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
@@ -9669,7 +9669,7 @@
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
-      base::MakeUnique<std::set<LayerImpl*>>();
+      std::make_unique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   scroll_parent->SetDrawsContent(true);

diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 27ecb4b..931b123 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc

@@ -255,7 +255,7 @@
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
-  active_tree_ = base::MakeUnique<LayerTreeImpl>(
+  active_tree_ = std::make_unique<LayerTreeImpl>(
       this, new SyncedProperty<ScaleGroup>, new SyncedBrowserControls,
       new SyncedElasticOverscroll);
   active_tree_->property_trees()->is_active = true;
@@ -398,7 +398,7 @@
   } else if (!CommitToActiveTree()) {
     DCHECK(!pending_tree_raster_duration_timer_);
     pending_tree_raster_duration_timer_ =
-        base::MakeUnique<PendingTreeRasterDurationHistogramTimer>();
+        std::make_unique<PendingTreeRasterDurationHistogramTimer>();
   }
 }
 
@@ -1255,7 +1255,7 @@
   if (active_tree_)
     active_tree_->DetachLayers();
   active_tree_ =
-      base::MakeUnique<LayerTreeImpl>(this, active_tree()->page_scale_factor(),
+      std::make_unique<LayerTreeImpl>(this, active_tree()->page_scale_factor(),
                                       active_tree()->top_controls_shown_ratio(),
                                       active_tree()->elastic_overscroll());
   active_tree_->property_trees()->is_active = true;
@@ -2105,7 +2105,7 @@
   if (recycle_tree_) {
     recycle_tree_.swap(pending_tree_);
   } else {
-    pending_tree_ = base::MakeUnique<LayerTreeImpl>(
+    pending_tree_ = std::make_unique<LayerTreeImpl>(
         this, active_tree()->page_scale_factor(),
         active_tree()->top_controls_shown_ratio(),
         active_tree()->elastic_overscroll());
@@ -2319,14 +2319,14 @@
                                         &resource_pool_);
 
   if (use_gpu_rasterization_) {
-    image_decode_cache_ = base::MakeUnique<GpuImageDecodeCache>(
+    image_decode_cache_ = std::make_unique<GpuImageDecodeCache>(
         layer_tree_frame_sink_->worker_context_provider(),
         viz::ResourceFormatToClosestSkColorType(
             settings_.preferred_tile_format),
         settings_.decoded_image_working_set_budget_bytes,
         settings_.decoded_image_cache_budget_bytes);
   } else {
-    image_decode_cache_ = base::MakeUnique<SoftwareImageDecodeCache>(
+    image_decode_cache_ = std::make_unique<SoftwareImageDecodeCache>(
         viz::ResourceFormatToClosestSkColorType(
             settings_.preferred_tile_format),
         settings_.decoded_image_working_set_budget_bytes);
@@ -2389,7 +2389,7 @@
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
-    *raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
+    *raster_buffer_provider = std::make_unique<GpuRasterBufferProvider>(
         compositor_context_provider, worker_context_provider,
         resource_provider_.get(), settings_.use_distance_field_text,
         msaa_sample_count, settings_.preferred_tile_format,
@@ -2428,7 +2428,7 @@
       compositor_context_provider->ContextCapabilities()
           .max_copy_texture_chromium_size;
 
-  *raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
+  *raster_buffer_provider = std::make_unique<OneCopyRasterBufferProvider>(
       GetTaskRunner(), compositor_context_provider, worker_context_provider,
       resource_provider_.get(), max_copy_texture_chromium_size,
       settings_.use_partial_raster, settings_.max_staging_buffer_usage_in_bytes,
@@ -2559,7 +2559,7 @@
 
   layer_tree_frame_sink_ = layer_tree_frame_sink;
   has_valid_layer_tree_frame_sink_ = true;
-  resource_provider_ = base::MakeUnique<LayerTreeResourceProvider>(
+  resource_provider_ = std::make_unique<LayerTreeResourceProvider>(
       layer_tree_frame_sink_->context_provider(),
       layer_tree_frame_sink_->shared_bitmap_manager(),
       layer_tree_frame_sink_->gpu_memory_buffer_manager(),

diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 8a8f922..9346612 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc

@@ -646,7 +646,7 @@
 
   void InitializeImageWorker(const LayerTreeSettings& settings) {
     if (settings.enable_checker_imaging) {
-      image_worker_ = base::MakeUnique<base::Thread>("ImageWorker");
+      image_worker_ = std::make_unique<base::Thread>("ImageWorker");
       ASSERT_TRUE(image_worker_->Start());
     } else {
       image_worker_.reset();
@@ -9192,7 +9192,7 @@
   constexpr bool synchronous_composite = true;
   constexpr bool disable_display_vsync = false;
   constexpr double refresh_rate = 60.0;
-  auto layer_tree_frame_sink = base::MakeUnique<viz::TestLayerTreeFrameSink>(
+  auto layer_tree_frame_sink = std::make_unique<viz::TestLayerTreeFrameSink>(
       context_provider, TestContextProvider::CreateWorker(), nullptr, nullptr,
       viz::RendererSettings(), base::ThreadTaskRunnerHandle::Get().get(),
       synchronous_composite, disable_display_vsync, refresh_rate);

diff --git a/cc/trees/layer_tree_host_perftest.cc b/cc/trees/layer_tree_host_perftest.cc
index 7afaa6c..84868dbb 100644
--- a/cc/trees/layer_tree_host_perftest.cc
+++ b/cc/trees/layer_tree_host_perftest.cc

@@ -55,7 +55,7 @@
     bool synchronous_composite =
         !HasImplThread() &&
         !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
-    return base::MakeUnique<viz::TestLayerTreeFrameSink>(
+    return std::make_unique<viz::TestLayerTreeFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
         ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,

diff --git a/cc/trees/layer_tree_host_pixeltest_scrollbars.cc b/cc/trees/layer_tree_host_pixeltest_scrollbars.cc
index 93d29ad..8db7b52 100644
--- a/cc/trees/layer_tree_host_pixeltest_scrollbars.cc
+++ b/cc/trees/layer_tree_host_pixeltest_scrollbars.cc

@@ -86,7 +86,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedScrollbar>();
+  auto scrollbar = std::make_unique<PaintedScrollbar>();
   scoped_refptr<PaintedScrollbarLayer> layer =
       PaintedScrollbarLayer::Create(std::move(scrollbar));
   layer->SetIsDrawable(true);
@@ -105,7 +105,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(100, 100), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedScrollbar>();
+  auto scrollbar = std::make_unique<PaintedScrollbar>();
   scoped_refptr<PaintedScrollbarLayer> layer =
       PaintedScrollbarLayer::Create(std::move(scrollbar));
   layer->SetIsDrawable(true);
@@ -120,7 +120,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedScrollbar>();
+  auto scrollbar = std::make_unique<PaintedScrollbar>();
   scoped_refptr<PaintedScrollbarLayer> layer =
       PaintedScrollbarLayer::Create(std::move(scrollbar));
   layer->SetIsDrawable(true);
@@ -141,7 +141,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(400, 400), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedScrollbar>();
+  auto scrollbar = std::make_unique<PaintedScrollbar>();
   scrollbar->set_paint_scale(1);
   scoped_refptr<PaintedScrollbarLayer> layer =
       PaintedScrollbarLayer::Create(std::move(scrollbar));
@@ -237,7 +237,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(400, 400), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedOverlayScrollbar>();
+  auto scrollbar = std::make_unique<PaintedOverlayScrollbar>();
   scoped_refptr<PaintedOverlayScrollbarLayer> layer =
       PaintedOverlayScrollbarLayer::Create(std::move(scrollbar));
 
@@ -261,7 +261,7 @@
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(400, 400), SK_ColorWHITE);
 
-  auto scrollbar = base::MakeUnique<PaintedOverlayScrollbar>();
+  auto scrollbar = std::make_unique<PaintedOverlayScrollbar>();
   scoped_refptr<PaintedOverlayScrollbarLayer> layer =
       PaintedOverlayScrollbarLayer::Create(std::move(scrollbar));
 

diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index b85ba9a..de30b08 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc

@@ -447,13 +447,13 @@
       scoped_refptr<viz::ContextProvider> compositor_context_provider,
       scoped_refptr<viz::ContextProvider> worker_context_provider) override {
     // Create the main viz::ContextProvider with a MockContextSupport.
-    auto main_support = base::MakeUnique<MockContextSupport>();
+    auto main_support = std::make_unique<MockContextSupport>();
     mock_main_context_support_ = main_support.get();
     auto test_main_context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(main_support));
 
     // Create the main viz::ContextProvider with a MockContextSupport.
-    auto worker_support = base::MakeUnique<MockContextSupport>();
+    auto worker_support = std::make_unique<MockContextSupport>();
     mock_worker_context_support_ = worker_support.get();
     auto test_worker_context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(worker_support));
@@ -3445,7 +3445,7 @@
         &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
             CallOnDraw,
         base::Unretained(this));
-    auto frame_sink = base::MakeUnique<OnDrawLayerTreeFrameSink>(
+    auto frame_sink = std::make_unique<OnDrawLayerTreeFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
         ImplThreadTaskRunner(), false /* synchronous_composite */, refresh_rate,
@@ -4949,12 +4949,12 @@
     int frame = host_impl->active_tree()->source_frame_number();
     if (frame == -1) {
       host_impl->active_tree()->QueuePinnedSwapPromise(
-          base::MakeUnique<TestSwapPromise>(
+          std::make_unique<TestSwapPromise>(
               &pinned_active_swap_promise_result_));
       host_impl->pending_tree()->QueueSwapPromise(
-          base::MakeUnique<TestSwapPromise>(&pending_swap_promise_result_));
+          std::make_unique<TestSwapPromise>(&pending_swap_promise_result_));
       host_impl->active_tree()->QueueSwapPromise(
-          base::MakeUnique<TestSwapPromise>(&active_swap_promise_result_));
+          std::make_unique<TestSwapPromise>(&active_swap_promise_result_));
     }
   }
 
@@ -5107,7 +5107,7 @@
       case 1:
         layer_->SetBounds(gfx::Size(10, 11));
         layer_tree_host()->GetSwapPromiseManager()->QueueSwapPromise(
-            base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
+            std::make_unique<TestSwapPromise>(&swap_promise_result_));
         break;
       case 2:
         break;
@@ -5222,7 +5222,7 @@
         // Make no changes so that we abort the next commit caused by queuing
         // the swap promise.
         layer_tree_host()->GetSwapPromiseManager()->QueueSwapPromise(
-            base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
+            std::make_unique<TestSwapPromise>(&swap_promise_result_));
         layer_tree_host()->SetNeedsUpdateLayers();
         break;
       case 2:
@@ -6106,7 +6106,7 @@
     bool synchronous_composite =
         !HasImplThread() &&
         !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
-    return base::MakeUnique<viz::TestLayerTreeFrameSink>(
+    return std::make_unique<viz::TestLayerTreeFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(), renderer_settings,
         ImplThreadTaskRunner(), synchronous_composite, disable_display_vsync,

diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
index eb8c2524a..656ba60 100644
--- a/cc/trees/layer_tree_impl_unittest.cc
+++ b/cc/trees/layer_tree_impl_unittest.cc

@@ -1066,7 +1066,7 @@
     // |child|'s clip.
     scroll_child->test_properties()->scroll_parent = child.get();
     child->test_properties()->scroll_children =
-        base::MakeUnique<std::set<LayerImpl*>>();
+        std::make_unique<std::set<LayerImpl*>>();
     child->test_properties()->scroll_children->insert(scroll_child.get());
 
     grand_child->SetBounds(gfx::Size(200, 200));
@@ -2311,7 +2311,7 @@
       persistent_promises_to_pass;
   for (size_t i = 0; i < promises_count; ++i) {
     persistent_promises_to_pass.push_back(
-        base::MakeUnique<PersistentSwapPromise>());
+        std::make_unique<PersistentSwapPromise>());
   }
 
   for (auto& promise : persistent_promises_to_pass) {
@@ -2341,7 +2341,7 @@
       not_persistent_promises_to_pass;
   for (size_t i = 0; i < promises_count; ++i) {
     not_persistent_promises_to_pass.push_back(
-        base::MakeUnique<NotPersistentSwapPromise>());
+        std::make_unique<NotPersistentSwapPromise>());
   }
 
   for (auto& promise : not_persistent_promises_to_pass) {

diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 8bf2949..c7c9ff6e 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc

@@ -223,7 +223,7 @@
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
-    layer_iterator_ = base::MakeUnique<EffectTreeLayerListIterator>(
+    layer_iterator_ = std::make_unique<EffectTreeLayerListIterator>(
         host_->host_impl()->active_tree());
   }
 

diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index e3096fb7..d3e139f 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc

@@ -1001,7 +1001,7 @@
       continue;
 
     if (needs_render_surface) {
-      render_surfaces_[id] = base::MakeUnique<RenderSurfaceImpl>(
+      render_surfaces_[id] = std::make_unique<RenderSurfaceImpl>(
           layer_tree_impl, effect_node->stable_id);
       render_surfaces_[id]->set_effect_tree_index(id);
     } else {
@@ -1077,7 +1077,7 @@
 
     if ((*surfaces_list_it)->id() > id_list_it->first) {
       int new_node_id = id_list_it->second;
-      render_surfaces_[new_node_id] = base::MakeUnique<RenderSurfaceImpl>(
+      render_surfaces_[new_node_id] = std::make_unique<RenderSurfaceImpl>(
           layer_tree_impl, id_list_it->first);
       render_surfaces_[new_node_id]->set_effect_tree_index(new_node_id);
       id_list_it++;
@@ -1094,7 +1094,7 @@
   while (id_list_it != stable_id_node_id_list.end()) {
     int new_node_id = id_list_it->second;
     render_surfaces_[new_node_id] =
-        base::MakeUnique<RenderSurfaceImpl>(layer_tree_impl, id_list_it->first);
+        std::make_unique<RenderSurfaceImpl>(layer_tree_impl, id_list_it->first);
     render_surfaces_[new_node_id]->set_effect_tree_index(new_node_id);
     id_list_it++;
   }

diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index e094495..390120ac 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc

@@ -288,7 +288,7 @@
       DCHECK(Filters(layer).HasFilterThatMovesPixels());
       node.clip_type = ClipNode::ClipType::EXPANDS_CLIP;
       node.clip_expander =
-          base::MakeUnique<ClipExpander>(layer->effect_tree_index());
+          std::make_unique<ClipExpander>(layer->effect_tree_index());
     }
     data_for_children->clip_tree_parent =
         data_for_children->property_trees->clip_tree.Insert(node, parent_id);

diff --git a/cc/trees/proxy_impl.cc b/cc/trees/proxy_impl.cc
index 14b6c88..089825b 100644
--- a/cc/trees/proxy_impl.cc
+++ b/cc/trees/proxy_impl.cc

@@ -241,7 +241,7 @@
   DCHECK(IsImplThread());
   DCHECK(scheduler_);
 
-  auto state = base::MakeUnique<base::trace_event::TracedValue>();
+  auto state = std::make_unique<base::trace_event::TracedValue>();
 
   state->SetBoolean("commit_completion_waits_for_activation",
                     commit_completion_waits_for_activation_);

diff --git a/cc/trees/proxy_main.cc b/cc/trees/proxy_main.cc
index 9ca0ce8..875e8b3c 100644
--- a/cc/trees/proxy_main.cc
+++ b/cc/trees/proxy_main.cc

@@ -51,7 +51,7 @@
 void ProxyMain::InitializeOnImplThread(CompletionEvent* completion_event) {
   DCHECK(task_runner_provider_->IsImplThread());
   DCHECK(!proxy_impl_);
-  proxy_impl_ = base::MakeUnique<ProxyImpl>(
+  proxy_impl_ = std::make_unique<ProxyImpl>(
       weak_factory_.GetWeakPtr(), layer_tree_host_, task_runner_provider_);
   completion_event->Signal();
 }

diff --git a/cc/trees/swap_promise_manager_unittest.cc b/cc/trees/swap_promise_manager_unittest.cc
index 5ebd53a..9975899 100644
--- a/cc/trees/swap_promise_manager_unittest.cc
+++ b/cc/trees/swap_promise_manager_unittest.cc

@@ -53,7 +53,7 @@
 TEST(SwapPromiseManagerTest, SwapPromises) {
   SwapPromiseManager manager;
   std::unique_ptr<StrictMock<MockSwapPromise>> swap_promise =
-      base::MakeUnique<StrictMock<MockSwapPromise>>();
+      std::make_unique<StrictMock<MockSwapPromise>>();
   MockSwapPromise* mock_promise = swap_promise.get();
 
   manager.QueueSwapPromise(std::move(swap_promise));

diff --git a/content/test/gpu/generate_buildbot_json.py b/content/test/gpu/generate_buildbot_json.py
index 1f08f75..c4c19584 100755
--- a/content/test/gpu/generate_buildbot_json.py
+++ b/content/test/gpu/generate_buildbot_json.py

@@ -83,22 +83,9 @@
   def DEFAULT_AND_OPTIONAL(x):
     return Predicates.DEFAULT(x) or Types.OPTIONAL in x
 
-  # TODO(kbr): we're only temporarily running the dEQP tests on both
-  # the new dEQP bots as well as the regular bots. As soon as separate
-  # tryservers for the dEQP tests have been set up, these type testers
-  # will be removed, and replaced with ones that are specific to the
-  # dEQP.
   @staticmethod
-  def FYI_AND_OPTIONAL_AND_DEQP(x):
-    return Types.DEQP in x or Predicates.FYI_AND_OPTIONAL(x)
-
-  @staticmethod
-  def FYI_AND_OPTIONAL_AND_WIN_ANGLE_AMD_AND_DEQP(x):
-    return Types.DEQP in x or Predicates.FYI_AND_OPTIONAL_AND_WIN_ANGLE_AMD(x)
-
-  @staticmethod
-  def FYI_ONLY_AND_DEQP(x):
-    return Types.DEQP in x or Predicates.FYI_ONLY(x)
+  def DEQP(x):
+    return Types.DEQP in x
 
 WATERFALL = {
   'name': 'chromium.gpu',
@@ -977,8 +964,7 @@
   'angle_deqp_egl_tests': {
     'tester_configs': [
       {
-        # Run this on the FYI waterfall and optional tryservers.
-        'predicate': Predicates.FYI_AND_OPTIONAL_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run only on the Win7 Release NVIDIA 32- and 64-bit bots
         # (and trybots) for the time being, at least until more capacity is
         # added.
@@ -1007,9 +993,7 @@
   'angle_deqp_gles2_d3d11_tests': {
     'tester_configs': [
       {
-        # Run this on the FYI waterfall, optional tryservers, and Win
-        # ANGLE AMD tryserver.
-        'predicate': Predicates.FYI_AND_OPTIONAL_AND_WIN_ANGLE_AMD_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run only on the Win7 NVIDIA/AMD R7 240 32- and 64-bit bots (and
         # trybots) for the time being, at least until more capacity is
         # added.
@@ -1048,8 +1032,7 @@
   'angle_deqp_gles2_gl_tests': {
     'tester_configs': [
       {
-        # Run this on the FYI waterfall and optional tryservers.
-        'predicate': Predicates.FYI_AND_OPTIONAL_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run only on the Linux Release NVIDIA 32- and 64-bit bots (and
         # trybots) for the time being, at least until more capacity is added.
         'build_configs': ['Release', 'Release_x64'],
@@ -1082,8 +1065,7 @@
   'angle_deqp_gles2_gles_tests': {
     'tester_configs': [
       {
-        # Run this on the FYI waterfall and optional tryservers.
-        'predicate': Predicates.FYI_AND_OPTIONAL_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run on Nexus 5X swarmed bots.
         'build_configs': ['android-chromium'],
         'swarming_dimension_sets': [
@@ -1121,8 +1103,7 @@
   'angle_deqp_gles3_gles_tests': {
     'tester_configs': [
       {
-        # Run this on the FYI waterfall and optional tryservers.
-        'predicate': Predicates.FYI_AND_OPTIONAL_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run on Nexus 5X swarmed bots.
         'build_configs': ['android-chromium'],
         'swarming_dimension_sets': [
@@ -1164,7 +1145,7 @@
     'tester_configs': [
       {
         # TODO(jmadill): Run this on ANGLE roll tryservers.
-        'predicate': Predicates.FYI_ONLY_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run only on the NVIDIA and AMD Win7 bots (and trybots) for the time
         # being, at least until more capacity is added.
         'build_configs': ['Release'],
@@ -1206,7 +1187,7 @@
     'tester_configs': [
       {
         # TODO(jmadill): Run this on ANGLE roll tryservers.
-        'predicate': Predicates.FYI_ONLY_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run only on the Linux Release NVIDIA 32-bit bots (and trybots) for
         # the time being, at least until more capacity is added.
         'build_configs': ['Release'],
@@ -1239,7 +1220,7 @@
   'angle_deqp_gles31_d3d11_tests': {
     'tester_configs': [
       {
-        'predicate': Predicates.FYI_ONLY_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run on the Win Release NVIDIA bots.
         'build_configs': ['Release'],
         'swarming_dimension_sets': [
@@ -1272,7 +1253,7 @@
   'angle_deqp_gles31_gl_tests': {
     'tester_configs': [
       {
-        'predicate': Predicates.FYI_ONLY_AND_DEQP,
+        'predicate': Predicates.DEQP,
         # Run on the Win Release NVIDIA bots.
         'build_configs': ['Release'],
         'swarming_dimension_sets': [

diff --git a/testing/buildbot/chromium.gpu.fyi.json b/testing/buildbot/chromium.gpu.fyi.json
index a5232040..a2abefd 100644
--- a/testing/buildbot/chromium.gpu.fyi.json
+++ b/testing/buildbot/chromium.gpu.fyi.json

@@ -758,81 +758,6 @@
   "Android Release (Nexus 5X)": {
     "gtest_tests": [
       {
-        "args": [
-          "--enable-xml-result-parsing",
-          "--shard-timeout=300"
-        ],
-        "name": "angle_deqp_gles2_gles_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "cipd_packages": [
-            {
-              "cipd_package": "infra/tools/luci/logdog/butler/${platform}",
-              "location": "bin",
-              "revision": "git_revision:ff387eadf445b24c935f1cf7d6ddd279f8a6b04c"
-            }
-          ],
-          "dimension_sets": [
-            {
-              "android_devices": "1",
-              "device_os": "M",
-              "device_type": "bullhead",
-              "os": "Android"
-            }
-          ],
-          "output_links": [
-            {
-              "link": [
-                "https://luci-logdog.appspot.com/v/?s",
-                "=android%2Fswarming%2Flogcats%2F",
-                "${TASK_ID}%2F%2B%2Funified_logcats"
-              ],
-              "name": "shard #${SHARD_INDEX} logcats"
-            }
-          ]
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--enable-xml-result-parsing",
-          "--shard-timeout=300"
-        ],
-        "name": "angle_deqp_gles3_gles_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "cipd_packages": [
-            {
-              "cipd_package": "infra/tools/luci/logdog/butler/${platform}",
-              "location": "bin",
-              "revision": "git_revision:ff387eadf445b24c935f1cf7d6ddd279f8a6b04c"
-            }
-          ],
-          "dimension_sets": [
-            {
-              "android_devices": "1",
-              "device_os": "M",
-              "device_type": "bullhead",
-              "os": "Android"
-            }
-          ],
-          "output_links": [
-            {
-              "link": [
-                "https://luci-logdog.appspot.com/v/?s",
-                "=android%2Fswarming%2Flogcats%2F",
-                "${TASK_ID}%2F%2B%2Funified_logcats"
-              ],
-              "name": "shard #${SHARD_INDEX} logcats"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles3_tests",
-        "use_xvfb": false
-      },
-      {
         "swarming": {
           "can_use_on_swarming_builders": true,
           "cipd_packages": [
@@ -2911,63 +2836,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles2_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles31_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles31_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles3_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 12
-        },
-        "test": "angle_deqp_gles3_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -4447,63 +4315,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles2_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles31_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles31_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles3_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 12
-        },
-        "test": "angle_deqp_gles3_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -10287,25 +10098,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles2_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Ubuntu"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -10875,41 +10667,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400"
-        ],
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ]
-        },
-        "test": "angle_deqp_egl_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -13608,25 +13365,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "1002:6613",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -14855,25 +14593,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": false,
-          "dimension_sets": [
-            {
-              "gpu": "1002:6613",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -15472,25 +15191,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "1002:6613",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -16095,98 +15795,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400"
-        ],
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ]
-        },
-        "test": "angle_deqp_egl_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles31_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles31_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-gl"
-        ],
-        "name": "angle_deqp_gles31_gl_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles31_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles3_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 12
-        },
-        "test": "angle_deqp_gles3_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],
@@ -17584,41 +17192,6 @@
     "gtest_tests": [
       {
         "args": [
-          "--test-launcher-batch-limit=400"
-        ],
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ]
-        },
-        "test": "angle_deqp_egl_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
-          "--test-launcher-batch-limit=400",
-          "--deqp-egl-display-type=angle-d3d11"
-        ],
-        "name": "angle_deqp_gles2_d3d11_tests",
-        "swarming": {
-          "can_use_on_swarming_builders": true,
-          "dimension_sets": [
-            {
-              "gpu": "10de:104a",
-              "os": "Windows-2008ServerR2-SP1"
-            }
-          ],
-          "shards": 4
-        },
-        "test": "angle_deqp_gles2_tests",
-        "use_xvfb": false
-      },
-      {
-        "args": [
           "--use-gpu-in-tests",
           "--test-launcher-retry-limit=0"
         ],

diff --git a/tools/mb/mb_config.pyl b/tools/mb/mb_config.pyl
index 33b1c42..1f6aef2 100644
--- a/tools/mb/mb_config.pyl
+++ b/tools/mb/mb_config.pyl

@@ -249,26 +249,26 @@
 
     'chromium.gpu.fyi': {
       # These all use the 'trybot' mixins to ensure that dcheck is on.
-      'Android dEQP Release (Nexus 5X)': 'gpu_tests_deqp_android_release_trybot_arm64',
+      'Android dEQP Release (Nexus 5X)': 'deqp_android_release_trybot_arm64',
       'Android Release (Nexus 5)': 'android_release_trybot',
-      'Android Release (Nexus 5X)': 'gpu_tests_deqp_android_release_trybot_arm64',
+      'Android Release (Nexus 5X)': 'gpu_tests_android_release_trybot_arm64',
       'Android Release (Nexus 6)': 'android_release_trybot',
       'Android Release (Nexus 6P)': 'android_release_trybot_arm64',
       'Android Release (Nexus 9)': 'android_release_trybot_arm64',
       'Android Release (NVIDIA Shield TV)': 'android_release_trybot_arm64',
       'GPU Linux Builder': 'gpu_fyi_tests_release_trybot',
       'GPU Linux Builder (dbg)': 'gpu_fyi_tests_debug_trybot',
-      'GPU Linux dEQP Builder': 'gpu_fyi_tests_release_trybot',
+      'GPU Linux dEQP Builder': 'deqp_release_trybot',
       'GPU Mac Builder': 'gpu_fyi_tests_release_trybot',
       'GPU Mac Builder (dbg)': 'gpu_fyi_tests_debug_trybot',
-      'GPU Mac dEQP Builder': 'gpu_fyi_tests_release_trybot',
-      'GPU Win Builder': 'gpu_tests_deqp_gles_release_trybot_x86',
-      'GPU Win Builder (dbg)': 'gpu_tests_deqp_gles_debug_trybot_x86',
-      'GPU Win dEQP Builder': 'gpu_tests_deqp_gles_release_trybot_x86',
+      'GPU Mac dEQP Builder': 'deqp_release_trybot',
+      'GPU Win Builder': 'gpu_fyi_tests_release_trybot_x86',
+      'GPU Win Builder (dbg)': 'gpu_fyi_tests_debug_trybot_x86',
+      'GPU Win dEQP Builder': 'deqp_release_no_clang_trybot_x86',
       'GPU Win Clang Builder (dbg)': 'gpu_fyi_tests_win_clang_debug_bot',
-      'GPU Win x64 Builder': 'gpu_tests_deqp_gles_release_trybot',
-      'GPU Win x64 Builder (dbg)': 'gpu_tests_deqp_gles_debug_trybot',
-      'GPU Win x64 dEQP Builder': 'gpu_tests_deqp_gles_release_trybot',
+      'GPU Win x64 Builder': 'gpu_fyi_tests_release_trybot',
+      'GPU Win x64 Builder (dbg)': 'gpu_fyi_tests_debug_trybot',
+      'GPU Win x64 dEQP Builder': 'deqp_release_no_clang_trybot',
       'Linux ChromiumOS Builder': 'gpu_fyi_tests_chromeos_cros_release_trybot',
       # This is, confusingly, apparently not actually building ChromiumOS.
       'Linux ChromiumOS Ozone Builder': 'gpu_fyi_tests_ozone_linux_system_gbm_libdrm_release_trybot',
@@ -397,7 +397,7 @@
 
     'client.v8.fyi': {
       'Android Builder': 'official_goma_minimal_symbols_android',
-      'Android Release (Nexus 5X)': 'gpu_tests_deqp_android_release_trybot_arm64',
+      'Android Release (Nexus 5X)': 'gpu_tests_android_release_trybot_arm64',
       'Linux ASAN Builder': 'asan_lsan_release_bot',
       'Linux Debug Builder': 'debug_bot',
       'Linux Release (NVIDIA)': 'gpu_tests_release_trybot',
@@ -510,7 +510,7 @@
 
       'android_n5x_swarming_dbg': 'android_debug_trybot_arm64',
       'android_n5x_swarming_rel': 'android_release_trybot_arm64',
-      'android_optional_gpu_tests_rel': 'gpu_tests_deqp_android_release_trybot_arm64',
+      'android_optional_gpu_tests_rel': 'gpu_tests_android_release_trybot_arm64',
       'android_unswarmed_n5_rel': 'android_release_trybot',
       'android_unswarmed_n5x_rel': 'android_release_trybot_arm64',
       'cast_shell_android': 'android_cast_debug_static_bot',
@@ -519,20 +519,20 @@
     },
 
     'tryserver.chromium.angle': {
-      'android_angle_rel_ng': 'gpu_tests_deqp_android_release_trybot_arm64',
-      'android_angle_deqp_rel_ng': 'gpu_tests_deqp_android_release_trybot_arm64',
+      'android_angle_rel_ng': 'gpu_tests_android_release_trybot_arm64',
+      'android_angle_deqp_rel_ng': 'deqp_android_release_trybot_arm64',
       'linux_angle_chromeos_rel_ng': 'gpu_fyi_tests_chromeos_cros_release_trybot',
       'linux_angle_dbg_ng': 'gpu_fyi_tests_debug_trybot',
-      'linux_angle_deqp_rel_ng': 'gpu_fyi_tests_release_trybot',
+      'linux_angle_deqp_rel_ng': 'deqp_release_trybot',
       'linux_angle_rel_ng': 'gpu_fyi_tests_release_trybot',
       'mac_angle_dbg_ng': 'gpu_fyi_tests_debug_trybot',
       'mac_angle_rel_ng': 'gpu_fyi_tests_release_trybot',
-      'win_angle_dbg_ng': 'gpu_tests_deqp_gles_debug_trybot_x86',
-      'win_angle_deqp_rel_ng': 'gpu_tests_deqp_gles_release_trybot_x86',
-      'win_angle_rel_ng': 'gpu_tests_deqp_gles_release_trybot_x86',
-      'win_angle_x64_dbg_ng': 'gpu_tests_deqp_gles_debug_trybot',
-      'win_angle_x64_deqp_rel_ng': 'gpu_tests_deqp_gles_release_trybot',
-      'win_angle_x64_rel_ng': 'gpu_tests_deqp_gles_release_trybot',
+      'win_angle_dbg_ng': 'gpu_fyi_tests_debug_trybot_x86',
+      'win_angle_deqp_rel_ng': 'deqp_release_no_clang_trybot_x86',
+      'win_angle_rel_ng': 'gpu_fyi_tests_release_trybot_x86',
+      'win_angle_x64_dbg_ng': 'gpu_fyi_tests_debug_trybot',
+      'win_angle_x64_deqp_rel_ng': 'deqp_release_no_clang_trybot',
+      'win_angle_x64_rel_ng': 'gpu_fyi_tests_release_trybot',
     },
 
     'tryserver.chromium.linux': {
@@ -682,7 +682,7 @@
       'win_mojo': 'release_trybot_x86',
       'win_nacl_sdk': 'release_bot_x86_minimal_symbols',
       'win_nacl_sdk_build': 'release_bot_x86_minimal_symbols',
-      'win_optional_gpu_tests_rel': 'gpu_tests_deqp_gles_release_trybot_x86',
+      'win_optional_gpu_tests_rel': 'gpu_fyi_tests_release_trybot_x86',
       'win_pgo': {
         '1': 'official_optimize_chrome_pgo_phase_1_x86',
         '2': 'official_optimize_chrome_pgo_phase_2_x86',
@@ -1242,6 +1242,28 @@
       'debug_trybot', 'x86',
     ],
 
+    'deqp_android_release_trybot_arm64': [
+      'angle_deqp_tests', 'android', 'release_trybot', 'arm64',
+    ],
+
+    'deqp_release_no_clang_trybot': [
+      # TODO(thakis): Remove no_clang once https://crbug.com/727437 is fixed.
+      # Still need conditional entries in .gclient so that clang and compiler
+      # options can be pinned based on the presence of a GN flag.
+      'angle_deqp_tests', 'release_trybot', 'no_clang',
+    ],
+
+    'deqp_release_no_clang_trybot_x86': [
+      # TODO(thakis): Remove no_clang once https://crbug.com/727437 is fixed.
+      # Still need conditional entries in .gclient so that clang and compiler
+      # options can be pinned based on the presence of a GN flag.
+      'angle_deqp_tests', 'release_trybot', 'x86', 'no_clang',
+    ],
+
+    'deqp_release_trybot': [
+      'angle_deqp_tests', 'release_trybot',
+    ],
+
     'gpu_fyi_tests_chromeos_cros_release_trybot': [
       'gpu_fyi_tests', 'chromeos', 'release_trybot',
     ],
@@ -1250,6 +1272,10 @@
       'gpu_fyi_tests', 'debug_trybot',
     ],
 
+    'gpu_fyi_tests_debug_trybot_x86': [
+      'gpu_fyi_tests', 'debug_trybot', 'x86',
+    ],
+
     'gpu_fyi_tests_ozone_linux_system_gbm_libdrm_release_trybot': [
       'gpu_fyi_tests', 'ozone_linux', 'system_gbm_libdrm', 'release_trybot',
     ],
@@ -1266,30 +1292,16 @@
       'gpu_fyi_tests', 'release_trybot', 'tsan', 'full_symbols', 'disable_nacl',
     ],
 
+    'gpu_fyi_tests_release_trybot_x86': [
+      'gpu_fyi_tests', 'release_trybot', 'x86',
+    ],
+
     'gpu_fyi_tests_win_clang_debug_bot': [
       'gpu_tests', 'internal_gles2_conform_tests', 'clang', 'debug_bot', 'minimal_symbols',
     ],
 
-    'gpu_tests_deqp_android_release_trybot_arm64': [
-      'gpu_tests', 'angle_deqp_tests', 'android', 'release_trybot', 'arm64',
-    ],
-
-    'gpu_tests_deqp_gles_debug_trybot': [
-      'gpu_fyi_tests', 'debug_trybot',
-    ],
-
-    'gpu_tests_deqp_gles_debug_trybot_x86': [
-      'gpu_fyi_tests', 'debug_trybot', 'x86',
-    ],
-
-    'gpu_tests_deqp_gles_release_trybot': [
-      # TODO(thakis): Remove no_clang once https://crbug.com/727437 is fixed.
-      'gpu_fyi_tests', 'release_trybot', 'no_clang',
-    ],
-
-    'gpu_tests_deqp_gles_release_trybot_x86': [
-      # TODO(thakis): Remove no_clang once https://crbug.com/727437 is fixed.
-      'gpu_fyi_tests', 'release_trybot', 'x86', 'no_clang',
+    'gpu_tests_android_release_trybot_arm64': [
+      'gpu_tests', 'android', 'release_trybot', 'arm64',
     ],
 
     'gpu_tests_debug_trybot': [
@@ -1780,7 +1792,7 @@
     },
 
     'gpu_fyi_tests': {
-      'mixins': ['gpu_tests', 'internal_gles2_conform_tests', 'angle_deqp_tests'],
+      'mixins': ['gpu_tests', 'internal_gles2_conform_tests'],
     },
 
     'gpu_tests': {