Allow gaming_seat to use ozone gamepad as back-end

components/exo/gaming_seat.cc

 // Copyright 2016 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/exo/gaming_seat.h"
 
 #include <cmath>
 
 #include "base/bind.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "components/exo/gamepad_delegate.h"
 #include "components/exo/gaming_seat_delegate.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
 #include "device/gamepad/gamepad_data_fetcher.h"
 #include "device/gamepad/gamepad_pad_state_provider.h"
 #include "device/gamepad/gamepad_platform_data_fetcher_linux.h"
 #include "ui/aura/window.h"
 
 namespace exo {
 namespace {
 
 constexpr double kGamepadButtonValueEpsilon = 0.001;
 bool GamepadButtonValuesAreEqual(double a, double b) {
   return fabs(a - b) < kGamepadButtonValueEpsilon;
 }
 
 std::unique_ptr<device::GamepadDataFetcher> CreateGamepadPlatformDataFetcher() {
   return std::unique_ptr<device::GamepadDataFetcher>(
       new device::GamepadPlatformDataFetcherLinux());
 }
 
 // Time between gamepad polls in milliseconds.
 constexpr unsigned kPollingTimeIntervalMs = 16;
 
 }  // namespace
 
+base::Thread* GamingSeat::CreatePollingThreadIfNeeded() {
+  base::Thread* polling_thread =
+      new base::Thread("Exo gaming input polling thread.");
+  polling_thread->StartWithOptions(
+      base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+  return polling_thread;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // GamingSeat::ThreadSafeGamepadChangeFetcher
 
 // Implements all methods and resources running on the polling thread.
 // This class is reference counted to allow it to shut down safely on the
 // polling thread even if the Gamepad has been destroyed on the origin thread.
 class GamingSeat::ThreadSafeGamepadChangeFetcher
     : public device::GamepadPadStateProvider,
       public base::RefCountedThreadSafe<
           GamingSeat::ThreadSafeGamepadChangeFetcher> {
  public:
   using ProcessGamepadChangesCallback =
       base::Callback<void(int index, const device::Gamepad)>;
 
   ThreadSafeGamepadChangeFetcher(
       const ProcessGamepadChangesCallback& post_gamepad_changes,
       const CreateGamepadDataFetcherCallback& create_fetcher_callback,
       base::SingleThreadTaskRunner* task_runner)
       : process_gamepad_changes_(post_gamepad_changes),
         create_fetcher_callback_(create_fetcher_callback),
         polling_task_runner_(task_runner),
         origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
-    thread_checker_.DetachFromThread();
+    DETACH_FROM_THREAD(thread_checker_);
   }
 
   // Enable or disable gamepad polling. Can be called from any thread.
   void EnablePolling(bool enabled) {
     polling_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &ThreadSafeGamepadChangeFetcher::EnablePollingOnPollingThread,
             make_scoped_refptr(this), enabled));
   }
 
  private:
   friend class base::RefCountedThreadSafe<ThreadSafeGamepadChangeFetcher>;
 
   ~ThreadSafeGamepadChangeFetcher() override {}
 
   // Enables or disables polling.
   void EnablePollingOnPollingThread(bool enabled) {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     is_enabled_ = enabled;
 
     if (is_enabled_) {
       if (!fetcher_) {
         fetcher_ = create_fetcher_callback_.Run();
         InitializeDataFetcher(fetcher_.get());
         DCHECK(fetcher_);
       }
       SchedulePollOnPollingThread();
     } else {
       fetcher_.reset();
     }
   }
 
   // Schedules the next poll on the polling thread.
   void SchedulePollOnPollingThread() {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(fetcher_);
 
     if (!is_enabled_ || has_poll_scheduled_)
       return;
 
     has_poll_scheduled_ = true;
     polling_task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ThreadSafeGamepadChangeFetcher::PollOnPollingThread,
                    make_scoped_refptr(this)),
         base::TimeDelta::FromMilliseconds(kPollingTimeIntervalMs));
   }
 
   // Polls devices for new data and posts gamepad changes back to origin thread.
   void PollOnPollingThread() {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
     has_poll_scheduled_ = false;
     if (!is_enabled_)
       return;
 
     DCHECK(fetcher_);
 
     device::Gamepads new_state = state_;
     fetcher_->GetGamepadData(
         false /* No hardware changed notification from the system */);
@@ skipping 47 matching lines @@
   // The current state of all gamepads.
   device::Gamepads state_;
 
   // True if a poll has been scheduled.
   bool has_poll_scheduled_ = false;
 
   // True if the polling thread is paused.
   bool is_enabled_ = false;
 
   // ThreadChecker for the polling thread.
-  base::ThreadChecker thread_checker_;
+  THREAD_CHECKER(thread_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(ThreadSafeGamepadChangeFetcher);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // GamingSeat, public:
 
 GamingSeat::GamingSeat(GamingSeatDelegate* gaming_seat_delegate,
-                       base::SingleThreadTaskRunner* polling_task_runner)
+                       base::Thread* polling_thread)
     : GamingSeat(gaming_seat_delegate,
-                 polling_task_runner,
+                 polling_thread->task_runner().get(),
                  base::Bind(CreateGamepadPlatformDataFetcher)) {}
 
 GamingSeat::GamingSeat(GamingSeatDelegate* gaming_seat_delegate,
                        base::SingleThreadTaskRunner* polling_task_runner,
                        CreateGamepadDataFetcherCallback create_fetcher_callback)
     : delegate_(gaming_seat_delegate),
       gamepad_delegates_{nullptr},
       weak_ptr_factory_(this) {
   gamepad_change_fetcher_ = new ThreadSafeGamepadChangeFetcher(
       base::Bind(&GamingSeat::ProcessGamepadChanges,
@@ skipping 17 matching lines @@
     }
   }
   WMHelper::GetInstance()->RemoveFocusObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::client::FocusChangeObserver overrides:
 
 void GamingSeat::OnWindowFocused(aura::Window* gained_focus,
                                  aura::Window* lost_focus) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   Surface* target = nullptr;
   if (gained_focus) {
     target = Surface::AsSurface(gained_focus);
     if (!target) {
       aura::Window* top_level_window = gained_focus->GetToplevelWindow();
       if (top_level_window)
         target = ShellSurface::GetMainSurface(top_level_window);
     }
   }
 
   bool focused = target && delegate_->CanAcceptGamepadEventsForSurface(target);
 
   gamepad_change_fetcher_->EnablePolling(focused);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GamingSeat, private:
 
 void GamingSeat::ProcessGamepadChanges(int index,
                                        const device::Gamepad new_pad) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   bool send_frame = false;
 
   device::Gamepad& pad_state = pad_state_.items[index];
   // Update connection state.
   GamepadDelegate* delegate = gamepad_delegates_[index];
   if (new_pad.connected != pad_state.connected) {
     // New pad is disconnected.
     if (!new_pad.connected) {
       // If gamepad is disconnected now, it should be connected before, then
       // gamepad_delegate should not be null.
@@ skipping 35 matching lines @@
       delegate->OnButton(button_id, new_button.pressed, new_button.value);
     }
   }
   if (send_frame)
     delegate->OnFrame();
 
   pad_state = new_pad;
 }
 
 }  // namespace exo