Remove implicit scoped_refptr operator T*

chrome/browser/managed_mode/managed_mode_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 "chrome/browser/managed_mode/managed_mode.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 109 matching lines @@
   ManagedModeTest() : message_loop_(MessageLoop::TYPE_UI),
                       ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   scoped_refptr<MockCallback> CreateCallback() {
     return new StrictMock<MockCallback>(&managed_mode_);
   }
 
   base::Callback<void(bool)> CreateExpectedCallback(bool success) {
     scoped_refptr<MockCallback> callback = CreateCallback();
-    EXPECT_CALL(*callback, DidEnterManagedMode(success));
+    EXPECT_CALL(*callback.get(), DidEnterManagedMode(success));
     return base::Bind(&MockCallback::CheckManagedMode, callback);
   }
 
  protected:
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   TestingProfile managed_mode_profile_;
   TestingProfile other_profile_;
   FakeManagedMode managed_mode_;
 };
@@ skipping 27 matching lines @@
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
   EXPECT_CALL(*other_browser.window(), Close());
   managed_mode_.EnterManagedModeForTesting(
       &managed_mode_profile_,
       base::Bind(&MockCallback::CheckManagedMode, callback));
   managed_mode_.EnterManagedModeForTesting(
       &managed_mode_profile_,
       base::Bind(&MockCallback::CheckManagedMode, callback));
   // The callbacks should run as soon as |other_browser| is closed.
-  EXPECT_CALL(*callback, DidEnterManagedMode(true)).Times(2);
+  EXPECT_CALL(*callback.get(), DidEnterManagedMode(true)).Times(2);
 }
 
 TEST_F(ManagedModeTest, OpenNewBrowser) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
   scoped_refptr<MockCallback> callback = CreateCallback();
   EXPECT_CALL(*other_browser.window(), Close());
   managed_mode_.EnterManagedModeForTesting(
       &managed_mode_profile_,
       base::Bind(&MockCallback::CheckManagedMode, callback));
 
   // Opening another browser with the managed profile should not cancel entering
   // managed mode.
   BrowserFixture other_managed_mode_browser(&managed_mode_,
                                             &managed_mode_profile_);
 
   // Opening another browser should cancel entering managed mode.
-  EXPECT_CALL(*callback, DidEnterManagedMode(false));
+  EXPECT_CALL(*callback.get(), DidEnterManagedMode(false));
   BrowserFixture yet_another_browser(&managed_mode_, &other_profile_);
 }
 
 TEST_F(ManagedModeTest, DifferentProfile) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
 
   // Keep this before the other browser is constructed, so we verify its
   // expectations after the browser is destroyed.
   scoped_refptr<MockCallback> callback = CreateCallback();
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
   EXPECT_CALL(*other_browser.window(), Close());
   managed_mode_.EnterManagedModeForTesting(
       &managed_mode_profile_,
       base::Bind(&MockCallback::CheckManagedMode, callback));
 
   // Trying to enter managed mode with a different profile should fail
   // immediately.
   managed_mode_.EnterManagedModeForTesting(&other_profile_,
                                            CreateExpectedCallback(false));
 
   // The first request should still succeed as soon as the other browser is
   // closed.
-  EXPECT_CALL(*callback, DidEnterManagedMode(true));
+  EXPECT_CALL(*callback.get(), DidEnterManagedMode(true));
 }
 
 TEST_F(ManagedModeTest, Cancelled) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
   // If the user cancelled entering managed mode, it should fail immediately.
   managed_mode_.set_should_cancel_enter(true);
   managed_mode_.EnterManagedModeForTesting(&managed_mode_profile_,
                                            CreateExpectedCallback(false));
 }
 
 TEST_F(ManagedModeTest, ExtensionManagementPolicyProvider) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
 
   EXPECT_TRUE(managed_mode_.UserMayLoad(NULL, NULL));
   EXPECT_TRUE(managed_mode_.UserMayModifySettings(NULL, NULL));
 
   managed_mode_.SetInManagedMode(&managed_mode_profile_);
   EXPECT_FALSE(managed_mode_.UserMayLoad(NULL, NULL));
   EXPECT_FALSE(managed_mode_.UserMayModifySettings(NULL, NULL));
 
 #ifndef NDEBUG
   EXPECT_FALSE(managed_mode_.GetDebugPolicyProviderName().empty());
 #endif
 }