cros: Replace BrowserThread::FILE in InputServiceProxy

components/pairing/bluetooth_host_pairing_controller.cc

 // Copyright 2014 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 "components/pairing/bluetooth_host_pairing_controller.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
+#include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "chromeos/system/devicetype.h"
 #include "components/pairing/bluetooth_pairing_constants.h"
 #include "components/pairing/pairing_api.pb.h"
 #include "components/pairing/proto_decoder.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "net/base/io_buffer.h"
 
 namespace pairing_chromeos {
 
@@ skipping 56 matching lines @@
 std::vector<BluetoothHostPairingController::InputDeviceInfo> GetDevices() {
   std::vector<BluetoothHostPairingController::InputDeviceInfo> devices;
   if (device::InputServiceLinux::HasInstance())
     device::InputServiceLinux::GetInstance()->GetDevices(&devices);
   return devices;
 }
 
 }  // namespace
 
 BluetoothHostPairingController::BluetoothHostPairingController(
-    const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-    : current_stage_(STAGE_NONE),
-      connectivity_status_(CONNECTIVITY_UNTESTED),
-      update_status_(UPDATE_STATUS_UNKNOWN),
-      enrollment_status_(ENROLLMENT_STATUS_UNKNOWN),
-      proto_decoder_(new ProtoDecoder(this)),
-      file_task_runner_(file_task_runner),
-      ptr_factory_(this) {}
+    const scoped_refptr<base::TaskRunner>& input_service_task_runner)
+    : proto_decoder_(new ProtoDecoder(this)),

[achuithb, 2017/06/20 08:36:48]

Does base::MakeUnique not work here?

[xiyuan, 2017/06/20 15:26:55]

Done.

+      input_service_task_runner_(input_service_task_runner) {}
 
 BluetoothHostPairingController::~BluetoothHostPairingController() {
   Reset();
 }
 
 void BluetoothHostPairingController::SetDelegateForTesting(
     TestDelegate* delegate) {
   delegate_ = delegate;
 }
 
@@ skipping 53 matching lines @@
                      base::Bind(&BluetoothHostPairingController::OnForget,
                                 ptr_factory_.GetWeakPtr()));
       return;
     }
   }
   OnForget();
 }
 
 void BluetoothHostPairingController::OnGetAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!adapter_.get());
   adapter_ = adapter;
 
   if (adapter_->IsPresent()) {
     SetPowered();
   } else {
     // Set the name once the adapter is present.
     adapter_->AddObserver(this);
   }
 }
 
 void BluetoothHostPairingController::SetPowered() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (adapter_->IsPowered()) {
     was_powered_ = true;
     OnSetPowered();
   } else {
     adapter_->SetPowered(
         true,
         base::Bind(&BluetoothHostPairingController::OnSetPowered,
                    ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothHostPairingController::OnSetError,
                    ptr_factory_.GetWeakPtr()));
   }
 }
 
 void BluetoothHostPairingController::OnSetPowered() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   adapter_->AddPairingDelegate(
       this, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   device::BluetoothAdapter::ServiceOptions options;
   options.name.reset(new std::string(kPairingServiceName));
 
   adapter_->CreateRfcommService(
       device::BluetoothUUID(kPairingServiceUUID), options,
       base::Bind(&BluetoothHostPairingController::OnCreateService,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnCreateServiceError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::OnCreateService(
     scoped_refptr<device::BluetoothSocket> socket) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   service_socket_ = socket;
 
   service_socket_->Accept(
       base::Bind(&BluetoothHostPairingController::OnAccept,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnAcceptError,
                  ptr_factory_.GetWeakPtr()));
 
   adapter_->SetDiscoverable(
       true,
       base::Bind(&BluetoothHostPairingController::OnSetDiscoverable,
                  ptr_factory_.GetWeakPtr(), true),
       base::Bind(&BluetoothHostPairingController::OnSetError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::OnAccept(
     const device::BluetoothDevice* device,
     scoped_refptr<device::BluetoothSocket> socket) {
   controller_device_address_ = device->GetAddress();
 
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   adapter_->SetDiscoverable(
       false,
       base::Bind(&BluetoothHostPairingController::OnSetDiscoverable,
                  ptr_factory_.GetWeakPtr(), false),
       base::Bind(&BluetoothHostPairingController::OnSetError,
                  ptr_factory_.GetWeakPtr()));
   controller_socket_ = socket;
 
   SendHostStatus();
 
   controller_socket_->Receive(
       kReceiveSize,
       base::Bind(&BluetoothHostPairingController::OnReceiveComplete,
                  ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothHostPairingController::OnReceiveError,
                  ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothHostPairingController::OnSetDiscoverable(bool change_stage) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (change_stage) {
     DCHECK_EQ(current_stage_, STAGE_NONE);
     ChangeStage(STAGE_WAITING_FOR_CONTROLLER);
   }
 }
 
 void BluetoothHostPairingController::OnSendComplete(int bytes_sent) {}
 
 void BluetoothHostPairingController::OnReceiveComplete(
     int bytes, scoped_refptr<net::IOBuffer> io_buffer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   proto_decoder_->DecodeIOBuffer(bytes, io_buffer);
 
   if (controller_socket_.get()) {
     controller_socket_->Receive(
         kReceiveSize,
         base::Bind(&BluetoothHostPairingController::OnReceiveComplete,
                    ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothHostPairingController::OnReceiveError,
                    ptr_factory_.GetWeakPtr()));
   }
@@ skipping 63 matching lines @@
     service_socket_ = nullptr;
   }
 
   if (adapter_.get()) {
     if (adapter_->IsDiscoverable()) {
       adapter_->SetDiscoverable(false, base::Bind(&base::DoNothing),
                                 base::Bind(&base::DoNothing));
     }
 
     base::PostTaskAndReplyWithResult(
-        file_task_runner_.get(), FROM_HERE, base::Bind(&GetDevices),
+        input_service_task_runner_.get(), FROM_HERE, base::Bind(&GetDevices),
         base::Bind(&BluetoothHostPairingController::PowerOffAdapterIfApplicable,
                    ptr_factory_.GetWeakPtr()));
   }
   ChangeStage(STAGE_NONE);
 }
 
 void BluetoothHostPairingController::SetControllerDeviceAddressForTesting(
     const std::string& address) {
   controller_device_address_ = address;
 }
@@ skipping 16 matching lines @@
   for (Observer& observer : observers_) {
     observer.ConfigureHostRequested(
         message.parameters().accepted_eula(), message.parameters().lang(),
         message.parameters().timezone(), message.parameters().send_reports(),
         message.parameters().keyboard_layout());
   }
 }
 
 void BluetoothHostPairingController::OnPairDevicesMessage(
     const pairing_api::PairDevices& message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   enrollment_domain_ = message.parameters().enrolling_domain();
   ChangeStage(STAGE_ENROLLING);
   for (Observer& observer : observers_)
     observer.EnrollHostRequested(message.parameters().admin_access_token());
 }
 
 void BluetoothHostPairingController::OnCompleteSetupMessage(
     const pairing_api::CompleteSetup& message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (current_stage_ != STAGE_ENROLLMENT_SUCCESS) {
     ChangeStage(STAGE_ENROLLMENT_ERROR);
   } else {
     // TODO(zork): Handle adding another controller. (http://crbug.com/405757)
     ChangeStage(STAGE_FINISHED);
   }
   Reset();
 }
 
 void BluetoothHostPairingController::OnErrorMessage(
     const pairing_api::Error& message) {
   NOTREACHED();
 }
 
 void BluetoothHostPairingController::OnRebootMessage(
     const pairing_api::Reboot& message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   for (Observer& observer : observers_)
     observer.RebootHostRequested();
 }
 
 void BluetoothHostPairingController::OnAddNetworkMessage(
     const pairing_api::AddNetwork& message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   for (Observer& observer : observers_)
     observer.AddNetworkRequested(message.parameters().onc_spec());
 }
 
 void BluetoothHostPairingController::AdapterPresentChanged(
     device::BluetoothAdapter* adapter,
     bool present) {
   DCHECK_EQ(adapter, adapter_.get());
   if (present) {
     adapter_->RemoveObserver(this);
@@ skipping 52 matching lines @@
     UpdateStatus update_status) {
   update_status_ = update_status;
   if (update_status == UPDATE_STATUS_UPDATED)
     ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
   SendHostStatus();
 }
 
 void BluetoothHostPairingController::OnEnrollmentStatusChanged(
     EnrollmentStatus enrollment_status) {
   DCHECK_EQ(current_stage_, STAGE_ENROLLING);
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   enrollment_status_ = enrollment_status;
   if (enrollment_status == ENROLLMENT_STATUS_SUCCESS) {
     ChangeStage(STAGE_ENROLLMENT_SUCCESS);
   } else if (enrollment_status == ENROLLMENT_STATUS_FAILURE) {
     ChangeStage(STAGE_ENROLLMENT_ERROR);
   }
   SendHostStatus();
 }
 
@@ skipping 48 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos