Migrate SequencedTaskRunnerHandle calls to TaskRunnerHandle calls.

blimp/client/session/blimp_client_session.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 "blimp/client/session/blimp_client_session.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/task_runner_handle.h"
 #include "blimp/client/app/blimp_client_switches.h"
 #include "blimp/client/feature/ime_feature.h"
 #include "blimp/client/feature/navigation_feature.h"
 #include "blimp/client/feature/render_widget_feature.h"
 #include "blimp/client/feature/settings_feature.h"
 #include "blimp/client/feature/tab_control_feature.h"
 #include "blimp/common/blob_cache/in_memory_blob_cache.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
@@ skipping 14 matching lines @@
 
 namespace blimp {
 namespace client {
 namespace {
 
 // Posts network events to an observer across the IO/UI thread boundary.
 class CrossThreadNetworkEventObserver : public NetworkEventObserver {
  public:
   CrossThreadNetworkEventObserver(
       const base::WeakPtr<NetworkEventObserver>& target,
-      const scoped_refptr<base::TaskRunner>& task_runner)
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner)
       : target_(target), task_runner_(task_runner) {}
 
   ~CrossThreadNetworkEventObserver() override {}
 
   void OnConnected() override {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&NetworkEventObserver::OnConnected, target_));
   }
 
   void OnDisconnected(int result) override {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&NetworkEventObserver::OnDisconnected, target_, result));
   }
 
  private:
   base::WeakPtr<NetworkEventObserver> target_;
-  scoped_refptr<base::TaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 }  // namespace
 
 // This class's functions and destruction are all invoked on the IO thread by
 // the BlimpClientSession.
 class ClientNetworkComponents : public ConnectionHandler,
                                 public ConnectionErrorObserver {
  public:
   // Can be created on any thread.
@@ skipping 107 matching lines @@
       ime_feature_(new ImeFeature),
       render_widget_feature_(new RenderWidgetFeature),
       settings_feature_(new SettingsFeature),
       weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
   blimp_connection_statistics_ = new BlimpConnectionStatistics();
   net_components_.reset(new ClientNetworkComponents(
       base::WrapUnique(new CrossThreadNetworkEventObserver(
-          weak_factory_.GetWeakPtr(), base::SequencedTaskRunnerHandle::Get())),
+          weak_factory_.GetWeakPtr(), base::TaskRunnerHandle::GetSequenced())),
       base::WrapUnique(blimp_connection_statistics_)));
 
   assignment_source_.reset(new AssignmentSource(
       assigner_endpoint, io_thread_.task_runner(), io_thread_.task_runner()));
 
   std::unique_ptr<HeliumBlobReceiverDelegate> blob_delegate(
       new HeliumBlobReceiverDelegate);
   blob_delegate_ = blob_delegate.get();
   blob_receiver_ = BlobChannelReceiver::Create(
       base::WrapUnique(new InMemoryBlobCache), std::move(blob_delegate));
@@ skipping 110 matching lines @@
   return settings_feature_.get();
 }
 
 BlimpConnectionStatistics* BlimpClientSession::GetBlimpConnectionStatistics()
     const {
   return blimp_connection_statistics_;
 }
 
 }  // namespace client
 }  // namespace blimp