Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 774 matching lines @@
     if (!GetFileTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(
                 &extension_file_util::UninstallExtension,
                 install_directory_,
                 extension_id)))
       NOTREACHED();
   }
 
   GURL launch_web_url_origin(
-      extensions::AppLaunchInfo::GetLaunchWebURL(extension).GetOrigin());
+      extensions::AppLaunchInfo::GetLaunchWebURL(extension.get()).GetOrigin());
   bool is_storage_isolated =
       extensions::AppIsolationInfo::HasIsolatedStorage(extension.get());
 
   if (is_storage_isolated) {
     BrowserContext::AsyncObliterateStoragePartition(
         profile_,
         GetSiteForExtensionId(extension_id),
         base::Bind(&ExtensionService::OnNeedsToGarbageCollectIsolatedStorage,
                    AsWeakPtr()));
   } else {
@@ skipping 343 matching lines @@
 extensions::ExtensionUpdater* ExtensionService::updater() {
   return updater_.get();
 }
 
 void ExtensionService::CheckManagementPolicy() {
   std::vector<std::string> to_be_removed;
 
   // Loop through extensions list, unload installed extensions.
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
-    const Extension* extension = (*iter);
+    const Extension* extension = (iter->get());
     if (!system_->management_policy()->UserMayLoad(extension, NULL))
       to_be_removed.push_back(extension->id());
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (size_t i = 0; i < to_be_removed.size(); ++i)
     UnloadExtension(to_be_removed[i], extension_misc::UNLOAD_REASON_DISABLE);
 }
 
@@ skipping 517 matching lines @@
        it != blacklisted_extensions_.end(); ++it) {
     std::string id = (*it)->id();
     if (!extension_prefs_->IsBlacklistedExtensionAcknowledged(id)) {
       extension_error_ui->AddBlacklistedExtension(id);
       needs_alert = true;
     }
   }
 
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
-    const Extension* e = *iter;
+    const Extension* e = iter->get();
 
     // Extensions disabled by policy. Note: this no longer includes blacklisted
     // extensions, though we still show the same UI.
     if (!system_->management_policy()->UserMayLoad(e, NULL)) {
       if (!extension_prefs_->IsBlacklistedExtensionAcknowledged(e->id())) {
         extension_error_ui->AddBlacklistedExtension(e->id());
         needs_alert = true;
       }
     }
   }
@@ skipping 39 matching lines @@
     extension_error_ui_->Close();
 }
 
 void ExtensionService::UpdateExternalExtensionAlert() {
   if (!FeatureSwitch::prompt_for_external_extensions()->IsEnabled())
     return;
 
   const Extension* extension = NULL;
   for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
        iter != disabled_extensions_.end(); ++iter) {
-    const Extension* e = *iter;
+    const Extension* e = iter->get();
     if (IsUnacknowledgedExternalExtension(e)) {
       extension = e;
       break;
     }
   }
 
   if (extension) {
     if (!extensions::HasExternalInstallError(this)) {
       if (extension_prefs_->IncrementAcknowledgePromptCount(extension->id()) >
               kMaxExtensionAcknowledgePromptCount) {
@@ skipping 343 matching lines @@
     // Add all the recognized permissions if the granted permissions list
     // hasn't been initialized yet.
     scoped_refptr<PermissionSet> granted_permissions =
         extension_prefs_->GetGrantedPermissions(extension->id());
     CHECK(granted_permissions.get());
 
     // Here, we check if an extension's privileges have increased in a manner
     // that requires the user's approval. This could occur because the browser
     // upgraded and recognized additional privileges, or an extension upgrades
     // to a version that requires additional privileges.
-    is_privilege_increase =
-        granted_permissions->HasLessPrivilegesThan(
-            extension->GetActivePermissions());
+    is_privilege_increase = granted_permissions->HasLessPrivilegesThan(
+        extension->GetActivePermissions().get());
   }
 
   if (is_extension_upgrade) {
     // If the extension was already disabled, suppress any alerts for becoming
     // disabled on permissions increase.
     bool previously_disabled =
         extension_prefs_->IsExtensionDisabled(extension->id());
     // Legacy disabled extensions do not have a disable reason. Infer that if
     // there was no permission increase, it was likely disabled by the user.
     if (previously_disabled && disable_reasons == Extension::DISABLE_NONE &&
@@ skipping 27 matching lines @@
     extension_prefs_->AddDisableReason(
         extension->id(),
         static_cast<Extension::DisableReason>(disable_reasons));
   }
 }
 
 void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
-    const Extension* extension = *iter;
+    const Extension* extension = iter->get();
     if (!extension->is_theme() && extension->location() != Manifest::COMPONENT)
       extension_ids.insert(extension->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionService::OnExtensionInstalled(
     const Extension* extension,
     const syncer::StringOrdinal& page_ordinal,
@@ skipping 394 matching lines @@
       // to renderers.
       process->Send(new ExtensionMsg_SetScriptingWhitelist(
           *Extension::GetScriptingWhitelist()));
 
       // Loaded extensions.
       std::vector<ExtensionMsg_Loaded_Params> loaded_extensions;
       for (ExtensionSet::const_iterator iter = extensions_.begin();
            iter != extensions_.end(); ++iter) {
         // Renderers don't need to know about themes.
         if (!(*iter)->is_theme())
-          loaded_extensions.push_back(ExtensionMsg_Loaded_Params(*iter));
+          loaded_extensions.push_back(ExtensionMsg_Loaded_Params(iter->get()));
       }
       process->Send(new ExtensionMsg_Loaded(loaded_extensions));
       break;
     }
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
@@ skipping 186 matching lines @@
     // Delay installation if the extension is not idle.
     return !IsExtensionIdle(extension_id);
   }
 }
 
 void ExtensionService::GarbageCollectIsolatedStorage() {
   scoped_ptr<base::hash_set<base::FilePath> > active_paths(
       new base::hash_set<base::FilePath>());
   for (ExtensionSet::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
-    if (extensions::AppIsolationInfo::HasIsolatedStorage(*it)) {
-      active_paths->insert(
-          BrowserContext::GetStoragePartitionForSite(
-              profile_,
-              GetSiteForExtensionId((*it)->id()))->GetPath());
+    if (extensions::AppIsolationInfo::HasIsolatedStorage(it->get())) {
+      active_paths->insert(BrowserContext::GetStoragePartitionForSite(
+          profile_, GetSiteForExtensionId((*it)->id()))->GetPath());
     }
   }
 
   DCHECK(!installs_delayed());
   set_installs_delayed(true);
   BrowserContext::GarbageCollectStoragePartitions(
       profile_, active_paths.Pass(),
       base::Bind(&ExtensionService::OnGarbageCollectIsolatedStorageFinished,
                  AsWeakPtr()));
 }
@@ skipping 71 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }