cros: Replace BrowserThread::FILE in InputServiceProxy

chrome/browser/chromeos/device/input_service_proxy.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 "chrome/browser/chromeos/device/input_service_proxy.h"
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
+#include "base/sequence_checker.h"
 #include "base/task_runner_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using device::InputServiceLinux;
 
 typedef device::InputServiceLinux::InputDeviceInfo InputDeviceInfo;
 
 namespace chromeos {
 
-// static
-BrowserThread::ID InputServiceProxy::thread_identifier_ = BrowserThread::FILE;
+namespace {
+
+InputServiceProxy::TaskRunnerFactory* task_runner_factory = nullptr;
+
+scoped_refptr<base::TaskRunner> GetTaskRunner() {
+  if (task_runner_factory)
+    return task_runner_factory->Run();
+
+  return base::CreateSequencedTaskRunnerWithTraits(
+      {base::TaskPriority::BACKGROUND});
+}
+
+}  // namespace
 
 class InputServiceProxy::ServiceObserver : public InputServiceLinux::Observer {
  public:
-  ServiceObserver() { DCHECK_CURRENTLY_ON(BrowserThread::UI); }
-  ~ServiceObserver() override { DCHECK(CalledOnValidThread()); }
+  ServiceObserver() {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+    // Detach since this object is constructed on UI thread and forever after
+    // used from another sequence.
+    DETACH_FROM_SEQUENCE(sequence_checker_);
+  }
+  ~ServiceObserver() override {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  }
 
   void Initialize(const base::WeakPtr<InputServiceProxy>& proxy) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     InputServiceLinux::GetInstance()->AddObserver(this);
     proxy_ = proxy;
   }
 
   void Shutdown() {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     if (InputServiceLinux::HasInstance())
       InputServiceLinux::GetInstance()->RemoveObserver(this);
     delete this;
   }
 
   std::vector<InputDeviceInfo> GetDevices() {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     std::vector<InputDeviceInfo> devices;
     if (InputServiceLinux::HasInstance())
       InputServiceLinux::GetInstance()->GetDevices(&devices);
     return devices;
   }
 
   void GetDeviceInfo(const std::string& id,
                      const InputServiceProxy::GetDeviceInfoCallback& callback) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     bool success = false;
     InputDeviceInfo info;
     info.id = id;
     if (InputServiceLinux::HasInstance())
       success = InputServiceLinux::GetInstance()->GetDeviceInfo(id, &info);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(callback, success, info));
   }
 
   // InputServiceLinux::Observer implementation:
   void OnInputDeviceAdded(
       const InputServiceLinux::InputDeviceInfo& info) override {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&InputServiceProxy::OnDeviceAdded, proxy_, info));
   }
 
   void OnInputDeviceRemoved(const std::string& id) override {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&InputServiceProxy::OnDeviceRemoved, proxy_, id));
   }
 
  private:
-  bool CalledOnValidThread() const {
-    return BrowserThread::CurrentlyOn(InputServiceProxy::thread_identifier_);
-  }
-
   base::WeakPtr<InputServiceProxy> proxy_;
+  SEQUENCE_CHECKER(sequence_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceObserver);
 };
 
 InputServiceProxy::InputServiceProxy()
     : service_observer_(new ServiceObserver()),
-      task_runner_(BrowserThread::GetTaskRunnerForThread(thread_identifier_)),
+      task_runner_(GetTaskRunner()),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InputServiceProxy::ServiceObserver::Initialize,
                  base::Unretained(service_observer_.get()),
                  weak_factory_.GetWeakPtr()));
 }
 
 InputServiceProxy::~InputServiceProxy() {
@@ skipping 31 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InputServiceProxy::ServiceObserver::GetDeviceInfo,
                  base::Unretained(service_observer_.release()),
                  id,
                  callback));
 }
 
 // static
-void InputServiceProxy::SetThreadIdForTesting(BrowserThread::ID thread_id) {
-  InputServiceProxy::thread_identifier_ = thread_id;
+void InputServiceProxy::SetTaskRunnerFactoryForTesting(
+    TaskRunnerFactory* factory) {
+  task_runner_factory = factory;
 }
 
 void InputServiceProxy::OnDeviceAdded(
     const InputServiceLinux::InputDeviceInfo& info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observers_)
     observer.OnInputDeviceAdded(info);
 }
 
 void InputServiceProxy::OnDeviceRemoved(const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observers_)
     observer.OnInputDeviceRemoved(id);
 }
 
 }  // namespace chromeos