components/pairing/fake_host_pairing_controller.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 "components/pairing/fake_host_pairing_controller.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/rand_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_split.h"
  16
  17 namespace {
  18
  19 const int kDefaultAsyncDurationMs = 3000;
  20 const size_t kCodeLength = 6;
  21
  22 }  // namespace
  23
  24 namespace pairing_chromeos {
  25
  26 FakeHostPairingController::FakeHostPairingController(const std::string& config)
  27     : current_stage_(STAGE_NONE),
  28       enrollment_should_fail_(false),
  29       start_after_update_(false) {
  30   ApplyConfig(config);
  31   AddObserver(this);
  32 }
  33
  34 FakeHostPairingController::~FakeHostPairingController() {
  35   RemoveObserver(this);
  36 }
  37
  38 void FakeHostPairingController::ApplyConfig(const std::string& config) {
  39   base::StringPairs kv_pairs;
  40   CHECK(base::SplitStringIntoKeyValuePairs(config, ':', ',', &kv_pairs))
  41       << "Wrong config format.";
  42   std::map<std::string, std::string> dict(kv_pairs.begin(), kv_pairs.end());
  43
  44   if (dict.count("async_duration")) {
  45     int ms = 0;
  46     CHECK(base::StringToInt(dict["async_duration"], &ms))
  47         << "Wrong 'async_duration' format.";
  48     async_duration_ = base::TimeDelta::FromMilliseconds(ms);
  49   } else {
  50     async_duration_ =
  51       base::TimeDelta::FromMilliseconds(kDefaultAsyncDurationMs);
  52   }
  53
  54   start_after_update_ = dict["start_after_update"] == "1";
  55
  56   enrollment_should_fail_ = dict["fail_enrollment"] == "1";
  57
  58   if (dict.count("code")) {
  59     confirmation_code_ = dict["code"];
  60   } else {
  61     confirmation_code_.clear();
  62     for (size_t i = 0; i < kCodeLength; ++i)
  63       confirmation_code_.push_back(base::RandInt('0', '9'));
  64   }
  65   CHECK(confirmation_code_.length() == kCodeLength &&
  66         confirmation_code_.find_first_not_of("0123456789") == std::string::npos)
  67       << "Wrong 'code' format.";
  68
  69   device_name_ =
  70       dict.count("device_name") ? dict["device_name"] : "Chromebox-01";
  71
  72   enrollment_domain_ = dict.count("domain") ? dict["domain"] : "example.com";
  73 }
  74
  75 void FakeHostPairingController::ChangeStage(Stage new_stage) {
  76   if (current_stage_ == new_stage)
  77     return;
  78   current_stage_ = new_stage;
  79   FOR_EACH_OBSERVER(Observer, observers_, PairingStageChanged(new_stage));
  80 }
  81
  82 void FakeHostPairingController::ChangeStageLater(Stage new_stage) {
  83   base::MessageLoop::current()->PostDelayedTask(
  84       FROM_HERE,
  85       base::Bind(&FakeHostPairingController::ChangeStage,
  86                  base::Unretained(this),
  87                  new_stage),
  88       async_duration_);
  89 }
  90
  91 void FakeHostPairingController::AddObserver(Observer* observer) {
  92   observers_.AddObserver(observer);
  93 }
  94
  95 void FakeHostPairingController::RemoveObserver(Observer* observer) {
  96   observers_.RemoveObserver(observer);
  97 }
  98
  99 HostPairingController::Stage FakeHostPairingController::GetCurrentStage() {
 100   return current_stage_;
 101 }
 102
 103 void FakeHostPairingController::StartPairing() {
 104   CHECK(current_stage_ == STAGE_NONE);
 105   if (start_after_update_) {
 106     ChangeStage(STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE);
 107   } else {
 108     ChangeStage(STAGE_WAITING_FOR_CONTROLLER);
 109   }
 110 }
 111
 112 std::string FakeHostPairingController::GetDeviceName() {
 113   return device_name_;
 114 }
 115
 116 std::string FakeHostPairingController::GetConfirmationCode() {
 117   CHECK(current_stage_ == STAGE_WAITING_FOR_CODE_CONFIRMATION);
 118   return confirmation_code_;
 119 }
 120
 121 std::string FakeHostPairingController::GetEnrollmentDomain() {
 122   return enrollment_domain_;
 123 }
 124
 125 void FakeHostPairingController::OnUpdateStatusChanged(
 126     UpdateStatus update_status) {
 127 }
 128
 129 void FakeHostPairingController::OnEnrollmentStatusChanged(
 130     EnrollmentStatus enrollment_status) {
 131 }
 132
 133 void FakeHostPairingController::PairingStageChanged(Stage new_stage) {
 134   switch (new_stage) {
 135     case STAGE_WAITING_FOR_CONTROLLER: {
 136       ChangeStageLater(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 137       break;
 138     }
 139     case STAGE_WAITING_FOR_CODE_CONFIRMATION: {
 140       ChangeStageLater(STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE);
 141       break;
 142     }
 143     case STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE: {
 144       ChangeStageLater(STAGE_WAITING_FOR_CREDENTIALS);
 145       break;
 146     }
 147     case STAGE_WAITING_FOR_CREDENTIALS: {
 148       ChangeStageLater(STAGE_ENROLLING);
 149       break;
 150     }
 151     case STAGE_ENROLLING: {
 152       if (enrollment_should_fail_) {
 153         enrollment_should_fail_ = false;
 154         ChangeStageLater(STAGE_ENROLLMENT_ERROR);
 155       } else {
 156         ChangeStageLater(STAGE_ENROLLMENT_SUCCESS);
 157       }
 158       break;
 159     }
 160     case STAGE_ENROLLMENT_ERROR: {
 161       ChangeStageLater(STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE);
 162       break;
 163     }
 164     case STAGE_ENROLLMENT_SUCCESS: {
 165       ChangeStageLater(STAGE_FINISHED);
 166       break;
 167     }
 168     default: { break; }
 169   }
 170 }
 171
 172 void FakeHostPairingController::ConfigureHost(
 173     bool accepted_eula,
 174     const std::string& lang,
 175     const std::string& timezone,
 176     bool send_reports,
 177     const std::string& keyboard_layout) {
 178 }
 179
 180 void FakeHostPairingController::EnrollHost(const std::string& auth_token) {
 181 }
 182
 183 }  // namespace pairing_chromeos