device/u2f/u2f_request.cc

// Copyright 2017 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 "u2f_request.h"

#include "base/bind.h"
#include "base/memory/ptr_util.h"
#include "base/threading/thread_task_runner_handle.h"
#include "device/base/device_client.h"
#include "u2f_hid_device.h"

namespace device {

U2fRequest::U2fRequest(const ResponseCallback& cb)
    : state_(State::INIT),
      cb_(cb),
      hid_service_observer_(this),
      weak_factory_(this) {
  filter_.SetUsagePage(0xf1d0);
}

void U2fRequest::Transition() {
  switch (state_) {
    case State::IDLE:
      IterateDevice();
      if (!current_device_) {
        // No devices available
        state_ = State::OFF;
        break;
      }
      state_ = State::WINK;
      current_device_->TryWink(
          base::Bind(&U2fRequest::Transition, weak_factory_.GetWeakPtr()));
      break;
    case State::WINK:
      state_ = State::BUSY;
      TryDevice();
    default:
      break;
  }
}

void U2fRequest::Start() {
  if (state_ == State::INIT) {
    state_ = State::BUSY;
    Enumerate();
  }
}

void U2fRequest::Enumerate() {
  HidService* hid_service = DeviceClient::Get()->GetHidService();
  DCHECK(hid_service);
  hid_service_observer_.Add(hid_service);
  hid_service->GetDevices(
      base::Bind(&U2fRequest::OnEnumerate, weak_factory_.GetWeakPtr()));
}

void U2fRequest::OnEnumerate(
    const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
  for (auto device_info : devices) {
    if (filter_.Matches(device_info))
      devices_.push_back(base::MakeUnique<U2fHidDevice>(device_info));
  }

  state_ = State::IDLE;
  Transition();
}

void U2fRequest::OnDeviceAdded(scoped_refptr<HidDeviceInfo> device_info) {
  // Ignore non-U2F devices
  if (!filter_.Matches(device_info))
    return;

  auto device = base::MakeUnique<U2fHidDevice>(device_info);
  AddDevice(std::move(device));
}

void U2fRequest::OnDeviceRemoved(scoped_refptr<HidDeviceInfo> device_info) {
  // Ignore non-U2F devices
  if (!filter_.Matches(device_info))
    return;

  auto device = base::MakeUnique<U2fHidDevice>(device_info);

  // Check if the active device was removed
  if (current_device_ && current_device_->GetId() == device->GetId()) {
    current_device_ = nullptr;
    state_ = State::IDLE;
    Transition();
    return;
  }

  // Remove the device if it exists in either device list
  devices_.remove_if([&device](const std::unique_ptr<U2fDevice>& this_device) {
    return this_device->GetId() == device->GetId();
  });
  attempted_devices_.remove_if(
      [&device](const std::unique_ptr<U2fDevice>& this_device) {
        return this_device->GetId() == device->GetId();
      });
}

void U2fRequest::IterateDevice() {
  // Move active device to attempted device list
  if (current_device_)
    attempted_devices_.push_back(std::move(current_device_));

  // If there is an additional device on device list, make it active.
  // Otherwise, if all devices have been tried, move attempted devices back to
  // the main device list.
  if (devices_.size() > 0) {
    current_device_ = std::move(devices_.front());
    devices_.pop_front();
  } else if (attempted_devices_.size() > 0) {
    devices_ = std::move(attempted_devices_);
    // After trying every device, wait 200ms before trying again
    delay_callback_.Reset(
        base::Bind(&U2fRequest::OnWaitComplete, weak_factory_.GetWeakPtr()));
    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
        FROM_HERE, delay_callback_.callback(),
        base::TimeDelta::FromMilliseconds(200));
  }
}

void U2fRequest::OnWaitComplete() {
  state_ = State::IDLE;
  Transition();
}

void U2fRequest::AddDevice(std::unique_ptr<U2fDevice> device) {
  devices_.push_back(std::move(device));

  // Start the state machine if this is the only device
  if (state_ == State::OFF) {
    state_ = State::IDLE;
    delay_callback_.Cancel();
    Transition();
  }
}

void U2fRequest::AddDeviceForTesting(std::unique_ptr<U2fDevice> device) {
  AddDevice(std::move(device));
}

U2fRequest::~U2fRequest() {}

}  // namespace device