Don't use base::WorkerPool in the asset_bundle app.

services/asset_bundle/asset_unpacker_job.cc

 // Copyright 2015 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 "services/asset_bundle/asset_unpacker_job.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/threading/worker_pool.h"
 #include "services/asset_bundle/asset_bundle_impl.h"
 #include "third_party/zlib/google/zip.h"
 
 namespace mojo {
 namespace asset_bundle {
 namespace {
 
 void UnzipAssets(
     const base::FilePath& zip_path,
     scoped_ptr<base::ScopedTempDir> asset_dir,
     scoped_refptr<base::TaskRunner> task_runner,
     base::Callback<void(scoped_ptr<base::ScopedTempDir>)> callback) {
   if (!zip::Unzip(zip_path, asset_dir->path())) {
     task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
   } else {
     task_runner->PostTask(FROM_HERE,
                           base::Bind(callback, base::Passed(asset_dir.Pass())));
   }
   base::DeleteFile(zip_path, false);
 }
 
 }  // namespace
 
-AssetUnpackerJob::AssetUnpackerJob(InterfaceRequest<AssetBundle> asset_bundle)
-    : asset_bundle_(asset_bundle.Pass()), weak_factory_(this) {
+AssetUnpackerJob::AssetUnpackerJob(
+    InterfaceRequest<AssetBundle> asset_bundle,
+    scoped_refptr<base::TaskRunner> worker_runner)
+    : asset_bundle_(asset_bundle.Pass()),
+      worker_runner_(worker_runner.Pass()),
+      weak_factory_(this) {
 }
 
 AssetUnpackerJob::~AssetUnpackerJob() {
 }
 
 void AssetUnpackerJob::Unpack(ScopedDataPipeConsumerHandle zipped_assets) {
   base::FilePath zip_path;
   if (!CreateTemporaryFile(&zip_path)) {
     delete this;
     return;
   }
-  scoped_refptr<base::TaskRunner> worker =
-      base::WorkerPool::GetTaskRunner(true);
-  common::CopyToFile(zipped_assets.Pass(), zip_path, worker.get(),
+  common::CopyToFile(zipped_assets.Pass(), zip_path, worker_runner_.get(),
                      base::Bind(&AssetUnpackerJob::OnZippedAssetsAvailable,
                                 weak_factory_.GetWeakPtr(), zip_path));
 }
 
 void AssetUnpackerJob::OnZippedAssetsAvailable(const base::FilePath& zip_path,
                                                bool success) {
   if (!success) {
     delete this;
     return;
   }
   scoped_ptr<base::ScopedTempDir> asset_dir(new base::ScopedTempDir());
   if (!asset_dir->CreateUniqueTempDir()) {
     delete this;
     return;
   }
-  base::WorkerPool::PostTask(
+  worker_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UnzipAssets, zip_path, base::Passed(asset_dir.Pass()),
                  base::MessageLoop::current()->task_runner(),
                  base::Bind(&AssetUnpackerJob::OnUnzippedAssetsAvailable,
-                            weak_factory_.GetWeakPtr())),
-      true);
+                            weak_factory_.GetWeakPtr())));
 }
 
 void AssetUnpackerJob::OnUnzippedAssetsAvailable(
     scoped_ptr<base::ScopedTempDir> asset_dir) {
   if (asset_dir)
-    new AssetBundleImpl(asset_bundle_.Pass(), asset_dir.Pass());
+    new AssetBundleImpl(asset_bundle_.Pass(), asset_dir.Pass(), worker_runner_);
 
   delete this;
 }
 
 }  // namespace asset_bundle
 }  // namespace mojo