Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/extensions/installed_loader.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/installed_loader.h"
 
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 89 matching lines @@
         *info.extension_manifest,
         GetCreationFlags(&info),
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
   // Once installed, non-unpacked extensions cannot change their IDs (e.g., by
   // updating the 'key' field in their manifest).
   // TODO(jstritar): migrate preferences when unpacked extensions change IDs.
-  if (extension &&
-      !Manifest::IsUnpackedLocation(extension->location()) &&
+  if (extension.get() && !Manifest::IsUnpackedLocation(extension->location()) &&
       info.extension_id != extension->id()) {
     error = errors::kCannotChangeExtensionID;
     extension = NULL;
     content::RecordAction(UserMetricsAction("Extensions.IDChangedError"));
   }
 
   // Check policy on every load in case an extension was blacklisted while
   // Chrome was not running.
   const ManagementPolicy* policy = extensions::ExtensionSystem::Get(
       extension_service_->profile())->management_policy();
-  if (extension &&
-      !policy->UserMayLoad(extension, NULL)) {
+  if (extension.get() && !policy->UserMayLoad(extension.get(), NULL)) {
     // The error message from UserMayInstall() often contains the extension ID
     // and is therefore not well suited to this UI.
     error = errors::kDisabledByPolicy;
     extension = NULL;
   }
 
-  if (!extension) {
-    extension_service_->
-        ReportExtensionLoadError(info.extension_path, error, false);
+  if (!extension.get()) {
+    extension_service_->ReportExtensionLoadError(
+        info.extension_path, error, false);
     return;
   }
 
   if (write_to_prefs)
-    extension_prefs_->UpdateManifest(extension);
+    extension_prefs_->UpdateManifest(extension.get());
 
-  extension_service_->AddExtension(extension);
+  extension_service_->AddExtension(extension.get());
 }
 
 void InstalledLoader::LoadAllExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
@@ skipping 49 matching lines @@
       base::ThreadRestrictions::ScopedAllowIO allow_io;
 
       std::string error;
       scoped_refptr<const Extension> extension(
           extension_file_util::LoadExtension(
               info->extension_path,
               info->extension_location,
               GetCreationFlags(info),
               &error));
 
-      if (!extension) {
-        extension_service_->
-            ReportExtensionLoadError(info->extension_path, error, false);
+      if (!extension.get()) {
+        extension_service_->ReportExtensionLoadError(
+            info->extension_path, error, false);
         continue;
       }
 
       extensions_info->at(i)->extension_manifest.reset(
           static_cast<DictionaryValue*>(
               extension->manifest()->value()->DeepCopy()));
       should_write_prefs = true;
     }
   }
 
@@ skipping 158 matching lines @@
 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
   int flags = extension_prefs_->GetCreationFlags(info->extension_id);
   if (!Manifest::IsUnpackedLocation(info->extension_location))
     flags |= Extension::REQUIRE_KEY;
   if (extension_prefs_->AllowFileAccess(info->extension_id))
     flags |= Extension::ALLOW_FILE_ACCESS;
   return flags;
 }
 
 }  // namespace extensions