Remove implicit scoped_refptr operator T*

chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.cc

 // Copyright (c) 2012 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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/policy/cloud_policy_refresh_scheduler.h"
@@ skipping 36 matching lines @@
     // value back to get a millisecond-clamped time stamp for the checks below.
     store_.policy_.reset(new em::PolicyData());
     store_.policy_->set_timestamp(
         ((base::Time::NowFromSystemTime() - base::TimeDelta::FromMinutes(1)) -
          base::Time::UnixEpoch()).InMilliseconds());
     last_refresh_ =
         base::Time::UnixEpoch() +
         base::TimeDelta::FromMilliseconds(store_.policy_->timestamp());
 
     // Keep track of when the last task was posted.
-    EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _))
+    EXPECT_CALL(*task_runner_.get(), PostDelayedTask(_, _, _))
         .WillRepeatedly(DoAll(SaveArg<1>(&last_callback_),
                               SaveArg<2>(&last_delay_),
                               Return(true)));
   }
 
   CloudPolicyRefreshScheduler* CreateRefreshScheduler() {
     return new CloudPolicyRefreshScheduler(&client_, &store_, &prefs_,
                                          prefs::kUserPolicyRefreshRate,
                                          task_runner_);
   }
@@ skipping 56 matching lines @@
   client_.SetPolicy(em::PolicyFetchResponse());
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   CheckTiming(kPolicyRefreshRate);
   ASSERT_FALSE(last_callback_.is_null());
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   last_callback_.Run();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerTest, Unregistered) {
   client_.SetDMToken("");
-  EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(*task_runner_.get(), PostDelayedTask(_, _, _)).Times(0);
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   client_.NotifyPolicyFetched();
   client_.NotifyRegistrationStateChanged();
   client_.NotifyClientError();
   store_.NotifyStoreLoaded();
   store_.NotifyStoreError();
   prefs_.SetInteger(prefs::kUserPolicyRefreshRate, 12 * 60 * 60 * 1000);
 }
 
 class CloudPolicyRefreshSchedulerSteadyStateTest
@@ skipping 16 matching lines @@
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnPolicyFetched) {
   client_.NotifyPolicyFetched();
   CheckTiming(kPolicyRefreshRate);
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnRegistrationStateChanged) {
   client_.SetDMToken("new_token");
   client_.NotifyRegistrationStateChanged();
   EXPECT_EQ(last_delay_, base::TimeDelta());
 
-  EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(*task_runner_.get(), PostDelayedTask(_, _, _)).Times(0);
   client_.SetDMToken("");
   client_.NotifyRegistrationStateChanged();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnStoreLoaded) {
   store_.NotifyStoreLoaded();
   CheckTiming(kPolicyRefreshRate);
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnStoreError) {
-  EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(*task_runner_.get(), PostDelayedTask(_, _, _)).Times(0);
   store_.NotifyStoreError();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, RefreshDelayChange) {
   const int delay_short_ms = 5 * 60 * 1000;
   prefs_.SetInteger(prefs::kUserPolicyRefreshRate, delay_short_ms);
   CheckTiming(CloudPolicyRefreshScheduler::kRefreshDelayMinMs);
 
   const int delay_ms = 12 * 60 * 60 * 1000;
   prefs_.SetInteger(prefs::kUserPolicyRefreshRate, delay_ms);
@@ skipping 78 matching lines @@
     EXPECT_EQ(base::TimeDelta(), last_delay_);
     EXPECT_TRUE(last_callback_.is_null());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(CloudPolicyRefreshSchedulerClientErrorTest,
                         CloudPolicyRefreshSchedulerClientErrorTest,
                         testing::ValuesIn(kClientErrorTestCases));
 
 }  // namespace policy