Update Linux 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 817 matching lines @@
   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_installs_.Remove(extension_id);
 
-  PruneSharedModulesOnUninstall(extension);
+  PruneSharedModulesOnUninstall(extension.get());
 
   // Track the uninstallation.
   UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionUninstalled", 1, 2);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
   if (extensions_.Contains(extension_id) ||
@@ skipping 103 matching lines @@
   SyncExtensionChangeIfNeeded(*extension);
 }
 
 void ExtensionService::DisableUserExtensions() {
   extensions::ManagementPolicy* management_policy =
       system_->management_policy();
   extensions::ExtensionList to_disable;
 
   for (ExtensionSet::const_iterator extension = extensions_.begin();
       extension != extensions_.end(); ++extension) {
-    if (management_policy->UserMayModifySettings(*extension, NULL))
+    if (management_policy->UserMayModifySettings(extension->get(), NULL))
       to_disable.push_back(*extension);
   }
   for (ExtensionSet::const_iterator extension = terminated_extensions_.begin();
       extension != terminated_extensions_.end(); ++extension) {
-    if (management_policy->UserMayModifySettings(*extension, NULL))
+    if (management_policy->UserMayModifySettings(extension->get(), NULL))
       to_disable.push_back(*extension);
   }
 
   for (extensions::ExtensionList::const_iterator extension = to_disable.begin();
       extension != to_disable.end(); ++extension) {
     DisableExtension((*extension)->id(),
                      extensions::Extension::DISABLE_USER_ACTION);
   }
 }
 
@@ skipping 1276 matching lines @@
 scoped_ptr<const ExtensionSet>
     ExtensionService::GetDependentExtensions(const Extension* extension) {
   scoped_ptr<ExtensionSet> dependents(new ExtensionSet());
   scoped_ptr<ExtensionSet> set_to_check(new ExtensionSet());
   if (SharedModuleInfo::IsSharedModule(extension)) {
     set_to_check->InsertAll(disabled_extensions_);
     set_to_check->InsertAll(delayed_installs_);
     set_to_check->InsertAll(extensions_);
     for (ExtensionSet::const_iterator iter = set_to_check->begin();
          iter != set_to_check->end(); ++iter) {
-      if (SharedModuleInfo::ImportsExtensionById(*iter, extension->id())) {
+      if (SharedModuleInfo::ImportsExtensionById(iter->get(),
+                                                 extension->id())) {
         dependents->Insert(*iter);
       }
     }
   }
   return dependents.PassAs<const ExtensionSet>();
 }
 
 void ExtensionService::PruneSharedModulesOnUninstall(
     const Extension* extension) {
   if (SharedModuleInfo::ImportsModules(extension)) {
@@ skipping 760 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }