Switch make_scoped_refptr to MakeRefCounted.

This CL replaces instances of make_scoped_refptr() with MakeRefCounted()
for constructing scoped_refptr<>s where possible. MakeRefCounted() only
works if the class has a public constructor, so not all instances are
replaced.

Bug: 765333
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: Ic53d512940f7cc53a959e967a63da0ca94a95eae
Reviewed-on: https://chromium-review.googlesource.com/676646
Commit-Queue: kylechar <kylechar@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#504151}

android_webview/browser/aw_browser_context.cc

@@ -247,13 +247,13 @@ void AwBrowserContext::InitUserPrefService() {
   safe_browsing::RegisterProfilePrefs(pref_registry);
 
   PrefServiceFactory pref_service_factory;
-  pref_service_factory.set_user_prefs(make_scoped_refptr(
-      new InMemoryPrefStore()));
+  pref_service_factory.set_user_prefs(
+      base::MakeRefCounted<InMemoryPrefStore>());
   pref_service_factory.set_managed_prefs(
-      make_scoped_refptr(new policy::ConfigurationPolicyPrefStore(
+      base::MakeRefCounted<policy::ConfigurationPolicyPrefStore>(
           browser_policy_connector_->GetPolicyService(),
           browser_policy_connector_->GetHandlerList(),
-          policy::POLICY_LEVEL_MANDATORY)));
+          policy::POLICY_LEVEL_MANDATORY));
   pref_service_factory.set_read_error_callback(base::Bind(&HandleReadError));
   user_pref_service_ = pref_service_factory.Create(pref_registry);
   pref_change_registrar_.Init(user_pref_service_.get());

android_webview/browser/aw_field_trial_creator.cc

@@ -70,7 +70,7 @@ std::unique_ptr<PrefService> AwFieldTrialCreator::CreateLocalState() {
       base::MakeUnique<base::ListValue>());
 
   pref_service_factory_.set_user_prefs(
-      make_scoped_refptr(new InMemoryPrefStore()));
+      base::MakeRefCounted<InMemoryPrefStore>());
   return pref_service_factory_.Create(pref_registry.get());
 }
 

ash/display/display_manager_unittest.cc

@@ -1472,12 +1472,12 @@ TEST_F(DisplayManagerTest, DontRememberBestResolution) {
   display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
   display::ManagedDisplayInfo::ManagedDisplayModeList display_modes;
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(1000, 500), 58.0f, false, true)));
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(800, 300), 59.0f, false, false)));
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(400, 500), 60.0f, false, false)));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(1000, 500), 58.0f, false, true));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(800, 300), 59.0f, false, false));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(400, 500), 60.0f, false, false));
 
   native_display_info.SetManagedDisplayModes(display_modes);
 
@@ -1539,12 +1539,12 @@ TEST_F(DisplayManagerTest, ResolutionFallback) {
   display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
   display::ManagedDisplayInfo::ManagedDisplayModeList display_modes;
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(1000, 500), 58.0f, false, true)));
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(800, 300), 59.0f, false, false)));
-  display_modes.push_back(make_scoped_refptr(new display::ManagedDisplayMode(
-      gfx::Size(400, 500), 60.0f, false, false)));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(1000, 500), 58.0f, false, true));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(800, 300), 59.0f, false, false));
+  display_modes.push_back(base::MakeRefCounted<display::ManagedDisplayMode>(
+      gfx::Size(400, 500), 60.0f, false, false));
 
   display::ManagedDisplayInfo::ManagedDisplayModeList copy = display_modes;
   native_display_info.SetManagedDisplayModes(copy);

base/ios/scoped_critical_action.mm

