[storage] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

storage/browser/blob/blob_url_request_job.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 "storage/browser/blob/blob_url_request_job.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util_proxy.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
@@ skipping 21 matching lines @@
   }
 }
 
 }  // namespace
 
 BlobURLRequestJob::BlobURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     scoped_ptr<BlobDataSnapshot> blob_data,
     storage::FileSystemContext* file_system_context,
-    base::MessageLoopProxy* file_thread_proxy)
+    base::SingleThreadTaskRunner* file_task_runner)
     : net::URLRequestJob(request, network_delegate),
       blob_data_(blob_data.Pass()),
       file_system_context_(file_system_context),
-      file_thread_proxy_(file_thread_proxy),
+      file_task_runner_(file_task_runner),
       total_size_(0),
       remaining_bytes_(0),
       pending_get_file_info_count_(0),
       current_item_index_(0),
       current_item_offset_(0),
       error_(false),
       byte_range_set_(false),
       weak_factory_(this) {
   TRACE_EVENT_ASYNC_BEGIN1("Blob", "BlobRequest", this, "uuid",
                            blob_data_ ? blob_data_->uuid() : "NotFound");
-  DCHECK(file_thread_proxy_.get());
+  DCHECK(file_task_runner_.get());
 }
 
 void BlobURLRequestJob::Start() {
   // Continue asynchronously.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BlobURLRequestJob::DidStart, weak_factory_.GetWeakPtr()));
 }
 
 void BlobURLRequestJob::Kill() {
@@ skipping 503 matching lines @@
   const auto& items = blob_data_->items();
   DCHECK_LT(index, items.size());
   const BlobDataItem& item = *items.at(index);
   DCHECK(IsFileType(item.type()));
   DCHECK_EQ(0U, index_to_reader_.count(index));
 
   FileStreamReader* reader = NULL;
   switch (item.type()) {
     case DataElement::TYPE_FILE:
       reader = FileStreamReader::CreateForLocalFile(
-          file_thread_proxy_.get(),
+          file_task_runner_.get(),
           item.path(),
           item.offset() + additional_offset,
           item.expected_modification_time());
       break;
     case DataElement::TYPE_FILE_FILESYSTEM:
       reader = file_system_context_
                    ->CreateFileStreamReader(
                          storage::FileSystemURL(file_system_context_->CrackURL(
                              item.filesystem_url())),
                          item.offset() + additional_offset,
                          item.length() == std::numeric_limits<uint64>::max()
                              ? storage::kMaximumLength
                              : item.length() - additional_offset,
                          item.expected_modification_time())
                    .release();
       break;
     default:
       NOTREACHED();
   }
   DCHECK(reader);
   index_to_reader_[index] = reader;
 }
 
 }  // namespace storage