Update chrome/ to use scoped_refptr<T>::get() rather than 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 648 matching lines @@
     creation_flags |= Extension::WAS_INSTALLED_BY_DEFAULT;
 
   installer->set_creation_flags(creation_flags);
 
   installer->set_delete_source(true);
   installer->set_download_url(download_url);
   installer->set_install_cause(extension_misc::INSTALL_CAUSE_UPDATE);
   installer->InstallCrx(extension_path);
 
   if (out_crx_installer)
-    *out_crx_installer = installer;
+    *out_crx_installer = installer.get();
 
   return true;
 }
 
 void ExtensionService::ReloadExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the extension is already reloading, don't reload again.
   if (extension_prefs_->GetDisableReasons(extension_id) &
       Extension::DISABLE_RELOAD) {
@@ skipping 57 matching lines @@
 
 bool ExtensionService::UninstallExtension(
     std::string extension_id,
     bool external_uninstall,
     string16* error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_refptr<const Extension> extension(GetInstalledExtension(extension_id));
 
   // Callers should not send us nonexistent extensions.
-  CHECK(extension);
+  CHECK(extension.get());
 
   // Policy change which triggers an uninstall will always set
   // |external_uninstall| to true so this is the only way to uninstall
   // managed extensions.
   if (!external_uninstall &&
       !system_->management_policy()->UserMayModifySettings(
         extension.get(), error)) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         content::Source<Profile>(profile_),
-        content::Details<const Extension>(extension));
+        content::Details<const Extension>(extension.get()));
     return false;
   }
 
   // Extract the data we need for sync now, but don't actually sync until we've
   // completed the uninstallation.
   syncer::SyncChange sync_change;
-  if (app_sync_bundle_.HandlesApp(*extension)) {
-    sync_change = app_sync_bundle_.CreateSyncChangeToDelete(extension);
-  } else if (extension_sync_bundle_.HandlesExtension(*extension)) {
-    sync_change = extension_sync_bundle_.CreateSyncChangeToDelete(extension);
+  if (app_sync_bundle_.HandlesApp(*extension.get())) {
+    sync_change = app_sync_bundle_.CreateSyncChangeToDelete(extension.get());
+  } else if (extension_sync_bundle_.HandlesExtension(*extension.get())) {
+    sync_change =
+        extension_sync_bundle_.CreateSyncChangeToDelete(extension.get());
   }
 
-  if (IsUnacknowledgedExternalExtension(extension)) {
+  if (IsUnacknowledgedExternalExtension(extension.get())) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEvent",
                               EXTERNAL_EXTENSION_UNINSTALLED,
                               EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
   }
   UMA_HISTOGRAM_ENUMERATION("Extensions.UninstallType",
                             extension->GetType(), 100);
-  RecordPermissionMessagesHistogram(
-      extension, "Extensions.Permissions_Uninstall");
+  RecordPermissionMessagesHistogram(extension.get(),
+                                    "Extensions.Permissions_Uninstall");
 
   // Unload before doing more cleanup to ensure that nothing is hanging on to
   // any of these resources.
   UnloadExtension(extension_id, extension_misc::UNLOAD_REASON_UNINSTALL);
 
   extension_prefs_->OnExtensionUninstalled(extension_id, extension->location(),
                                            external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     if (!GetFileTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(
                 &extension_file_util::UninstallExtension,
                 install_directory_,
                 extension_id)))
       NOTREACHED();
   }
 
   GURL launch_web_url_origin(extension->launch_web_url());
   launch_web_url_origin = launch_web_url_origin.GetOrigin();
   bool is_storage_isolated =
