Allow gaming_seat to use ozone gamepad as back-end

components/exo/gaming_seat.h

 // 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.
 
 #ifndef COMPONENTS_EXO_GAMING_SEAT_H_
 #define COMPONENTS_EXO_GAMING_SEAT_H_
 
-#include <memory>
+#include "components/exo/wm_helper.h"
 
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/sequenced_task_runner.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "components/exo/wm_helper.h"
-#include "device/gamepad/gamepad_data_fetcher.h"
-#include "ui/aura/client/focus_change_observer.h"
+namespace base {
+class Thread;
+}
 
 namespace exo {
 class GamingSeatDelegate;
-class GamepadDelegate;
 
-using CreateGamepadDataFetcherCallback =
-    base::Callback<std::unique_ptr<device::GamepadDataFetcher>()>;
-
-// This class represents one gaming seat, it uses a background thread
-// for polling gamepad devices and notifies the corresponding GampadDelegate of
-// any changes.
+// TODO(jkwang): Remove this GamingSeat and always use ozone gamepad once ozone
+// is default for all chrome os.
 class GamingSeat : public WMHelper::FocusObserver {
  public:
-  // This class will post tasks to invoke the delegate on the thread runner
-  // which is associated with the thread that is creating this instance.
-  GamingSeat(GamingSeatDelegate* gaming_seat_delegate,
-             base::SingleThreadTaskRunner* polling_task_runner);
+  static base::Thread* CreatePollingThreadIfNeeded();
 
-  // Allows test cases to specify a CreateGamepadDataFetcherCallback that
-  // overrides the default GamepadPlatformDataFetcher.
-  GamingSeat(GamingSeatDelegate* gaming_seat_delegate,
-             base::SingleThreadTaskRunner* polling_task_runner,
-             CreateGamepadDataFetcherCallback create_fetcher_callback);
-
-  ~GamingSeat() override;
-
-  // Overridden WMHelper::FocusObserver:
-  void OnWindowFocused(aura::Window* gained_focus,
-                       aura::Window* lost_focus) override;
-
- private:
-  class ThreadSafeGamepadChangeFetcher;
-
-  // Processes updates of gamepad data and passes changes on to delegate.
-  void ProcessGamepadChanges(int index, const device::Gamepad new_pad);
-
-  // Private implementation of methods and resources that are used on the
-  // polling thread.
-  scoped_refptr<ThreadSafeGamepadChangeFetcher> gamepad_change_fetcher_;
-
-  // The delegate that handles gamepad_added.
-  GamingSeatDelegate* const delegate_;
-
-  // The delegate instances that all other events are dispatched to.
-  GamepadDelegate* gamepad_delegates_[device::Gamepads::kItemsLengthCap];
-
-  // The current state of the gamepad represented by this instance.
-  device::Gamepads pad_state_;
-
-  // ThreadChecker for the origin thread.
-  base::ThreadChecker thread_checker_;
-
-  base::WeakPtrFactory<GamingSeat> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(GamingSeat);
+  static GamingSeat* CreateGamingSeat(GamingSeatDelegate* gaming_seat_delegate,

[reveman, 2017/05/31 22:42:23]

do we need to use a factory pattern if this is now compile time? why not just
put a few ifdefs in gaming_seat.h/cc and be done?

[jkwang, 2017/06/01 19:43:15]

No..It does not need to be like this, but I would want all the ifdef here (don't
want to do it in server.cc). So I kind of have to wrap the constructor (cause
gaming_seat_ozone does not need a thread) and expose an unified interface to
server.cc. I don't see any performance issue here.

[reveman, 2017/06/01 22:24:52]

Performance is not a concern of mine. Making the code clean and easy to
understand is important to me. If this is a compile time option then please have
simple non-factory mechanism that server.cc can use to create an instance and
either ifdef everything in gaming_seat.cc/h or add gaming_seat_IMPL.cc files if
the amount of changes are large enough to justify separate files. If you're
using separate files or not should not affect the actual implementation and is
just a choice between using ifdefs or BUILD.gn to control what is compiled. You
can follow base/memory/shared_memory.h/cc as an example of how to do this.

+                                      base::Thread* polling_thread);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_GAMING_SEAT_H_