Call scoped_refptr<T>::get() rather than relying on 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 69 matching lines @@
   return base::Bind(&RunChecker::Run, base::Owned(new RunChecker(location)));
 }
 
 // With the task tracker, post a task, a task with a reply, and get a
 // new task id without canceling any of them.  The tasks and the reply
 // should run and the "is canceled" callback should return false.
 TEST_F(CancelableTaskTrackerTest, NoCancel) {
   base::Thread worker_thread("worker thread");
   ASSERT_TRUE(worker_thread.Start());
 
-  ignore_result(
-      task_tracker_.PostTask(
-          worker_thread.message_loop_proxy(),
-          FROM_HERE,
-          MakeExpectedRunClosure(FROM_HERE)));
+  ignore_result(task_tracker_.PostTask(worker_thread.message_loop_proxy().get(),
+                                       FROM_HERE,
+                                       MakeExpectedRunClosure(FROM_HERE)));
 
   ignore_result(
-      task_tracker_.PostTaskAndReply(
-          worker_thread.message_loop_proxy(),
-          FROM_HERE,
-          MakeExpectedRunClosure(FROM_HERE),
-          MakeExpectedRunClosure(FROM_HERE)));
+      task_tracker_.PostTaskAndReply(worker_thread.message_loop_proxy().get(),
+                                     FROM_HERE,
+                                     MakeExpectedRunClosure(FROM_HERE),
+                                     MakeExpectedRunClosure(FROM_HERE)));
 
   CancelableTaskTracker::IsCanceledCallback is_canceled;
   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 
   worker_thread.Stop();
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_FALSE(is_canceled.Run());
 }
@@ skipping 59 matching lines @@
 }
 
 // Post a task with reply with the task tracker on a worker thread and
 // cancel it before running the current message loop.  The task should
 // run but the reply should not.
 TEST_F(CancelableTaskTrackerTest, CancelReplyDifferentThread) {
   base::Thread worker_thread("worker thread");
   ASSERT_TRUE(worker_thread.Start());
 
   CancelableTaskTracker::TaskId task_id =
-      task_tracker_.PostTaskAndReply(
-          worker_thread.message_loop_proxy(),
-          FROM_HERE,
-          base::Bind(&base::DoNothing),
-          MakeExpectedNotRunClosure(FROM_HERE));
+      task_tracker_.PostTaskAndReply(worker_thread.message_loop_proxy().get(),
+                                     FROM_HERE,
+                                     base::Bind(&base::DoNothing),
+                                     MakeExpectedNotRunClosure(FROM_HERE));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
   task_tracker_.TryCancel(task_id);
 
   worker_thread.Stop();
 }
 
 void ExpectIsCanceled(
     const CancelableTaskTracker::IsCanceledCallback& is_canceled,
     bool expected_is_canceled) {
@@ skipping 182 matching lines @@
     const base::Callback<void(CancelableTaskTracker*)>& fn) {
   // CancelableTask uses DCHECKs with its ThreadChecker (itself only
   // enabled in debug mode).
 #if ENABLE_THREAD_CHECKER
   EXPECT_DEATH_IF_SUPPORTED(fn.Run(task_tracker), "");
 #endif
 }
 
 void PostDoNothingTask(CancelableTaskTracker* task_tracker) {
   ignore_result(
-      task_tracker->PostTask(
-          scoped_refptr<base::TestSimpleTaskRunner>(
-              new base::TestSimpleTaskRunner()),
-          FROM_HERE, base::Bind(&base::DoNothing)));
+      task_tracker->PostTask(scoped_refptr<base::TestSimpleTaskRunner>(
+                                 new base::TestSimpleTaskRunner())
+                                 .get(),
+                             FROM_HERE,
+                             base::Bind(&base::DoNothing)));
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
   base::Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   bad_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
                  base::Unretained(&task_tracker_),
@@ skipping 45 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