src/device/hid/hid_connection_win.cc

   1 // Copyright (c) 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 "device/hid/hid_connection_win.h"
   6
   7 #include <cstring>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/win/object_watcher.h"
  13
  14 #define INITGUID
  15
  16 #include <windows.h>
  17 #include <hidclass.h>
  18
  19 extern "C" {
  20 #include <hidsdi.h>
  21 }
  22
  23 #include <setupapi.h>
  24 #include <winioctl.h>
  25
  26 namespace device {
  27
  28 struct PendingHidTransfer : public base::RefCounted<PendingHidTransfer>,
  29                             public base::win::ObjectWatcher::Delegate,
  30                             public base::MessageLoop::DestructionObserver {
  31   typedef base::Callback<void(PendingHidTransfer*, bool)> Callback;
  32
  33   PendingHidTransfer(scoped_refptr<net::IOBuffer> buffer,
  34                      const Callback& callback);
  35
  36   void TakeResultFromWindowsAPI(BOOL result);
  37
  38   OVERLAPPED* GetOverlapped() { return &overlapped_; }
  39
  40   // Implements base::win::ObjectWatcher::Delegate.
  41   virtual void OnObjectSignaled(HANDLE object) OVERRIDE;
  42
  43   // Implements base::MessageLoop::DestructionObserver
  44   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
  45
  46   // The buffer isn't used by this object but it's important that a reference
  47   // to it is held until the transfer completes.
  48   scoped_refptr<net::IOBuffer> buffer_;
  49   Callback callback_;
  50   OVERLAPPED overlapped_;
  51   base::win::ScopedHandle event_;
  52   base::win::ObjectWatcher watcher_;
  53
  54  private:
  55   friend class base::RefCounted<PendingHidTransfer>;
  56
  57   virtual ~PendingHidTransfer();
  58
  59   DISALLOW_COPY_AND_ASSIGN(PendingHidTransfer);
  60 };
  61
  62 PendingHidTransfer::PendingHidTransfer(
  63     scoped_refptr<net::IOBuffer> buffer,
  64     const PendingHidTransfer::Callback& callback)
  65     : buffer_(buffer),
  66       callback_(callback),
  67       event_(CreateEvent(NULL, FALSE, FALSE, NULL)) {
  68   memset(&overlapped_, 0, sizeof(OVERLAPPED));
  69   overlapped_.hEvent = event_.Get();
  70 }
  71
  72 PendingHidTransfer::~PendingHidTransfer() {
  73   base::MessageLoop::current()->RemoveDestructionObserver(this);
  74 }
  75
  76 void PendingHidTransfer::TakeResultFromWindowsAPI(BOOL result) {
  77   if (result) {
  78     callback_.Run(this, true);
  79   } else if (GetLastError() == ERROR_IO_PENDING) {
  80     base::MessageLoop::current()->AddDestructionObserver(this);
  81     AddRef();
  82     watcher_.StartWatching(event_.Get(), this);
  83   } else {
  84     VPLOG(1) << "HID transfer failed";
  85     callback_.Run(this, false);
  86   }
  87 }
  88
  89 void PendingHidTransfer::OnObjectSignaled(HANDLE event_handle) {
  90   callback_.Run(this, true);
  91   Release();
  92 }
  93
  94 void PendingHidTransfer::WillDestroyCurrentMessageLoop() {
  95   watcher_.StopWatching();
  96   callback_.Run(this, false);
  97 }
  98
  99 HidConnectionWin::HidConnectionWin(const HidDeviceInfo& device_info)
 100     : HidConnection(device_info) {
 101   file_.Set(CreateFileA(device_info.device_id.c_str(),
 102                         GENERIC_WRITE | GENERIC_READ,
 103                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 104                         NULL,
 105                         OPEN_EXISTING,
 106                         FILE_FLAG_OVERLAPPED,
 107                         NULL));
 108
 109   if (!file_.IsValid() &&
 110       GetLastError() == base::File::FILE_ERROR_ACCESS_DENIED) {
 111     file_.Set(CreateFileA(device_info.device_id.c_str(),
 112                           GENERIC_READ,
 113                           FILE_SHARE_READ,
 114                           NULL,
 115                           OPEN_EXISTING,
 116                           FILE_FLAG_OVERLAPPED,
 117                           NULL));
 118   }
 119 }
 120
 121 HidConnectionWin::~HidConnectionWin() {
 122 }
 123
 124 void HidConnectionWin::PlatformClose() {
 125   CancelIo(file_.Get());
 126 }
 127
 128 void HidConnectionWin::PlatformRead(
 129     const HidConnection::ReadCallback& callback) {
 130   // Windows will always include the report ID (including zero if report IDs
 131   // are not in use) in the buffer.
 132   scoped_refptr<net::IOBufferWithSize> buffer =
 133       new net::IOBufferWithSize(device_info().max_input_report_size + 1);
 134   scoped_refptr<PendingHidTransfer> transfer(new PendingHidTransfer(
 135       buffer,
 136       base::Bind(&HidConnectionWin::OnReadComplete, this, buffer, callback)));
 137   transfers_.insert(transfer);
 138   transfer->TakeResultFromWindowsAPI(
 139       ReadFile(file_.Get(),
 140                buffer->data(),
 141                static_cast<DWORD>(buffer->size()),
 142                NULL,
 143                transfer->GetOverlapped()));
 144 }
 145
 146 void HidConnectionWin::PlatformWrite(scoped_refptr<net::IOBuffer> buffer,
 147                                      size_t size,
 148                                      const WriteCallback& callback) {
 149   // The Windows API always wants either a report ID (if supported) or
 150   // zero at the front of every output report.
 151   scoped_refptr<PendingHidTransfer> transfer(new PendingHidTransfer(
 152       buffer, base::Bind(&HidConnectionWin::OnWriteComplete, this, callback)));
 153   transfers_.insert(transfer);
 154   transfer->TakeResultFromWindowsAPI(WriteFile(file_.Get(),
 155                                                buffer->data(),
 156                                                static_cast<DWORD>(size),
 157                                                NULL,
 158                                                transfer->GetOverlapped()));
 159 }
 160
 161 void HidConnectionWin::PlatformGetFeatureReport(uint8_t report_id,
 162                                                 const ReadCallback& callback) {
 163   // The first byte of the destination buffer is the report ID being requested.
 164   scoped_refptr<net::IOBufferWithSize> buffer =
 165       new net::IOBufferWithSize(device_info().max_feature_report_size + 1);
 166   buffer->data()[0] = report_id;
 167
 168   scoped_refptr<PendingHidTransfer> transfer(new PendingHidTransfer(
 169       buffer,
 170       base::Bind(
 171           &HidConnectionWin::OnReadFeatureComplete, this, buffer, callback)));
 172   transfers_.insert(transfer);
 173   transfer->TakeResultFromWindowsAPI(
 174       DeviceIoControl(file_.Get(),
 175                       IOCTL_HID_GET_FEATURE,
 176                       NULL,
 177                       0,
 178                       buffer->data(),
 179                       static_cast<DWORD>(buffer->size()),
 180                       NULL,
 181                       transfer->GetOverlapped()));
 182 }
 183
 184 void HidConnectionWin::PlatformSendFeatureReport(
 185     scoped_refptr<net::IOBuffer> buffer,
 186     size_t size,
 187     const WriteCallback& callback) {
 188   // The Windows API always wants either a report ID (if supported) or
 189   // zero at the front of every output report.
 190   scoped_refptr<PendingHidTransfer> transfer(new PendingHidTransfer(
 191       buffer, base::Bind(&HidConnectionWin::OnWriteComplete, this, callback)));
 192   transfer->TakeResultFromWindowsAPI(
 193       DeviceIoControl(file_.Get(),
 194                       IOCTL_HID_SET_FEATURE,
 195                       buffer->data(),
 196                       static_cast<DWORD>(size),
 197                       NULL,
 198                       0,
 199                       NULL,
 200                       transfer->GetOverlapped()));
 201 }
 202
 203 void HidConnectionWin::OnReadComplete(scoped_refptr<net::IOBuffer> buffer,
 204                                       const ReadCallback& callback,
 205                                       PendingHidTransfer* transfer,
 206                                       bool signaled) {
 207   if (!signaled) {
 208     callback.Run(false, NULL, 0);
 209     return;
 210   }
 211
 212   DWORD bytes_transferred;
 213   if (GetOverlappedResult(
 214           file_, transfer->GetOverlapped(), &bytes_transferred, FALSE)) {
 215     CompleteRead(buffer, bytes_transferred, callback);
 216   } else {
 217     VPLOG(1) << "HID read failed";
 218     callback.Run(false, NULL, 0);
 219   }
 220 }
 221
 222 void HidConnectionWin::OnReadFeatureComplete(
 223     scoped_refptr<net::IOBuffer> buffer,
 224     const ReadCallback& callback,
 225     PendingHidTransfer* transfer,
 226     bool signaled) {
 227   if (!signaled) {
 228     callback.Run(false, NULL, 0);
 229     return;
 230   }
 231
 232   DWORD bytes_transferred;
 233   if (GetOverlappedResult(
 234           file_, transfer->GetOverlapped(), &bytes_transferred, FALSE)) {
 235     scoped_refptr<net::IOBuffer> new_buffer(
 236         new net::IOBuffer(bytes_transferred - 1));
 237     memcpy(new_buffer->data(), buffer->data() + 1, bytes_transferred - 1);
 238     CompleteRead(new_buffer, bytes_transferred, callback);
 239   } else {
 240     VPLOG(1) << "HID read failed";
 241     callback.Run(false, NULL, 0);
 242   }
 243 }
 244
 245 void HidConnectionWin::OnWriteComplete(const WriteCallback& callback,
 246                                        PendingHidTransfer* transfer,
 247                                        bool signaled) {
 248   if (!signaled) {
 249     callback.Run(false);
 250     return;
 251   }
 252
 253   DWORD bytes_transferred;
 254   if (GetOverlappedResult(
 255           file_, transfer->GetOverlapped(), &bytes_transferred, FALSE)) {
 256     callback.Run(true);
 257   } else {
 258     VPLOG(1) << "HID write failed";
 259     callback.Run(false);
 260   }
 261 }
 262
 263 }  // namespace device