src/chrome/browser/chromeos/device/input_service_proxy.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/device/input_service_proxy.h"
   6
   7 #include "base/task_runner_util.h"
   8 #include "content/public/browser/browser_thread.h"
   9
  10 using content::BrowserThread;
  11 using device::InputServiceLinux;
  12
  13 typedef device::InputServiceLinux::InputDeviceInfo InputDeviceInfo;
  14
  15 namespace chromeos {
  16
  17 class InputServiceProxy::ServiceObserver : public InputServiceLinux::Observer {
  18  public:
  19   ServiceObserver() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); }
  20   virtual ~ServiceObserver() { DCHECK(CalledOnValidThread()); }
  21
  22   void Initialize(const base::WeakPtr<InputServiceProxy>& proxy) {
  23     DCHECK(CalledOnValidThread());
  24     InputServiceLinux::GetInstance()->AddObserver(this);
  25     proxy_ = proxy;
  26   }
  27
  28   void Shutdown() {
  29     DCHECK(CalledOnValidThread());
  30     if (InputServiceLinux::HasInstance())
  31       InputServiceLinux::GetInstance()->RemoveObserver(this);
  32     delete this;
  33   }
  34
  35   std::vector<InputDeviceInfo> GetDevices() {
  36     DCHECK(CalledOnValidThread());
  37     std::vector<InputDeviceInfo> devices;
  38     if (InputServiceLinux::HasInstance())
  39       InputServiceLinux::GetInstance()->GetDevices(&devices);
  40     return devices;
  41   }
  42
  43   void GetDeviceInfo(const std::string& id,
  44                      const InputServiceProxy::GetDeviceInfoCallback& callback) {
  45     DCHECK(CalledOnValidThread());
  46     bool success = false;
  47     InputDeviceInfo info;
  48     info.id = id;
  49     if (InputServiceLinux::HasInstance())
  50       success = InputServiceLinux::GetInstance()->GetDeviceInfo(id, &info);
  51     BrowserThread::PostTask(
  52         BrowserThread::UI, FROM_HERE, base::Bind(callback, success, info));
  53   }
  54
  55   // InputServiceLinux::Observer implementation:
  56   virtual void OnInputDeviceAdded(
  57       const InputServiceLinux::InputDeviceInfo& info) OVERRIDE {
  58     DCHECK(CalledOnValidThread());
  59     BrowserThread::PostTask(
  60         BrowserThread::UI,
  61         FROM_HERE,
  62         base::Bind(&InputServiceProxy::OnDeviceAdded, proxy_, info));
  63   }
  64
  65   virtual void OnInputDeviceRemoved(const std::string& id) OVERRIDE {
  66     DCHECK(CalledOnValidThread());
  67     BrowserThread::PostTask(
  68         BrowserThread::UI,
  69         FROM_HERE,
  70         base::Bind(&InputServiceProxy::OnDeviceRemoved, proxy_, id));
  71   }
  72
  73  private:
  74   bool CalledOnValidThread() const {
  75     return BrowserThread::CurrentlyOn(BrowserThread::FILE);
  76   }
  77
  78   base::WeakPtr<InputServiceProxy> proxy_;
  79
  80   DISALLOW_COPY_AND_ASSIGN(ServiceObserver);
  81 };
  82
  83 InputServiceProxy::InputServiceProxy()
  84     : service_observer_(new ServiceObserver()), weak_factory_(this) {
  85   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  86   BrowserThread::PostTask(
  87       BrowserThread::FILE,
  88       FROM_HERE,
  89       base::Bind(&InputServiceProxy::ServiceObserver::Initialize,
  90                  base::Unretained(service_observer_.get()),
  91                  weak_factory_.GetWeakPtr()));
  92 }
  93
  94 InputServiceProxy::~InputServiceProxy() {
  95   DCHECK(thread_checker_.CalledOnValidThread());
  96   BrowserThread::PostTask(
  97       BrowserThread::FILE,
  98       FROM_HERE,
  99       base::Bind(&InputServiceProxy::ServiceObserver::Shutdown,
 100                  base::Unretained(service_observer_.release())));
 101 }
 102
 103 void InputServiceProxy::AddObserver(Observer* observer) {
 104   DCHECK(thread_checker_.CalledOnValidThread());
 105   if (observer)
 106     observers_.AddObserver(observer);
 107 }
 108
 109 void InputServiceProxy::RemoveObserver(Observer* observer) {
 110   DCHECK(thread_checker_.CalledOnValidThread());
 111   if (observer)
 112     observers_.RemoveObserver(observer);
 113 }
 114
 115 void InputServiceProxy::GetDevices(const GetDevicesCallback& callback) {
 116   DCHECK(thread_checker_.CalledOnValidThread());
 117   BrowserThread::PostTaskAndReplyWithResult(
 118       BrowserThread::FILE,
 119       FROM_HERE,
 120       base::Bind(&InputServiceProxy::ServiceObserver::GetDevices,
 121                  base::Unretained(service_observer_.get())),
 122       callback);
 123 }
 124
 125 void InputServiceProxy::GetDeviceInfo(const std::string& id,
 126                                       const GetDeviceInfoCallback& callback) {
 127   DCHECK(thread_checker_.CalledOnValidThread());
 128   BrowserThread::PostTask(
 129       BrowserThread::FILE,
 130       FROM_HERE,
 131       base::Bind(&InputServiceProxy::ServiceObserver::GetDeviceInfo,
 132                  base::Unretained(service_observer_.release()),
 133                  id,
 134                  callback));
 135 }
 136
 137 void InputServiceProxy::OnDeviceAdded(
 138     const InputServiceLinux::InputDeviceInfo& info) {
 139   DCHECK(thread_checker_.CalledOnValidThread());
 140   FOR_EACH_OBSERVER(Observer, observers_, OnInputDeviceAdded(info));
 141 }
 142
 143 void InputServiceProxy::OnDeviceRemoved(const std::string& id) {
 144   DCHECK(thread_checker_.CalledOnValidThread());
 145   FOR_EACH_OBSERVER(Observer, observers_, OnInputDeviceRemoved(id));
 146 }
 147
 148 }  // namespace chromeos