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

chrome/browser/extensions/permissions_updater.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/extensions/permissions_updater.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 46 matching lines @@
 }
 
 // Returns a PermissionSet that has the active permissions of the extension,
 // bounded to its current manifest.
 scoped_refptr<const PermissionSet> GetBoundedActivePermissions(
     const Extension* extension,
     const scoped_refptr<const PermissionSet>& active_permissions) {
   // If the extension has used the optional permissions API, it will have a
   // custom set of active permissions defined in the extension prefs. Here,
   // we update the extension's active permissions based on the prefs.
-  if (!active_permissions)
+  if (!active_permissions.get())
     return extension->permissions_data()->active_permissions();
 
   scoped_refptr<const PermissionSet> required_permissions =
       PermissionsParser::GetRequiredPermissions(extension);
 
   // We restrict the active permissions to be within the bounds defined in the
   // extension's manifest.
   //  a) active permissions must be a subset of optional + default permissions
   //  b) active permissions must contains all default permissions
   scoped_refptr<PermissionSet> total_permissions = PermissionSet::CreateUnion(
-      required_permissions,
+      required_permissions.get(),
       PermissionsParser::GetOptionalPermissions(extension));
 
   // Make sure the active permissions contain no more than optional + default.
   scoped_refptr<PermissionSet> adjusted_active =
-      PermissionSet::CreateIntersection(total_permissions, active_permissions);
+      PermissionSet::CreateIntersection(total_permissions.get(),
+                                        active_permissions.get());
 
   // Make sure the active permissions contain the default permissions.
-  adjusted_active =
-      PermissionSet::CreateUnion(required_permissions, adjusted_active);
+  adjusted_active = PermissionSet::CreateUnion(required_permissions.get(),
+                                               adjusted_active.get());
 
   return adjusted_active;
 }
 
 // Divvy up the |url patterns| between those we grant and those we do not. If
 // |withhold_permissions| is false (because the requisite feature is not
 // enabled), no permissions are withheld.
 void SegregateUrlPermissions(const URLPatternSet& url_patterns,
                              bool withhold_permissions,
                              URLPatternSet* granted,
@@ skipping 89 matching lines @@
   SegregateUrlPermissions(bounded_active->scriptable_hosts(),
                           should_withhold_permissions,
                           &granted_scriptable_hosts,
                           &withheld_scriptable_hosts);
 
   // After withholding permissions, add back any origins to the active set that
   // may have been lost during the set operations that would have dropped them.
   // For example, the union of <all_urls> and "example.com" is <all_urls>, so
   // we may lose "example.com". However, "example.com" is important once
   // <all_urls> is stripped during withholding.
-  if (active_permissions) {
+  if (active_permissions.get()) {
     granted_explicit_hosts.AddPatterns(
         FilterSingleOriginPermissions(active_permissions->explicit_hosts(),
                                       bounded_active->explicit_hosts()));
     granted_scriptable_hosts.AddPatterns(
         FilterSingleOriginPermissions(active_permissions->scriptable_hosts(),
                                       bounded_active->scriptable_hosts()));
   }
 
   bounded_active = new PermissionSet(bounded_active->apis(),
                                      bounded_active->manifest_permissions(),
@@ skipping 141 matching lines @@
             Profile::FromBrowserContext(host->GetBrowserContext()))) {
       host->Send(new ExtensionMsg_UpdatePermissions(params));
     }
   }
 
   // Trigger the onAdded and onRemoved events in the extension.
   DispatchEvent(extension->id(), event_name, changed);
 }
 
 }  // namespace extensions