Remove implicit conversions from scoped_refptr to T* in chrome/browser/extensions/

chrome/browser/extensions/permissions_updater_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/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 200 matching lines @@
                         hosts, URLPatternSet());
 
   PermissionsUpdaterListener listener;
   PermissionsUpdater updater(profile_.get());
   updater.AddPermissions(extension.get(), delta.get());
 
   listener.Wait();
 
   // Verify that the permission notification was sent correctly.
   ASSERT_TRUE(listener.received_notification());
-  ASSERT_EQ(extension, listener.extension());
+  ASSERT_EQ(extension.get(), listener.extension());
   ASSERT_EQ(UpdatedExtensionPermissionsInfo::ADDED, listener.reason());
   ASSERT_EQ(*delta.get(), *listener.permissions());
 
   // Make sure the extension's active permissions reflect the change.
   scoped_refptr<PermissionSet> active_permissions =
       PermissionSet::CreateUnion(default_permissions.get(), delta.get());
   ASSERT_EQ(*active_permissions.get(),
             *extension->permissions_data()->active_permissions().get());
 
   // Verify that the new granted and active permissions were also stored
@@ skipping 15 matching lines @@
   apis.erase(APIPermission::kNotifications);
   delta = new PermissionSet(apis, empty_manifest_permissions,
                             hosts, URLPatternSet());
 
   listener.Reset();
   updater.RemovePermissions(extension.get(), delta.get());
   listener.Wait();
 
   // Verify that the notification was correct.
   ASSERT_TRUE(listener.received_notification());
-  ASSERT_EQ(extension, listener.extension());
+  ASSERT_EQ(extension.get(), listener.extension());
   ASSERT_EQ(UpdatedExtensionPermissionsInfo::REMOVED, listener.reason());
   ASSERT_EQ(*delta.get(), *listener.permissions());
 
   // Make sure the extension's active permissions reflect the change.
   active_permissions =
       PermissionSet::CreateDifference(active_permissions.get(), delta.get());
   ASSERT_EQ(*active_permissions.get(),
             *extension->permissions_data()->active_permissions().get());
 
   // Verify that the extension prefs hold the new active permissions and the
@@ skipping 29 matching lines @@
   safe_patterns.insert(google);
   safe_patterns.insert(sub_google);
 
   std::set<URLPattern> all_patterns = base::STLSetUnion<std::set<URLPattern> >(
       all_host_patterns, safe_patterns);
 
   scoped_refptr<const Extension> extension = CreateExtensionWithPermissions(
       all_patterns, all_patterns, Manifest::INTERNAL);
   const PermissionsData* permissions_data = extension->permissions_data();
   PermissionsUpdater updater(profile_.get());
-  updater.InitializePermissions(extension);
+  updater.InitializePermissions(extension.get());
 
   // At first, the active permissions should have only the safe patterns and
   // the withheld permissions should have only the all host patterns.
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->scriptable_hosts().patterns(),
       safe_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->explicit_hosts().patterns(),
       safe_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->withheld_permissions()->scriptable_hosts().patterns(),
       all_host_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->withheld_permissions()->explicit_hosts().patterns(),
       all_host_patterns));
 
   // Then, we grant the withheld all-hosts permissions.
-  updater.GrantWithheldImpliedAllHosts(extension);
+  updater.GrantWithheldImpliedAllHosts(extension.get());
   // Now, active permissions should have all patterns, and withheld permissions
   // should have none.
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->scriptable_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->scriptable_hosts()
                   .patterns()
                   .empty());
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->explicit_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->explicit_hosts()
                   .patterns()
                   .empty());
 
   // Finally, we revoke the all hosts permissions.
-  updater.WithholdImpliedAllHosts(extension);
+  updater.WithholdImpliedAllHosts(extension.get());
 
   // We should be back to our initial state - all_hosts should be withheld, and
   // the safe patterns should be granted.
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->scriptable_hosts().patterns(),
       safe_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->explicit_hosts().patterns(),
       safe_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->withheld_permissions()->scriptable_hosts().patterns(),
       all_host_patterns));
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->withheld_permissions()->explicit_hosts().patterns(),
       all_host_patterns));
 
   // Creating a component extension should result in no withheld permissions.
   extension = CreateExtensionWithPermissions(
       all_patterns, all_patterns, Manifest::COMPONENT);
   permissions_data = extension->permissions_data();
-  updater.InitializePermissions(extension);
+  updater.InitializePermissions(extension.get());
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->scriptable_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->scriptable_hosts()
                   .patterns()
                   .empty());
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->explicit_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->explicit_hosts()
                   .patterns()
                   .empty());
 
   // Without the switch, we shouldn't withhold anything.
   switch_override.reset();
   extension = CreateExtensionWithPermissions(
       all_patterns, all_patterns, Manifest::INTERNAL);
   permissions_data = extension->permissions_data();
-  updater.InitializePermissions(extension);
+  updater.InitializePermissions(extension.get());
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->scriptable_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->scriptable_hosts()
                   .patterns()
                   .empty());
   EXPECT_TRUE(SetsAreEqual(
       permissions_data->active_permissions()->explicit_hosts().patterns(),
       all_patterns));
   EXPECT_TRUE(permissions_data->withheld_permissions()
                   ->explicit_hosts()
                   .patterns()
                   .empty());
 }
 
 }  // namespace extensions