Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/common/cancelable_task_tracker_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/common/cancelable_task_tracker.h"
 
 #include <cstddef>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 212 matching lines @@
 }
 
 // With the task tracker, post a task, a task with a reply, get a new
 // task id, and then cancel all of them.  None of the tasks nor the
 // reply should run and the "is canceled" callback should return
 // true.
 TEST_F(CancelableTaskTrackerTest, CancelAll) {
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner(
       new base::TestSimpleTaskRunner());
 
-  ignore_result(
-      task_tracker_.PostTask(
-          test_task_runner,
-          FROM_HERE,
-          MakeExpectedNotRunClosure(FROM_HERE)));
+  ignore_result(task_tracker_.PostTask(
+      test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
 
   ignore_result(
-      task_tracker_.PostTaskAndReply(
-          test_task_runner,
-          FROM_HERE,
-          MakeExpectedNotRunClosure(FROM_HERE),
-          MakeExpectedNotRunClosure(FROM_HERE)));
+      task_tracker_.PostTaskAndReply(test_task_runner.get(),
+                                     FROM_HERE,
+                                     MakeExpectedNotRunClosure(FROM_HERE),
+                                     MakeExpectedNotRunClosure(FROM_HERE)));
 
   CancelableTaskTracker::IsCanceledCallback is_canceled;
   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 
   task_tracker_.TryCancelAll();
 
   test_task_runner->RunUntilIdle();
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_TRUE(is_canceled.Run());
 }
 
 // With the task tracker, post a task, a task with a reply, get a new
 // task id, and then cancel all of them.  None of the tasks nor the
 // reply should run and the "is canceled" callback should return
 // true.
 TEST_F(CancelableTaskTrackerTest, DestructionCancelsAll) {
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner(
       new base::TestSimpleTaskRunner());
 
   CancelableTaskTracker::IsCanceledCallback is_canceled;
 
   {
     // Create another task tracker with a smaller scope.
     CancelableTaskTracker task_tracker;
 
-    ignore_result(
-        task_tracker.PostTask(
-            test_task_runner,
-            FROM_HERE,
-            MakeExpectedNotRunClosure(FROM_HERE)));
+    ignore_result(task_tracker.PostTask(test_task_runner.get(),
+                                        FROM_HERE,
+                                        MakeExpectedNotRunClosure(FROM_HERE)));
 
     ignore_result(
-        task_tracker.PostTaskAndReply(
-            test_task_runner,
-            FROM_HERE,
-            MakeExpectedNotRunClosure(FROM_HERE),
-            MakeExpectedNotRunClosure(FROM_HERE)));
+        task_tracker.PostTaskAndReply(test_task_runner.get(),
+                                      FROM_HERE,
+                                      MakeExpectedNotRunClosure(FROM_HERE),
+                                      MakeExpectedNotRunClosure(FROM_HERE)));
 
     ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
   }
 
   test_task_runner->RunUntilIdle();
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_FALSE(is_canceled.Run());
 }
 
 // Post a task and cancel it.  HasTrackedTasks() should return true
 // from when the task is posted until the (do-nothing) reply task is
 // flushed.
 TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPost) {
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner(
       new base::TestSimpleTaskRunner());
 
   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 
-  ignore_result(
-      task_tracker_.PostTask(
-          test_task_runner,
-          FROM_HERE,
-          MakeExpectedNotRunClosure(FROM_HERE)));
+  ignore_result(task_tracker_.PostTask(
+      test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
 
   task_tracker_.TryCancelAll();
 
   test_task_runner->RunUntilIdle();
 
   EXPECT_TRUE(task_tracker_.HasTrackedTasks());
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 }
 
 // Post a task with a reply and cancel it.  HasTrackedTasks() should
 // return true from when the task is posted until it is canceled.
 TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPostWithReply) {
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner(
       new base::TestSimpleTaskRunner());
 
   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 
   ignore_result(
-      task_tracker_.PostTaskAndReply(
-          test_task_runner,
-          FROM_HERE,
-          MakeExpectedNotRunClosure(FROM_HERE),
-          MakeExpectedNotRunClosure(FROM_HERE)));
+      task_tracker_.PostTaskAndReply(test_task_runner.get(),
+                                     FROM_HERE,
+                                     MakeExpectedNotRunClosure(FROM_HERE),
+                                     MakeExpectedNotRunClosure(FROM_HERE)));
 
   task_tracker_.TryCancelAll();
 
   test_task_runner->RunUntilIdle();
 
   EXPECT_TRUE(task_tracker_.HasTrackedTasks());
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
@@ skipping 113 matching lines @@
   bad_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
                  base::Unretained(&task_tracker_),
                  base::Bind(&CancelableTaskTracker::TryCancelAll)));
 
   test_task_runner->RunUntilIdle();
 }
 
 }  // namespace