Migrate SequencedTaskRunnerHandle calls to TaskRunnerHandle calls.

content/browser/download/url_downloader.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 "content/browser/download/url_downloader.h"
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/task_runner_handle.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_save_info.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ skipping 122 matching lines @@
 void UrlDownloader::StartReading(bool is_continuation) {
   int bytes_read;
 
   // Make sure we track the buffer in at least one place.  This ensures it gets
   // deleted even in the case the request has already finished its job and
   // doesn't use the buffer.
   scoped_refptr<net::IOBuffer> buf;
   int buf_size;
   if (!core_.OnWillRead(&buf, &buf_size, -1)) {
     request_->CancelWithError(net::ERR_ABORTED);
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
+    base::TaskRunnerHandle::GetSequenced()->PostTask(
         FROM_HERE, base::Bind(&UrlDownloader::ResponseCompleted,
                               weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   DCHECK(buf.get());
   DCHECK(buf_size > 0);
 
   request_->Read(buf.get(), buf_size, &bytes_read);
 
   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
   if (request_->status().is_io_pending())
     return;
 
   if (!is_continuation || bytes_read <= 0) {
     OnReadCompleted(request_.get(), bytes_read);
   } else {
     // Else, trigger OnReadCompleted asynchronously to avoid starving the IO
     // thread in case the URLRequest can provide data synchronously.
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
+    base::TaskRunnerHandle::GetSequenced()->PostTask(
         FROM_HERE,
         base::Bind(&UrlDownloader::OnReadCompleted,
                    weak_ptr_factory_.GetWeakPtr(), request_.get(), bytes_read));
   }
 }
 
 void UrlDownloader::OnReadCompleted(net::URLRequest* request, int bytes_read) {
   DVLOG(1) << "OnReadCompleted: \"" << request_->url().spec() << "\""
            << " bytes_read = " << bytes_read;
 
@@ skipping 32 matching lines @@
   core_.OnResponseCompleted(request_->status());
   Destroy();
 }
 
 void UrlDownloader::OnStart(
     std::unique_ptr<DownloadCreateInfo> create_info,
     std::unique_ptr<ByteStreamReader> stream_reader,
     const DownloadUrlParameters::OnStartedCallback& callback) {
   create_info->request_handle.reset(
       new RequestHandle(weak_ptr_factory_.GetWeakPtr(), manager_,
-                        base::SequencedTaskRunnerHandle::Get()));
+                        base::TaskRunnerHandle::GetSequenced()));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&DownloadManagerImpl::StartDownload,
                                      manager_, base::Passed(&create_info),
                                      base::Passed(&stream_reader), callback));
 }
 
 void UrlDownloader::OnReadyToRead() {
   if (request_->status().is_success())
     StartReading(false);  // Read the next chunk (OK to complete synchronously).
   else
@@ skipping 12 matching lines @@
   Destroy();
 }
 
 void UrlDownloader::Destroy() {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadManagerImpl::RemoveUrlDownloader, manager_, this));
 }
 
 }  // namespace content