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