1) Add basic configuration (network connection, language, keyboard layout, timezone) setup page. 2)…

components/pairing/bluetooth_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/bluetooth_host_pairing_controller.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "components/pairing/bluetooth_pairing_constants.h"
 #include "components/pairing/pairing_api.pb.h"
 #include "components/pairing/proto_decoder.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "net/base/io_buffer.h"
 
 namespace pairing_chromeos {
 
 namespace {
 const int kReceiveSize = 16384;
 
+pairing_api::HostStatusParameters::Connectivity PairingApiConnectivityStatus(
+    HostPairingController::Connectivity connectivity_status) {
+  switch (connectivity_status) {
+    case HostPairingController::CONNECTIVITY_UNTESTED:
+      return pairing_api::HostStatusParameters::CONNECTIVITY_UNTESTED;
+    case HostPairingController::CONNECTIVITY_NONE:
+      return pairing_api::HostStatusParameters::CONNECTIVITY_NONE;
+    case HostPairingController::CONNECTIVITY_LIMITED:
+      return pairing_api::HostStatusParameters::CONNECTIVITY_LIMITED;
+    case HostPairingController::CONNECTIVITY_CONNECTING:
+      return pairing_api::HostStatusParameters::CONNECTIVITY_CONNECTING;
+    case HostPairingController::CONNECTIVITY_CONNECTED:
+      return pairing_api::HostStatusParameters::CONNECTIVITY_CONNECTED;
+    default:
+      NOTREACHED();
+      return pairing_api::HostStatusParameters::CONNECTIVITY_UNTESTED;
+  }
+}
+
 pairing_api::HostStatusParameters::UpdateStatus PairingApiUpdateStatus(
     HostPairingController::UpdateStatus update_status) {
   switch(update_status) {
     case HostPairingController::UPDATE_STATUS_UNKNOWN:
       return pairing_api::HostStatusParameters::UPDATE_STATUS_UNKNOWN;
     case HostPairingController::UPDATE_STATUS_UPDATING:
       return pairing_api::HostStatusParameters::UPDATE_STATUS_UPDATING;
     case HostPairingController::UPDATE_STATUS_REBOOTING:
       return pairing_api::HostStatusParameters::UPDATE_STATUS_REBOOTING;
     case HostPairingController::UPDATE_STATUS_UPDATED:
@@ skipping 18 matching lines @@
     default:
       NOTREACHED();
       return pairing_api::HostStatusParameters::ENROLLMENT_STATUS_UNKNOWN;
   }
 }
 
 }  // namespace
 
 BluetoothHostPairingController::BluetoothHostPairingController()
     : current_stage_(STAGE_NONE),
+      connectivity_status_(CONNECTIVITY_UNTESTED),
       update_status_(UPDATE_STATUS_UNKNOWN),
       enrollment_status_(ENROLLMENT_STATUS_UNKNOWN),
       proto_decoder_(new ProtoDecoder(this)),
-      ptr_factory_(this) {
-}
+      ptr_factory_(this) {}
 
 BluetoothHostPairingController::~BluetoothHostPairingController() {
   Reset();
   if (adapter_.get()) {
     if (adapter_->IsDiscoverable()) {
       adapter_->SetDiscoverable(false, base::Closure(), base::Closure());
     }
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
@@ skipping 11 matching lines @@
   pairing_api::HostStatus host_status;
 
   host_status.set_api_version(kPairingAPIVersion);
   if (!enrollment_domain_.empty())
     host_status.mutable_parameters()->set_domain(enrollment_domain_);
   if (!permanent_id_.empty())
     host_status.mutable_parameters()->set_permanent_id(permanent_id_);
 
   // TODO(zork): Get these values from the UI. (http://crbug.com/405744)
   host_status.mutable_parameters()->set_connectivity(
-      pairing_api::HostStatusParameters::CONNECTIVITY_CONNECTED);
+      PairingApiConnectivityStatus(connectivity_status_));
   host_status.mutable_parameters()->set_update_status(
       PairingApiUpdateStatus(update_status_));
   host_status.mutable_parameters()->set_enrollment_status(
       PairingApiEnrollmentStatus(enrollment_status_));
 
   // TODO(zork): Get a list of other paired controllers.
   // (http://crbug.com/405757)
 
   int size = 0;
   scoped_refptr<net::IOBuffer> io_buffer(
@@ skipping 195 matching lines @@
   LOG(ERROR) << reason << ", " << error_message;
 }
 
 void BluetoothHostPairingController::OnHostStatusMessage(
     const pairing_api::HostStatus& message) {
   NOTREACHED();
 }
 
 void BluetoothHostPairingController::OnConfigureHostMessage(
     const pairing_api::ConfigureHost& message) {
+  ChangeStage(STAGE_SETUP_BASIC_CONFIGURATION);
   FOR_EACH_OBSERVER(Observer, observers_,
                     ConfigureHostRequested(
                         message.parameters().accepted_eula(),
                         message.parameters().lang(),
                         message.parameters().timezone(),
                         message.parameters().send_reports(),
                         message.parameters().keyboard_layout()));
 }
 
 void BluetoothHostPairingController::OnPairDevicesMessage(
@@ skipping 72 matching lines @@
 
 std::string BluetoothHostPairingController::GetConfirmationCode() {
   DCHECK_EQ(current_stage_, STAGE_WAITING_FOR_CODE_CONFIRMATION);
   return confirmation_code_;
 }
 
 std::string BluetoothHostPairingController::GetEnrollmentDomain() {
   return enrollment_domain_;
 }
 
+void BluetoothHostPairingController::OnNetworkConnectivityChanged(
+    Connectivity connectivity_status) {
+  connectivity_status_ = connectivity_status;
+  if (connectivity_status == CONNECTIVITY_NONE)
+    ChangeStage(STAGE_SETUP_NETWORK_ERROR);
+  SendHostStatus();
+}
+
 void BluetoothHostPairingController::OnUpdateStatusChanged(
     UpdateStatus update_status) {
   update_status_ = update_status;
   if (update_status == UPDATE_STATUS_UPDATED)
     ChangeStage(STAGE_WAITING_FOR_CREDENTIALS);
   SendHostStatus();
 }
 
 void BluetoothHostPairingController::OnEnrollmentStatusChanged(
     EnrollmentStatus enrollment_status) {
@@ skipping 62 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos