extensions: Change ScopedTempDir::path() to GetPath()

extensions/browser/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 "extensions/browser/sandboxed_unpacker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 254 matching lines @@
           extensions::switches::kEnableCrxHashCheck)) {
     expected_hash = base::ToLowerASCII(crx_info.expected_hash);
   }
 
   PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackInitialCrxPathLength",
                         crx_info.path);
   if (!CreateTempDirectory())
     return;  // ReportFailure() already called.
 
   // Initialize the path that will eventually contain the unpacked extension.
-  extension_root_ = temp_dir_.path().AppendASCII(kTempExtensionName);
+  extension_root_ = temp_dir_.GetPath().AppendASCII(kTempExtensionName);
   PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackUnpackedCrxPathLength",
                         extension_root_);
 
   // Extract the public key and validate the package.
   if (!ValidateSignature(crx_info.path, expected_hash))
     return;  // ValidateSignature() already reported the error.
 
   // Copy the crx file into our working directory.
   base::FilePath temp_crx_path =
-      temp_dir_.path().Append(crx_info.path.BaseName());
+      temp_dir_.GetPath().Append(crx_info.path.BaseName());
   PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackTempCrxPathLength",
                         temp_crx_path);
 
   if (!base::CopyFile(crx_info.path, temp_crx_path)) {
     // Failed to copy extension file to temporary directory.
     ReportFailure(
         FAILED_TO_COPY_EXTENSION_FILE_TO_TEMP_DIRECTORY,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             ASCIIToUTF16("FAILED_TO_COPY_EXTENSION_FILE_TO_TEMP_DIRECTORY")));
@@ skipping 22 matching lines @@
 }
 
 void SandboxedUnpacker::StartWithDirectory(const std::string& extension_id,
                                            const std::string& public_key,
                                            const base::FilePath& directory) {
   extension_id_ = extension_id;
   public_key_ = public_key;
   if (!CreateTempDirectory())
     return;  // ReportFailure() already called.
 
-  extension_root_ = temp_dir_.path().AppendASCII(kTempExtensionName);
+  extension_root_ = temp_dir_.GetPath().AppendASCII(kTempExtensionName);
 
   if (!base::Move(directory, extension_root_)) {
     LOG(ERROR) << "Could not move " << directory.value() << " to "
                << extension_root_.value();
     ReportFailure(
         DIRECTORY_MOVE_FAILED,
         l10n_util::GetStringFUTF16(IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                                    ASCIIToUTF16("DIRECTORY_MOVE_FAILED")));
     return;
   }
@@ skipping 34 matching lines @@
   ReportFailure(
       UTILITY_PROCESS_CRASHED_WHILE_TRYING_TO_INSTALL,
       l10n_util::GetStringFUTF16(
           IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
           ASCIIToUTF16("UTILITY_PROCESS_CRASHED_WHILE_TRYING_TO_INSTALL")) +
           ASCIIToUTF16(". ") +
           l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALL_PROCESS_CRASHED));
 }
 
 void SandboxedUnpacker::StartUnzipOnIOThread(const base::FilePath& crx_path) {
-  if (!utility_wrapper_->StartIfNeeded(temp_dir_.path(), this,
+  if (!utility_wrapper_->StartIfNeeded(temp_dir_.GetPath(), this,
                                        unpacker_io_task_runner_)) {
     ReportFailure(
         COULD_NOT_START_UTILITY_PROCESS,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             FailureReasonToString16(COULD_NOT_START_UTILITY_PROCESS)));
     return;
   }
-  DCHECK(crx_path.DirName() == temp_dir_.path());
+  DCHECK(crx_path.DirName() == temp_dir_.GetPath());
   base::FilePath unzipped_dir =
       crx_path.DirName().AppendASCII(kTempExtensionName);
   utility_wrapper_->host()->Send(
       new ExtensionUtilityMsg_UnzipToDir(crx_path, unzipped_dir));
 }
 
 void SandboxedUnpacker::StartUnpackOnIOThread(
     const base::FilePath& directory_path) {
-  if (!utility_wrapper_->StartIfNeeded(temp_dir_.path(), this,
+  if (!utility_wrapper_->StartIfNeeded(temp_dir_.GetPath(), this,
                                        unpacker_io_task_runner_)) {
     ReportFailure(
         COULD_NOT_START_UTILITY_PROCESS,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             FailureReasonToString16(COULD_NOT_START_UTILITY_PROCESS)));
     return;
   }
-  DCHECK(directory_path.DirName() == temp_dir_.path());
+  DCHECK(directory_path.DirName() == temp_dir_.GetPath());
   utility_wrapper_->host()->Send(new ExtensionUtilityMsg_UnpackExtension(
       directory_path, extension_id_, location_, creation_flags_));
 }
 
 void SandboxedUnpacker::OnUnzipToDirSucceeded(const base::FilePath& directory) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SandboxedUnpacker::StartUnpackOnIOThread, this, directory));
 }
 
