Redirect to the enterprise enrollment screen during remora and shark pairing

chrome/browser/chromeos/login/enrollment/enrollment_screen.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/screen_manager.h"
 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/auto_enrollment_client.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_initializer.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
+#include "components/pairing/controller_pairing_controller.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "policy/proto/device_management_backend.pb.h"
 
+using namespace pairing_chromeos;
+
 namespace chromeos {
 
 // static
 EnrollmentScreen* EnrollmentScreen::Get(ScreenManager* manager) {
   return static_cast<EnrollmentScreen*>(
       manager->GetScreen(WizardController::kEnrollmentScreenName));
 }
 
 EnrollmentScreen::EnrollmentScreen(
     ScreenObserver* observer,
     EnrollmentScreenActor* actor)
     : WizardScreen(observer),
+      shark_controller_(NULL),
+      remora_controller_(NULL),
       actor_(actor),
       enrollment_mode_(EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL),
       enrollment_failed_once_(false),
       remora_token_sent_(false),
       lockbox_init_duration_(0),
       weak_ptr_factory_(this) {
   // Init the TPM if it has not been done until now (in debug build we might
   // have not done that yet).
   DBusThreadManager::Get()->GetCryptohomeClient()->TpmCanAttemptOwnership(
       EmptyVoidDBusMethodCallback());
 }
 
-EnrollmentScreen::~EnrollmentScreen() {}
+EnrollmentScreen::~EnrollmentScreen() {
+  if (remora_controller_) {
+    remora_controller_->RemoveObserver(this);
+  }
+}
 
 void EnrollmentScreen::SetParameters(
     EnrollmentScreenActor::EnrollmentMode enrollment_mode,
     const std::string& management_domain,
     const std::string& user,
-    const std::string& auth_token) {
+    const std::string& auth_token,
+    pairing_chromeos::ControllerPairingController* shark_controller,
+    pairing_chromeos::HostPairingController* remora_controller) {
   enrollment_mode_ = enrollment_mode;
   user_ = user.empty() ? user : gaia::CanonicalizeEmail(user);
   auth_token_ = auth_token;
+  shark_controller_ = shark_controller;
+  DCHECK(!remora_controller_);
+  remora_controller_ = remora_controller;
+  if (remora_controller_) {
+    remora_controller_->AddObserver(this);
+  }
   actor_->SetParameters(this, enrollment_mode_, management_domain);
 }
 
 void EnrollmentScreen::PrepareToShow() {
   actor_->PrepareToShow();
 }
 
 void EnrollmentScreen::Show() {
   if (is_auto_enrollment() && !enrollment_failed_once_) {
     actor_->Show();
@@ skipping 13 matching lines @@
 
 void EnrollmentScreen::Hide() {
   actor_->Hide();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 std::string EnrollmentScreen::GetName() const {
   return WizardController::kEnrollmentScreenName;
 }
 
+void EnrollmentScreen::PairingStageChanged(Stage new_stage) {
+  switch (new_stage) {
+    case HostPairingController::STAGE_NONE:
+    case HostPairingController::STAGE_INITIALIZATION_ERROR:
+    case HostPairingController::STAGE_WAITING_FOR_CONTROLLER:
+    case HostPairingController::STAGE_WAITING_FOR_CONTROLLER_AFTER_UPDATE:
+    case HostPairingController::STAGE_WAITING_FOR_CODE_CONFIRMATION:
+    case HostPairingController::STAGE_UPDATING:
+    case HostPairingController::STAGE_WAITING_FOR_CREDENTIALS:
+    case HostPairingController::STAGE_ENROLLING:

[dzhioev (left Google), 2014/09/09 01:58:09]

nit: you can replace all these cases with a single "default" section.

[Zachary Kuznia, 2014/09/09 02:17:51]

When switching on enums, I leave off the default case so that the compiler will
catch missing statements.

+      NOTREACHED();
+      break;
+
+    case HostPairingController::STAGE_ENROLLMENT_ERROR:
+    case HostPairingController::STAGE_PAIRING_DONE:
+      break;
+
+    case HostPairingController::STAGE_FINISHED: {
+      remora_controller_->RemoveObserver(this);
+      remora_controller_ = NULL;
+      get_screen_observer()->OnExit(
+          WizardController::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);

[dzhioev (left Google), 2014/09/09 01:35:40]

a) Why do you use ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED code?
b) Shouldn't we just reboot host at this point? 

[Zachary Kuznia, 2014/09/09 02:17:51]

a: I reused the exit code from elsewhere in this file that fit our use case.
b: I don't think we need the reboot until we fix the flow to defer the update.

[dzhioev (left Google), 2014/09/09 02:46:50]

What do you see on host's screen after enrollment is done? I thought our case is
to reboot and launch a kiosk app.

[Zachary Kuznia, 2014/09/09 23:53:58]

After enrollment, the host launches Hangouts.

achuith: Is this the proper exit status to use here, or is something else
better?

[achuithb, 2014/09/10 08:04:20]

We can do this, or use ENTERPRISE_ENROLLMENT_COMPLETED, or have a new enum for
the purpose of this remote remora enrollment. This particular enum is used for
forced re-enrollment. I think it's fine to use here for now. You could also ask
Bartosz if he has an opinion on this. 

[Zachary Kuznia, 2014/09/10 15:57:25]

Ok, I'll leave this as is for now.  I've filed a bug and added a comment.

+      break;
+    }
+  }
+}
+
+void EnrollmentScreen::ConfigureHost(bool accepted_eula,
+                                     const std::string& lang,
+                                     const std::string& timezone,
+                                     bool send_reports,
+                                     const std::string& keyboard_layout) {
+  // Host configuration should already be complete.
+  NOTREACHED();
+}
+
+void EnrollmentScreen::EnrollHost(const std::string& auth_token) {
+  // Enrollment should already be complete.
+  NOTREACHED();
+}
+
 void EnrollmentScreen::OnLoginDone(const std::string& user) {
   user_ = gaia::CanonicalizeEmail(user);
 
   if (is_auto_enrollment())
     UMA(policy::kMetricEnrollmentAutoRetried);
   else if (enrollment_failed_once_)
     UMA(policy::kMetricEnrollmentRetried);
   else
     UMA(policy::kMetricEnrollmentStarted);
 
@@ skipping 124 matching lines @@
   CHECK(dcp_initializer);
   dcp_initializer->StartEnrollment(
       enterprise_management::PolicyData::ENTERPRISE_MANAGED,
       connector->device_management_service(),
       token, is_auto_enrollment(), device_modes,
       base::Bind(&EnrollmentScreen::ReportEnrollmentStatus,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EnrollmentScreen::SendEnrollmentAuthToken(const std::string& token) {
-  // TODO(achuith, zork): Send token via Bluetooth to remote device.
+  // TODO(achuith, zork): Extract and send domain.
+  if (shark_controller_)
+    shark_controller_->OnAuthenticationDone("", token);
 }
 
 void EnrollmentScreen::ShowEnrollmentStatusOnSuccess(
     const policy::EnrollmentStatus& status) {
   actor_->ShowEnrollmentStatus(status);
   StartupUtils::MarkOobeCompleted();
 }
 
 void EnrollmentScreen::ReportEnrollmentStatus(policy::EnrollmentStatus status) {
   switch (status.status()) {
     case policy::EnrollmentStatus::STATUS_SUCCESS:
       StartupUtils::MarkDeviceRegistered(
           base::Bind(&EnrollmentScreen::ShowEnrollmentStatusOnSuccess,
                      weak_ptr_factory_.GetWeakPtr(),
                      status));
       UMA(is_auto_enrollment() ? policy::kMetricEnrollmentAutoOK
                                : policy::kMetricEnrollmentOK);
+      remora_controller_->SetEnrollmentComplete(true);

[dzhioev (left Google), 2014/09/09 01:35:40]

Why do you assume everywhere that |remora_controller_| is not null?

[Zachary Kuznia, 2014/09/09 02:17:50]

That is a bad assumption on my part.  Fixed.

       return;
     case policy::EnrollmentStatus::STATUS_REGISTRATION_FAILED:
     case policy::EnrollmentStatus::STATUS_POLICY_FETCH_FAILED:
       switch (status.client_status()) {
         case policy::DM_STATUS_SUCCESS:
         case policy::DM_STATUS_REQUEST_INVALID:
         case policy::DM_STATUS_SERVICE_DEVICE_NOT_FOUND:
         case policy::DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID:
         case policy::DM_STATUS_SERVICE_ACTIVATION_PENDING:
         case policy::DM_STATUS_SERVICE_DEVICE_ID_CONFLICT:
@@ skipping 54 matching lines @@
       UMAFailure(policy::kMetricEnrollmentRobotRefreshTokenStoreFailed);
       break;
     case policy::EnrollmentStatus::STATUS_STORE_TOKEN_AND_ID_FAILED:
       // This error should not happen for enterprise enrollment, it only affects
       // consumer enrollment.
       UMAFailure(policy::kMetricEnrollmentStoreTokenAndIdFailed);
       NOTREACHED();
       break;
   }
 
+  remora_controller_->SetEnrollmentComplete(false);
   enrollment_failed_once_ = true;
   actor_->ShowEnrollmentStatus(status);
 }
 
 void EnrollmentScreen::UMA(policy::MetricEnrollment sample) {
   if (enrollment_mode_ == EnrollmentScreenActor::ENROLLMENT_MODE_RECOVERY) {
     UMA_HISTOGRAM_ENUMERATION(policy::kMetricEnrollmentRecovery, sample,
                               policy::kMetricEnrollmentSize);
   } else {
     UMA_HISTOGRAM_ENUMERATION(policy::kMetricEnrollment, sample,
                               policy::kMetricEnrollmentSize);
   }
 }
 
 void EnrollmentScreen::UMAFailure(policy::MetricEnrollment sample) {
   if (is_auto_enrollment())
     sample = policy::kMetricEnrollmentAutoFailed;
   UMA(sample);
 }
 
 void EnrollmentScreen::ShowSigninScreen() {
   actor_->Show();
   actor_->ShowSigninScreen();
 }
 
 }  // namespace chromeos