-      extensions::AppIsolationInfo::HasIsolatedStorage(extension);
+      extensions::AppIsolationInfo::HasIsolatedStorage(extension.get());
 
   if (is_storage_isolated) {
     BrowserContext::AsyncObliterateStoragePartition(
         profile_,
         GetSiteForExtensionId(extension_id),
         base::Bind(&ExtensionService::OnNeedsToGarbageCollectIsolatedStorage,
                    AsWeakPtr()));
   } else {
     if (extension->is_hosted_app() &&
         !profile_->GetExtensionSpecialStoragePolicy()->
             IsStorageProtected(launch_web_url_origin)) {
       extensions::DataDeleter::StartDeleting(
           profile_, extension_id, launch_web_url_origin);
     }
     extensions::DataDeleter::StartDeleting(profile_, extension_id,
                                            extension->url());
   }
 
   UntrackTerminatedExtension(extension_id);
 
   // Notify interested parties that we've uninstalled this extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       content::Source<Profile>(profile_),
-      content::Details<const Extension>(extension));
+      content::Details<const Extension>(extension.get()));
 
   if (app_sync_bundle_.HasExtensionId(extension_id) &&
       sync_change.sync_data().GetDataType() == syncer::APPS) {
     app_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   } else if (extension_sync_bundle_.HasExtensionId(extension_id) &&
              sync_change.sync_data().GetDataType() == syncer::EXTENSIONS) {
     extension_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   }
 
   delayed_updates_for_idle_.Remove(extension_id);
