Rename TaskRunner::RunsTasksOnCurrentThread() in //extensions, //headless, //mojo

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 217 matching lines @@
       location_(location),
       creation_flags_(creation_flags),
       unpacker_io_task_runner_(unpacker_io_task_runner) {
   // Tracking for crbug.com/692069. The location must be valid. If it's invalid,
   // the utility process kills itself for a bad IPC.
   CHECK_GT(location, Manifest::INVALID_LOCATION);
   CHECK_LT(location, Manifest::NUM_LOCATIONS);
 }
 
 bool SandboxedUnpacker::CreateTempDirectory() {
-  CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(unpacker_io_task_runner_->RunsTasksInCurrentSequence());
 
   base::FilePath temp_dir;
   if (!FindWritableTempLocation(extensions_dir_, &temp_dir)) {
     ReportFailure(COULD_NOT_GET_TEMP_DIRECTORY,
                   l10n_util::GetStringFUTF16(
                       IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                       ASCIIToUTF16("COULD_NOT_GET_TEMP_DIRECTORY")));
     return false;
   }
 
   if (!temp_dir_.CreateUniqueTempDirUnderPath(temp_dir)) {
     ReportFailure(COULD_NOT_CREATE_TEMP_DIRECTORY,
                   l10n_util::GetStringFUTF16(
                       IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                       ASCIIToUTF16("COULD_NOT_CREATE_TEMP_DIRECTORY")));
     return false;
   }
 
   return true;
 }
 
 void SandboxedUnpacker::StartWithCrx(const CRXFileInfo& crx_info) {
   // We assume that we are started on the thread that the client wants us
   // to do file IO on.
-  CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(unpacker_io_task_runner_->RunsTasksInCurrentSequence());
 
   crx_unpack_start_time_ = base::TimeTicks::Now();
   std::string expected_hash;
   if (!crx_info.expected_hash.empty() &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           extensions::switches::kEnableCrxHashCheck)) {
     expected_hash = base::ToLowerASCII(crx_info.expected_hash);
   }
 
   PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackInitialCrxPathLength",
@@ skipping 166 matching lines @@
     return;
   }
 
   unpacker_io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SandboxedUnpacker::UnpackExtensionSucceeded, this,
                             base::Passed(&manifest)));
 }
 
 void SandboxedUnpacker::UnpackExtensionSucceeded(
     std::unique_ptr<base::DictionaryValue> manifest) {
-  CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(unpacker_io_task_runner_->RunsTasksInCurrentSequence());
 
   std::unique_ptr<base::DictionaryValue> final_manifest(
       RewriteManifestFile(*manifest));
   if (!final_manifest)
     return;
 
   // Create an extension object that refers to the temporary location the
   // extension was unpacked to. We use this until the extension is finally
   // installed. For example, the install UI shows images from inside the
   // extension.
@@ skipping 26 matching lines @@
   if (!RewriteImageFiles(&install_icon))
     return;
 
   if (!RewriteCatalogFiles())
     return;
 
   ReportSuccess(std::move(manifest), install_icon);
 }
 
 void SandboxedUnpacker::UnpackExtensionFailed(const base::string16& error) {
-  CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(unpacker_io_task_runner_->RunsTasksInCurrentSequence());
 
   ReportFailure(
       UNPACKER_CLIENT_FAILED,
       l10n_util::GetStringFUTF16(IDS_EXTENSION_PACKAGE_ERROR_MESSAGE, error));
 }
 
 base::string16 SandboxedUnpacker::FailureReasonToString16(
     FailureReason reason) {
   switch (reason) {
     case COULD_NOT_GET_TEMP_DIRECTORY:
@@ skipping 390 matching lines @@
           l10n_util::GetStringFUTF16(IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
                                      ASCIIToUTF16("ERROR_SAVING_CATALOG")));
       return false;
     }
   }
 
   return true;
 }
 
 void SandboxedUnpacker::Cleanup() {
-  DCHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(unpacker_io_task_runner_->RunsTasksInCurrentSequence());
   if (!temp_dir_.Delete()) {
     LOG(WARNING) << "Can not delete temp directory at "
                  << temp_dir_.GetPath().value();
   }
 }
 
 }  // namespace extensions