Update the pairing API to include configuration and enrollment.

components/pairing/fake_host_pairing_controller.cc

 // Copyright 2014 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 "components/pairing/fake_host_pairing_controller.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 
 namespace {
 
-const int kUpdateStepsNumber = 10;
 const int kDefaultAsyncDurationMs = 3000;
 const size_t kCodeLength = 6;
 
 }  // namespace
 
 namespace pairing_chromeos {
 
 FakeHostPairingController::FakeHostPairingController(const std::string& config)
     : current_stage_(STAGE_NONE),
       enrollment_should_fail_(false),
@@ skipping 54 matching lines @@
 
 void FakeHostPairingController::ChangeStageLater(Stage new_stage) {
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeHostPairingController::ChangeStage,
                  base::Unretained(this),
                  new_stage),
       async_duration_);
 }
 
-void FakeHostPairingController::SetUpdateProgress(int step) {
-  UpdateProgress progress;
-  progress.progress = double(step) / kUpdateStepsNumber;
-  FOR_EACH_OBSERVER(Observer, observers_, UpdateAdvanced(progress));
-  base::Closure task;
-  if (step >= kUpdateStepsNumber) {
-    task = base::Bind(&FakeHostPairingController::ChangeStage,
-                      base::Unretained(this),
-                      STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE);
-  } else {
-    task = base::Bind(&FakeHostPairingController::SetUpdateProgress,
-                      base::Unretained(this),
-                      step + 1);
-  }
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, task, async_duration_ / kUpdateStepsNumber);
-}
-
 void FakeHostPairingController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeHostPairingController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 HostPairingController::Stage FakeHostPairingController::GetCurrentStage() {
   return current_stage_;
@@ skipping 14 matching lines @@
 
 std::string FakeHostPairingController::GetConfirmationCode() {
   CHECK(current_stage_ == STAGE_WAITING_FOR_CODE_CONFIRMATION);
   return confirmation_code_;
 }
 
 std::string FakeHostPairingController::GetEnrollmentDomain() {
   return enrollment_domain_;
 }
 
+void FakeHostPairingController::OnUpdateStatusChanged(
+    UpdateStatus update_status) {
+}
+
 void FakeHostPairingController::PairingStageChanged(Stage new_stage) {
   switch (new_stage) {
     case STAGE_WAITING_FOR_CONTROLLER: {
       ChangeStageLater(STAGE_WAITING_FOR_CODE_CONFIRMATION);
       break;
     }
     case STAGE_WAITING_FOR_CODE_CONFIRMATION: {
       ChangeStageLater(STAGE_UPDATING);
       break;
     }
     case STAGE_UPDATING: {
-      SetUpdateProgress(0);
+      ChangeStageLater(STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE);
       break;
     }
     case STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE: {
       ChangeStageLater(STAGE_WAITING_FOR_CREDENTIALS);
       break;
     }
     case STAGE_WAITING_FOR_CREDENTIALS: {
       ChangeStageLater(STAGE_ENROLLING);
       break;
     }
@@ skipping 11 matching lines @@
       break;
     }
     case STAGE_PAIRING_DONE: {
       ChangeStageLater(STAGE_FINISHED);
       break;
     }
     default: { break; }
   }
 }
 
-void FakeHostPairingController::UpdateAdvanced(const UpdateProgress& progress) {
+void FakeHostPairingController::ConfigureHost(
+    bool accepted_eula,
+    const std::string& lang,
+    const std::string& timezone,
+    bool send_reports,
+    const std::string& keyboard_layout) {
+}
+
+void FakeHostPairingController::EnrollHost(const std::string& auth_token) {
 }
 
 }  // namespace pairing_chromeos