@@ skipping 291 matching lines @@
 
 extensions::ContentSettingsStore* ExtensionService::GetContentSettingsStore() {
   return extension_prefs()->content_settings_store();
 }
 
 bool ExtensionService::is_ready() {
   return ready_->is_signaled();
 }
 
 base::SequencedTaskRunner* ExtensionService::GetFileTaskRunner() {
-  if (file_task_runner_)
-    return file_task_runner_;
+  if (file_task_runner_.get())
+    return file_task_runner_.get();
 
   // We should be able to interrupt any part of extension install process during
   // shutdown. SKIP_ON_SHUTDOWN ensures that not started extension install tasks
   // will be ignored/deleted while we will block on started tasks.
   std::string token("ext_install-");
   token.append(profile_->GetPath().AsUTF8Unsafe());
   file_task_runner_ = BrowserThread::GetBlockingPool()->
       GetSequencedTaskRunnerWithShutdownBehavior(
         BrowserThread::GetBlockingPool()->GetNamedSequenceToken(token),
         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
-  return file_task_runner_;
+  return file_task_runner_.get();
 }
 
 extensions::ExtensionUpdater* ExtensionService::updater() {
   return updater_.get();
 }
 
 void ExtensionService::CheckManagementPolicy() {
   std::vector<std::string> to_be_removed;
 
   // Loop through extensions list, unload installed extensions.
@@ skipping 632 matching lines @@
 void ExtensionService::UnloadExtension(
     const std::string& extension_id,
     extension_misc::UnloadedExtensionReason reason) {
   // Make sure the extension gets deleted after we return from this function.
   int include_mask = INCLUDE_EVERYTHING & ~INCLUDE_TERMINATED;
   scoped_refptr<const Extension> extension(
       GetExtensionById(extension_id, include_mask));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
-  if (!extension) {
+  if (!extension.get()) {
     // In case the extension may have crashed/uninstalled. Allow the profile to
     // clean up its RequestContexts.
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
   // If uninstalling let RuntimeEventRouter know.
   if (reason == extension_misc::UNLOAD_REASON_UNINSTALL)
     extensions::RuntimeEventRouter::OnExtensionUninstalled(
         profile_, extension_id);
 
   // Keep information about the extension so that we can reload it later
   // even if it's not permanently installed.
   unloaded_extension_paths_[extension->id()] = extension->path();
 
   // Clean up if the extension is meant to be enabled after a reload.
   reloading_extensions_.erase(extension->id());
 
   // Clean up runtime data.
   extension_runtime_data_.erase(extension_id);
 
   if (disabled_extensions_.Contains(extension->id())) {
-    UnloadedExtensionInfo details(extension, reason);
+    UnloadedExtensionInfo details(extension.get(), reason);
     details.already_disabled = true;
     disabled_extensions_.Remove(extension->id());
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNLOADED,
         content::Source<Profile>(profile_),
         content::Details<UnloadedExtensionInfo>(&details));
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
@@ skipping 200 matching lines @@
   AddExtension(extension);
 }
 
 void ExtensionService::UpdateActivePermissions(const Extension* extension) {
   // 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.
   scoped_refptr<PermissionSet> active_permissions =
       extension_prefs()->GetActivePermissions(extension->id());
 
-  if (active_permissions) {
+  if (active_permissions.get()) {
     // 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(
             extensions::PermissionsData::GetRequiredPermissions(extension),
             extensions::PermissionsData::GetOptionalPermissions(extension));
 
     // Make sure the active permissions contain no more than optional + default.
     scoped_refptr<PermissionSet> adjusted_active =
         PermissionSet::CreateIntersection(
             total_permissions.get(), active_permissions.get());
 
     // Make sure the active permissions contain the default permissions.
     adjusted_active = PermissionSet::CreateUnion(
         extensions::PermissionsData::GetRequiredPermissions(extension),
         adjusted_active.get());
 
     extensions::PermissionsUpdater perms_updater(profile());
-    perms_updater.UpdateActivePermissions(extension, adjusted_active);
+    perms_updater.UpdateActivePermissions(extension, adjusted_active.get());
   }
 }
 
 void ExtensionService::CheckPermissionsIncrease(const Extension* extension,
                                                 bool is_extension_upgrade) {
   UpdateActivePermissions(extension);
 
   // We keep track of all permissions the user has granted each extension.
   // This allows extensions to gracefully support backwards compatibility
   // by including unknown permissions in their manifests. When the user
@@ skipping 229 matching lines @@
   if (!IsExtensionIdle(extension_id))
     return;
 
   FinishDelayedInstallation(extension_id);
 }
 
 void ExtensionService::FinishDelayedInstallation(
     const std::string& extension_id) {
   scoped_refptr<const Extension> extension(
       GetPendingExtensionUpdate(extension_id));
-  CHECK(extension);
+  CHECK(extension.get());
   delayed_updates_for_idle_.Remove(extension_id);
 
   if (!extension_prefs_->FinishDelayedInstallInfo(extension_id))
     NOTREACHED();
 
-  FinishInstallation(extension);
+  FinishInstallation(extension.get());
 }
 
 void ExtensionService::FinishInstallation(const Extension* extension) {
   const extensions::Extension* existing_extension =
       GetInstalledExtension(extension->id());
   bool is_update = false;
   std::string old_name;
   if (existing_extension) {
     is_update = true;
     old_name = existing_extension->name();
@@ skipping 514 matching lines @@
   std::set<std::string> not_yet_blacklisted;
   std::set_difference(new_blacklisted_ids.begin(), new_blacklisted_ids.end(),
                       old_blacklisted_ids.begin(), old_blacklisted_ids.end(),
                       std::inserter(not_yet_blacklisted,
                                     not_yet_blacklisted.begin()));
 
   for (std::set<std::string>::iterator it = no_longer_blacklisted.begin();
        it != no_longer_blacklisted.end(); ++it) {
     scoped_refptr<const Extension> extension =
         blacklisted_extensions_.GetByID(*it);
-    DCHECK(extension);
-    if (!extension)
+    DCHECK(extension.get());
+    if (!extension.get())
       continue;
     blacklisted_extensions_.Remove(*it);
-    AddExtension(extension);
+    AddExtension(extension.get());
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.UnblacklistInstalled",
-                              extension->location(), Manifest::NUM_LOCATIONS);
+                              extension->location(),
+                              Manifest::NUM_LOCATIONS);
   }
 
   for (std::set<std::string>::iterator it = not_yet_blacklisted.begin();
        it != not_yet_blacklisted.end(); ++it) {
     scoped_refptr<const Extension> extension = GetInstalledExtension(*it);
-    DCHECK(extension);
-    if (!extension)
+    DCHECK(extension.get());
+    if (!extension.get())
       continue;
     blacklisted_extensions_.Insert(extension);
     UnloadExtension(*it, extension_misc::UNLOAD_REASON_BLACKLIST);
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlacklistInstalled",
                               extension->location(), Manifest::NUM_LOCATIONS);
   }
 
   IdentifyAlertableExtensions();
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }