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

chrome/browser/extensions/sandboxed_unpacker.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/sandboxed_unpacker.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 310 matching lines @@
   // Utility process crashed while trying to install.
   ReportFailure(
      UTILITY_PROCESS_CRASHED_WHILE_TRYING_TO_INSTALL,
      l10n_util::GetStringFUTF16(
          IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
          ASCIIToUTF16("UTILITY_PROCESS_CRASHED_WHILE_TRYING_TO_INSTALL")));
 }
 
 void SandboxedUnpacker::StartProcessOnIOThread(
     const base::FilePath& temp_crx_path) {
-  UtilityProcessHost* host = UtilityProcessHost::Create(
-      this, unpacker_io_task_runner_);
+  UtilityProcessHost* host =
+      UtilityProcessHost::Create(this, unpacker_io_task_runner_.get());
   // Grant the subprocess access to the entire subdir the extension file is
   // in, so that it can unpack to that dir.
   host->SetExposedDir(temp_crx_path.DirName());
   host->Send(
       new ChromeUtilityMsg_UnpackExtension(
           temp_crx_path, extension_id_, location_, creation_flags_));
 }
 
 void SandboxedUnpacker::OnUnpackExtensionSucceeded(
     const DictionaryValue& manifest) {
@@ skipping 25 matching lines @@
     return;
   }
 
   extension_ = Extension::Create(
       extension_root_,
       location_,
       *final_manifest,
       Extension::REQUIRE_KEY | creation_flags_,
       &utf8_error);
 
-
-  if (!extension_) {
-    ReportFailure(
-        INVALID_MANIFEST,
-        ASCIIToUTF16("Manifest is invalid: " + utf8_error));
+  if (!extension_.get()) {
+    ReportFailure(INVALID_MANIFEST,
+                  ASCIIToUTF16("Manifest is invalid: " + utf8_error));
     return;
   }
 
   if (!RewriteImageFiles())
     return;
 
   if (!RewriteCatalogFiles())
     return;
 
   ReportSuccess(manifest);
@@ skipping 182 matching lines @@
 }
 
 void SandboxedUnpacker::ReportSuccess(
     const DictionaryValue& original_manifest) {
   UMA_HISTOGRAM_COUNTS("Extensions.SandboxUnpackSuccess", 1);
 
   RecordSuccessfulUnpackTimeHistograms(
       crx_path_, base::TimeTicks::Now() - unpack_start_time_);
 
   // Client takes ownership of temporary directory and extension.
-  client_->OnUnpackSuccess(temp_dir_.Take(),
-                           extension_root_,
-                           &original_manifest,
-                           extension_);
+  client_->OnUnpackSuccess(
+      temp_dir_.Take(), extension_root_, &original_manifest, extension_.get());
   extension_ = NULL;
 }
 
 DictionaryValue* SandboxedUnpacker::RewriteManifestFile(
     const DictionaryValue& manifest) {
   // Add the public key extracted earlier to the parsed manifest and overwrite
   // the original manifest. We do this to ensure the manifest doesn't contain an
   // exploitable bug that could be used to compromise the browser.
   scoped_ptr<DictionaryValue> final_manifest(manifest.DeepCopy());
   final_manifest->SetString(extension_manifest_keys::kPublicKey, public_key_);
@@ skipping 36 matching lines @@
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             ASCIIToUTF16("COULD_NOT_READ_IMAGE_DATA_FROM_DISK")));
     return false;
   }
 
   // Delete any images that may be used by the browser.  We're going to write
   // out our own versions of the parsed images, and we want to make sure the
   // originals are gone for good.
   std::set<base::FilePath> image_paths =
-      extension_file_util::GetBrowserImagePaths(extension_);
+      extension_file_util::GetBrowserImagePaths(extension_.get());
   if (image_paths.size() != images.size()) {
     // Decoded images don't match what's in the manifest.
     ReportFailure(
         DECODED_IMAGES_DO_NOT_MATCH_THE_MANIFEST,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             ASCIIToUTF16("DECODED_IMAGES_DO_NOT_MATCH_THE_MANIFEST")));
     return false;
   }
 
@@ skipping 140 matching lines @@
 
 void SandboxedUnpacker::Cleanup() {
   DCHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
   if (!temp_dir_.Delete()) {
     LOG(WARNING) << "Can not delete temp directory at "
                  << temp_dir_.path().value();
   }
 }
 
 }  // namespace extensions