@@ -14,7 +14,7 @@
 namespace ios {
 
 ScopedCriticalAction::ScopedCriticalAction()
-    : core_(base::MakeRefCounted<ScopedCriticalAction::Core>()) {
+    : core_(MakeRefCounted<ScopedCriticalAction::Core>()) {
   ScopedCriticalAction::Core::StartBackgroundTask(core_);
 }
 

base/observer_list_unittest.cc

@@ -532,7 +532,7 @@ TEST(ObserverListThreadSafeTest, NotificationOnValidSequence) {
   auto task_runner_1 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
   auto task_runner_2 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
 
-  auto observer_list = make_scoped_refptr(new ObserverListThreadSafe<Foo>());
+  auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
 
   SequenceVerificationObserver observer_1(task_runner_1);
   SequenceVerificationObserver observer_2(task_runner_2);
@@ -558,7 +558,7 @@ TEST(ObserverListThreadSafeTest, NotificationOnValidSequence) {
 // from a notification, it is itself notified.
 TEST(ObserverListThreadSafeTest, AddObserverFromNotificationNotifyAll) {
   test::ScopedTaskEnvironment scoped_task_environment;
-  auto observer_list = make_scoped_refptr(new ObserverListThreadSafe<Foo>());
+  auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
 
   Adder observer_added_from_notification(1);
 
@@ -605,7 +605,7 @@ class RemoveWhileNotificationIsRunningObserver : public Foo {
 // Verify that there is no crash when an observer is removed while it is being
 // notified.
 TEST(ObserverListThreadSafeTest, RemoveWhileNotificationIsRunning) {
-  auto observer_list = make_scoped_refptr(new ObserverListThreadSafe<Foo>());
+  auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
   RemoveWhileNotificationIsRunningObserver observer;
 
   WaitableEvent task_running(WaitableEvent::ResetPolicy::AUTOMATIC,

base/task_scheduler/delayed_task_manager_unittest.cc

@@ -61,7 +61,7 @@ class TaskSchedulerDelayedTaskManagerTest : public testing::Test {
 
   testing::StrictMock<MockTaskTarget> task_target_;
   const scoped_refptr<TestMockTimeTaskRunner> service_thread_task_runner_ =
-      make_scoped_refptr(new TestMockTimeTaskRunner);
+      MakeRefCounted<TestMockTimeTaskRunner>();
   DelayedTaskManager delayed_task_manager_;
   std::unique_ptr<Task> task_ = CreateTask(kLongDelay);
   Task* const task_raw_ = task_.get();

base/task_scheduler/scheduler_single_thread_task_runner_manager.cc

@@ -514,9 +514,9 @@ SchedulerSingleThreadTaskRunnerManager::CreateAndRegisterSchedulerWorker(
     ThreadPriority priority_hint) {
   lock_.AssertAcquired();
   int id = next_worker_id_++;
-  workers_.emplace_back(make_scoped_refptr(new SchedulerWorker(
+  workers_.emplace_back(MakeRefCounted<SchedulerWorker>(
       priority_hint, CreateSchedulerWorkerDelegate<DelegateType>(name, id),
-      task_tracker_)));
+      task_tracker_));
   return workers_.back().get();
 }
 

base/task_scheduler/scheduler_worker_stack_unittest.cc

@@ -40,17 +40,17 @@ class MockSchedulerWorkerDelegate : public SchedulerWorker::Delegate {
 class TaskSchedulerWorkerStackTest : public testing::Test {
  protected:
   void SetUp() override {
-    worker_a_ = make_scoped_refptr(new SchedulerWorker(
+    worker_a_ = MakeRefCounted<SchedulerWorker>(
         ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
-        &task_tracker_));
+        &task_tracker_);
     ASSERT_TRUE(worker_a_);
-    worker_b_ = make_scoped_refptr(new SchedulerWorker(
+    worker_b_ = MakeRefCounted<SchedulerWorker>(
         ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
-        &task_tracker_));
+        &task_tracker_);
     ASSERT_TRUE(worker_b_);
-    worker_c_ = make_scoped_refptr(new SchedulerWorker(
+    worker_c_ = MakeRefCounted<SchedulerWorker>(
         ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
-        &task_tracker_));
+        &task_tracker_);
     ASSERT_TRUE(worker_c_);
   }
 

base/task_scheduler/scheduler_worker_unittest.cc

@@ -77,9 +77,9 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
                     WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void SetUp() override {
-    worker_ = make_scoped_refptr(new SchedulerWorker(
+    worker_ = MakeRefCounted<SchedulerWorker>(
         ThreadPriority::NORMAL,
-        std::make_unique<TestSchedulerWorkerDelegate>(this), &task_tracker_));
+        std::make_unique<TestSchedulerWorkerDelegate>(this), &task_tracker_);
     ASSERT_TRUE(worker_);
     worker_->Start();
     worker_set_.Signal();
@@ -512,8 +512,8 @@ TEST(TaskSchedulerWorkerTest, WorkerCleanupFromGetWork) {
       delegate->controls();
   controls->set_can_cleanup(true);
   EXPECT_CALL(*delegate, OnMainEntry(_));
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker);
   worker->Start();
   worker->WakeUp();
   controls->WaitForWorkToRun();
@@ -533,8 +533,8 @@ TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWork) {
 
   controls->HaveWorkBlock();
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker);
   worker->Start();
   worker->WakeUp();
 
@@ -555,8 +555,8 @@ TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWait) {
   scoped_refptr<ControllableCleanupDelegate::Controls> controls =
       delegate->controls();
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker);
   worker->Start();
   worker->WakeUp();
 
@@ -578,8 +578,8 @@ TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringShutdown) {
 
   controls->HaveWorkBlock();
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker);
   worker->Start();
   worker->WakeUp();
 
@@ -603,8 +603,8 @@ TEST(TaskSchedulerWorkerTest, CleanupBeforeStart) {
       delegate->controls();
   controls->set_expect_get_work(false);
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker);
 
   worker->Cleanup();
   worker->Start();
@@ -652,8 +652,8 @@ TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringJoin) {
 
   controls->HaveWorkBlock();
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::NORMAL, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker);
   worker->Start();
   worker->WakeUp();
 
@@ -731,8 +731,8 @@ TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
           ? ThreadPriority::BACKGROUND
           : ThreadPriority::NORMAL);
 
-  auto worker = make_scoped_refptr(new SchedulerWorker(
-      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker));
+  auto worker = MakeRefCounted<SchedulerWorker>(
+      ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker);
   worker->Start();
 
   // Verify that the initial thread priority is BACKGROUND (or NORMAL if thread
@@ -791,9 +791,9 @@ TEST(TaskSchedulerWorkerTest, BackwardCompatibilityEnabled) {
 
   // Create a worker with backward compatibility ENABLED. Wake it up and wait
   // until GetWork() returns.
-  auto worker = make_scoped_refptr(new SchedulerWorker(
+  auto worker = MakeRefCounted<SchedulerWorker>(
       ThreadPriority::NORMAL, std::move(delegate), &task_tracker, nullptr,
-      SchedulerBackwardCompatibility::INIT_COM_STA));
+      SchedulerBackwardCompatibility::INIT_COM_STA);
   worker->Start();
   worker->WakeUp();
   delegate_raw->WaitUntilGetWorkReturned();
@@ -818,9 +818,9 @@ TEST(TaskSchedulerWorkerTest, BackwardCompatibilityDisabled) {
 
   // Create a worker with backward compatibility DISABLED. Wake it up and wait
   // until GetWork() returns.
-  auto worker = make_scoped_refptr(new SchedulerWorker(
+  auto worker = MakeRefCounted<SchedulerWorker>(
       ThreadPriority::NORMAL, std::move(delegate), &task_tracker, nullptr,
-      SchedulerBackwardCompatibility::DISABLED));
+      SchedulerBackwardCompatibility::DISABLED);
   worker->Start();
   worker->WakeUp();
   delegate_raw->WaitUntilGetWorkReturned();

base/threading/post_task_and_reply_impl_unittest.cc

@@ -73,13 +73,12 @@ TEST(PostTaskAndReplyImplTest, PostTaskAndReply) {
   testing::StrictMock<MockObject> mock_object;
   bool delete_flag = false;
 
-  EXPECT_TRUE(
-      PostTaskAndReplyTaskRunner(post_runner.get())
-          .PostTaskAndReply(
-              FROM_HERE,
-              BindOnce(&MockObject::Task, Unretained(&mock_object),
-                       make_scoped_refptr(new ObjectToDelete(&delete_flag))),
-              BindOnce(&MockObject::Reply, Unretained(&mock_object))));
+  EXPECT_TRUE(PostTaskAndReplyTaskRunner(post_runner.get())
+                  .PostTaskAndReply(
+                      FROM_HERE,
+                      BindOnce(&MockObject::Task, Unretained(&mock_object),
+                               MakeRefCounted<ObjectToDelete>(&delete_flag)),
+                      BindOnce(&MockObject::Reply, Unretained(&mock_object))));
 
   // Expect the task to be posted to |post_runner|.
   EXPECT_TRUE(post_runner->HasPendingTask());

base/threading/sequenced_worker_pool_unittest.cc

@@ -393,7 +393,7 @@ TEST_P(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
   EXPECT_TRUE(pool()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&ShouldNotRun,
-                     make_scoped_refptr(new DeletionHelper(deleted_flag))),
+                     MakeRefCounted<DeletionHelper>(deleted_flag)),
       TestTimeouts::action_timeout()));
 
   std::vector<int> completion_sequence = tracker()->WaitUntilTasksComplete(1);

base/threading/thread_checker_unittest.cc

@@ -63,7 +63,7 @@ void ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle(
     ThreadCheckerImpl* thread_checker,
     SequenceToken sequence_token) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+      MakeRefCounted<TestSimpleTaskRunner>());
   ScopedSetSequenceTokenForCurrentThread
       scoped_set_sequence_token_for_current_thread(sequence_token);
   ExpectNotCalledOnValidThread(thread_checker);
@@ -79,7 +79,7 @@ TEST(ThreadCheckerTest, AllowedSameThreadNoSequenceToken) {
 TEST(ThreadCheckerTest,
      AllowedSameThreadAndSequenceDifferentTasksWithThreadTaskRunnerHandle) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+      MakeRefCounted<TestSimpleTaskRunner>());
 
   std::unique_ptr<ThreadCheckerImpl> thread_checker;
   const SequenceToken sequence_token = SequenceToken::Create();
@@ -130,7 +130,7 @@ TEST(ThreadCheckerTest, DisallowedDifferentThreadsNoSequenceToken) {
 
 TEST(ThreadCheckerTest, DisallowedDifferentThreadsSameSequence) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+      MakeRefCounted<TestSimpleTaskRunner>());
   const SequenceToken sequence_token(SequenceToken::Create());
 
   ScopedSetSequenceTokenForCurrentThread
@@ -147,7 +147,7 @@ TEST(ThreadCheckerTest, DisallowedSameThreadDifferentSequence) {
   std::unique_ptr<ThreadCheckerImpl> thread_checker;
 
   ThreadTaskRunnerHandle thread_task_runner_handle(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+      MakeRefCounted<TestSimpleTaskRunner>());
 
   {
     ScopedSetSequenceTokenForCurrentThread
@@ -180,7 +180,7 @@ TEST(ThreadCheckerTest, DetachFromThread) {
 
 TEST(ThreadCheckerTest, DetachFromThreadWithSequenceToken) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
-      make_scoped_refptr(new TestSimpleTaskRunner));
+      MakeRefCounted<TestSimpleTaskRunner>());
   ScopedSetSequenceTokenForCurrentThread
       scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
   ThreadCheckerImpl thread_checker;

base/trace_event/memory_dump_manager_unittest.cc

@@ -508,9 +508,9 @@ TEST_F(MemoryDumpManagerTest, PostTaskForSequencedTaskRunner) {
   InitializeMemoryDumpManagerForInProcessTesting(false /* is_coordinator */);
   std::vector<MockMemoryDumpProvider> mdps(3);
   scoped_refptr<TestSequencedTaskRunner> task_runner1(
-      make_scoped_refptr(new TestSequencedTaskRunner()));
+      MakeRefCounted<TestSequencedTaskRunner>());
   scoped_refptr<TestSequencedTaskRunner> task_runner2(
-      make_scoped_refptr(new TestSequencedTaskRunner()));
+      MakeRefCounted<TestSequencedTaskRunner>());
   RegisterDumpProviderWithSequencedTaskRunner(&mdps[0], task_runner1,
                                               kDefaultOptions);
   RegisterDumpProviderWithSequencedTaskRunner(&mdps[1], task_runner2,

cc/base/delayed_unique_notifier_unittest.cc

@@ -37,7 +37,7 @@ class DelayedUniqueNotifierTest : public testing::Test {
 
   void SetUp() override {
     notification_count_ = 0;
-    task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
+    task_runner_ = base::MakeRefCounted<base::TestSimpleTaskRunner>();
   }
 
   void Notify() { ++notification_count_; }

cc/blink/web_content_layer_impl.cc

@@ -76,7 +76,7 @@ gfx::Rect WebContentLayerImpl::PaintableRegion() {
 scoped_refptr<cc::DisplayItemList>
 WebContentLayerImpl::PaintContentsToDisplayList(
     cc::ContentLayerClient::PaintingControlSetting painting_control) {
-  auto display_list = make_scoped_refptr(new cc::DisplayItemList);
+  auto display_list = base::MakeRefCounted<cc::DisplayItemList>();
   if (client_) {
     WebDisplayItemListImpl list(display_list.get());
     client_->PaintContents(&list, PaintingControlToWeb(painting_control));

cc/blink/web_display_item_list_impl_unittest.cc

@@ -36,7 +36,7 @@ TEST(WebDisplayItemListImpl, ClipWhenCompositing) {
         clip_bounds.x, clip_bounds.y, clip_bounds.width, clip_bounds.height);
     SkIRect clip_irect = sk_clip_bounds.roundOut();
 
-    auto cc_list = make_scoped_refptr(new cc::DisplayItemList);
+    auto cc_list = base::MakeRefCounted<cc::DisplayItemList>();
     cc_blink::WebDisplayItemListImpl web_list(cc_list.get());
 
     // drawColor(background color)