@@ skipping 241 matching lines @@
 void SandboxedUnpacker::ReportSuccess(
     const base::DictionaryValue& original_manifest,
     const SkBitmap& install_icon) {
   utility_wrapper_ = nullptr;
   UMA_HISTOGRAM_COUNTS("Extensions.SandboxUnpackSuccess", 1);
 
   if (!crx_unpack_start_time_.is_null())
     RecordSuccessfulUnpackTimeHistograms(
         crx_path_for_histograms_,
         base::TimeTicks::Now() - crx_unpack_start_time_);
-  DCHECK(!temp_dir_.path().empty());
+  DCHECK(!temp_dir_.GetPath().empty());
 
   // Client takes ownership of temporary directory and extension.
   client_->OnUnpackSuccess(temp_dir_.Take(), extension_root_,
                            &original_manifest, extension_.get(), install_icon);
   extension_ = NULL;
 }
 
 base::DictionaryValue* SandboxedUnpacker::RewriteManifestFile(
     const base::DictionaryValue& manifest) {
   // Add the public key extracted earlier to the parsed manifest and overwrite
@@ skipping 23 matching lines @@
         ERROR_SAVING_MANIFEST_JSON,
         l10n_util::GetStringFUTF16(IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                                    ASCIIToUTF16("ERROR_SAVING_MANIFEST_JSON")));
     return NULL;
   }
 
   return final_manifest.release();
 }
 
 bool SandboxedUnpacker::RewriteImageFiles(SkBitmap* install_icon) {
-  DCHECK(!temp_dir_.path().empty());
+  DCHECK(!temp_dir_.GetPath().empty());
   DecodedImages images;
-  if (!ReadImagesFromFile(temp_dir_.path(), &images)) {
+  if (!ReadImagesFromFile(temp_dir_.GetPath(), &images)) {
     // Couldn't read image data from disk.
     ReportFailure(COULD_NOT_READ_IMAGE_DATA_FROM_DISK,
                   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
@@ skipping 87 matching lines @@
                                      ASCIIToUTF16("ERROR_SAVING_THEME_IMAGE")));
       return false;
     }
   }
 
   return true;
 }
 
 bool SandboxedUnpacker::RewriteCatalogFiles() {
   base::DictionaryValue catalogs;
-  if (!ReadMessageCatalogsFromFile(temp_dir_.path(), &catalogs)) {
+  if (!ReadMessageCatalogsFromFile(temp_dir_.GetPath(), &catalogs)) {
     // Could not read catalog data from disk.
     ReportFailure(COULD_NOT_READ_CATALOG_DATA_FROM_DISK,
                   l10n_util::GetStringFUTF16(
                       IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                       ASCIIToUTF16("COULD_NOT_READ_CATALOG_DATA_FROM_DISK")));
     return false;
   }
 
   // Write our parsed catalogs back to disk.
   for (base::DictionaryValue::Iterator it(catalogs); !it.IsAtEnd();
@@ skipping 45 matching lines @@
     }
   }
 
   return true;
 }
 
 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();
+                 << temp_dir_.GetPath().value();
   }
 }
 
 SandboxedUnpacker::UtilityHostWrapper::UtilityHostWrapper() {}
 
 bool SandboxedUnpacker::UtilityHostWrapper::StartIfNeeded(
     const base::FilePath& exposed_dir,
     const scoped_refptr<UtilityProcessHostClient>& client,
     const scoped_refptr<base::SequencedTaskRunner>& client_task_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 22 matching lines @@
 
 SandboxedUnpacker::UtilityHostWrapper::~UtilityHostWrapper() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (utility_host_) {
     utility_host_->EndBatchMode();
     utility_host_.reset();
   }
 }
 
 }  // namespace extensions