Add an enrolling state for consumer management section in settings page.

chrome/browser/chromeos/policy/consumer_management_service.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 "chrome/browser/chromeos/policy/consumer_management_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chrome_notification_types.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/enrollment_status_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/notifications/notification.h"
+#include "chrome/browser/notifications/notification_delegate.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
@@ skipping 88 matching lines @@
 
 void DesktopNotificationDelegate::Error() {
 }
 
 void DesktopNotificationDelegate::Close(bool by_user) {
 }
 
 void DesktopNotificationDelegate::Click() {
 }
 
+// The string of Status enum.
+const char* kStatusString[] = {
+  "StatusUnknown",
+  "StatusEnrolled",
+  "StatusEnrolling",
+  "StatusUnenrolled",
+  "StatusUnenrolling",
+};
+
+COMPILE_ASSERT(
+    arraysize(kStatusString) == policy::ConsumerManagementService::STATUS_LAST,
+    "invalid kStatusString array size.");
+
 }  // namespace
 
+namespace em = enterprise_management;
+
 namespace policy {
 
 ConsumerManagementService::ConsumerManagementService(
-    chromeos::CryptohomeClient* client)
+    chromeos::CryptohomeClient* client,
+    chromeos::DeviceSettingsService* device_settings_service)
     : Consumer("consumer_management_service"),
       client_(client),
+      device_settings_service_(device_settings_service),
       enrolling_profile_(NULL),
       weak_ptr_factory_(this) {
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                  content::NotificationService::AllSources());
+  // A NULL value may be passed in tests.
+  if (device_settings_service_)
+    device_settings_service_->AddObserver(this);
 }
 
 ConsumerManagementService::~ConsumerManagementService() {
-  registrar_.Remove(this,
-                    chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
-                    content::NotificationService::AllSources());
   if (enrolling_profile_) {
     ProfileOAuth2TokenServiceFactory::GetForProfile(enrolling_profile_)->
         RemoveObserver(this);
   }
+  if (device_settings_service_)
+    device_settings_service_->RemoveObserver(this);
+  registrar_.Remove(this,
+                    chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+                    content::NotificationService::AllSources());
 }
 
 // static
 void ConsumerManagementService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(
-      prefs::kConsumerManagementEnrollmentState, ENROLLMENT_NONE);
+      prefs::kConsumerManagementEnrollmentStage, ENROLLMENT_STAGE_NONE);
 }
 
-ConsumerManagementService::ConsumerEnrollmentState
-ConsumerManagementService::GetEnrollmentState() const {
-  const PrefService* prefs = g_browser_process->local_state();
-  int state = prefs->GetInteger(prefs::kConsumerManagementEnrollmentState);
-  if (state < 0 || state >= ENROLLMENT_LAST) {
-    LOG(ERROR) << "Unknown enrollment state: " << state;
-    state = 0;
-  }
-  return static_cast<ConsumerEnrollmentState>(state);
+void ConsumerManagementService::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
 }
 
-void ConsumerManagementService::SetEnrollmentState(
-    ConsumerEnrollmentState state) {
+void ConsumerManagementService::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+ConsumerManagementService::Status
+ConsumerManagementService::GetStatus() const {
+  if (!device_settings_service_)
+    return STATUS_UNKNOWN;
+
+  const enterprise_management::PolicyData* policy_data =
+      device_settings_service_->policy_data();
+  if (!policy_data)
+    return STATUS_UNKNOWN;
+
+  if (policy_data->management_mode() == em::PolicyData::CONSUMER_MANAGED) {
+    // TODO(davidyu): Check if unenrollment is in progress.
+    // http://crbug.com/353050.
+    return STATUS_ENROLLED;
+  }
+
+  EnrollmentStage stage = GetEnrollmentStage();
+  if (stage > ENROLLMENT_STAGE_NONE && stage < ENROLLMENT_STAGE_SUCCESS)
+    return STATUS_ENROLLING;
+
+  return STATUS_UNENROLLED;
+}
+
+std::string ConsumerManagementService::GetStatusString() const {
+  return kStatusString[GetStatus()];
+}
+
+ConsumerManagementService::EnrollmentStage
+ConsumerManagementService::GetEnrollmentStage() const {
+  const PrefService* prefs = g_browser_process->local_state();
+  int stage = prefs->GetInteger(prefs::kConsumerManagementEnrollmentStage);
+  if (stage < 0 || stage >= ENROLLMENT_STAGE_LAST) {
+    LOG(ERROR) << "Unknown enrollment stage: " << stage;
+    stage = 0;
+  }
+  return static_cast<EnrollmentStage>(stage);
+}
+
+void ConsumerManagementService::SetEnrollmentStage(EnrollmentStage stage) {
   PrefService* prefs = g_browser_process->local_state();
-  prefs->SetInteger(prefs::kConsumerManagementEnrollmentState, state);
+  prefs->SetInteger(prefs::kConsumerManagementEnrollmentStage, stage);
+
+  NotifyStatusChanged();
 }
 
 void ConsumerManagementService::GetOwner(const GetOwnerCallback& callback) {
   cryptohome::GetBootAttributeRequest request;
   request.set_name(kAttributeOwnerId);
   client_->GetBootAttribute(
       request,
       base::Bind(&ConsumerManagementService::OnGetBootAttributeDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ConsumerManagementService::SetOwner(const std::string& user_id,
                                          const SetOwnerCallback& callback) {
   cryptohome::SetBootAttributeRequest request;
   request.set_name(kAttributeOwnerId);
   request.set_value(user_id.data(), user_id.size());
   client_->SetBootAttribute(
       request,
       base::Bind(&ConsumerManagementService::OnSetBootAttributeDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
+void ConsumerManagementService::OwnershipStatusChanged() {
+}
+
+void ConsumerManagementService::DeviceSettingsUpdated() {
+  NotifyStatusChanged();
+}
+
 void ConsumerManagementService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type != chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED) {
     NOTREACHED() << "Unexpected notification " << type;
     return;
   }
 
   Profile* profile = content::Details<Profile>(details).ptr();
@@ skipping 22 matching lines @@
   OnOwnerAccessTokenAvailable(access_token);
 }
 
 void ConsumerManagementService::OnGetTokenFailure(
       const OAuth2TokenService::Request* request,
       const GoogleServiceAuthError& error) {
   DCHECK_EQ(token_request_, request);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, token_request_.release());
 
   LOG(ERROR) << "Failed to get the access token: " << error.ToString();
-  EndEnrollment(ENROLLMENT_GET_TOKEN_FAILED);
+  EndEnrollment(ENROLLMENT_STAGE_GET_TOKEN_FAILED);
 }
 
 void ConsumerManagementService::OnGetBootAttributeDone(
     const GetOwnerCallback& callback,
     chromeos::DBusMethodCallStatus call_status,
     bool dbus_success,
     const cryptohome::BaseReply& reply) {
   if (!dbus_success || reply.error() != 0) {
     LOG(ERROR) << "Failed to get the owner info from boot lockbox.";
     callback.Run("");
@@ skipping 31 matching lines @@
   if (!dbus_success || reply.error() != 0) {
     LOG(ERROR) << "Failed to flush and sign boot lockbox.";
     callback.Run(false);
     return;
   }
 
   callback.Run(true);
 }
 
 void ConsumerManagementService::OnOwnerSignin(Profile* profile) {
-  const ConsumerEnrollmentState state = GetEnrollmentState();
-  switch (state) {
-    case ENROLLMENT_NONE:
+  const EnrollmentStage stage = GetEnrollmentStage();
+  switch (stage) {
+    case ENROLLMENT_STAGE_NONE:
       // Do nothing.
       return;
 
-    case ENROLLMENT_OWNER_STORED:
+    case ENROLLMENT_STAGE_OWNER_STORED:
       // Continue the enrollment process after the owner signs in.
       ContinueEnrollmentProcess(profile);
       return;
 
-    case ENROLLMENT_SUCCESS:
-    case ENROLLMENT_CANCELED:
-    case ENROLLMENT_BOOT_LOCKBOX_FAILED:
-    case ENROLLMENT_DM_SERVER_FAILED:
-    case ENROLLMENT_GET_TOKEN_FAILED:
-      ShowDesktopNotificationAndResetState(state, profile);
+    case ENROLLMENT_STAGE_SUCCESS:
+    case ENROLLMENT_STAGE_CANCELED:
+    case ENROLLMENT_STAGE_BOOT_LOCKBOX_FAILED:
+    case ENROLLMENT_STAGE_DM_SERVER_FAILED:
+    case ENROLLMENT_STAGE_GET_TOKEN_FAILED:
+      ShowDesktopNotificationAndResetStage(stage, profile);
       return;
 
-    case ENROLLMENT_REQUESTED:
-    case ENROLLMENT_LAST:
-      NOTREACHED() << "Unexpected enrollment state " << state;
+    case ENROLLMENT_STAGE_REQUESTED:
+    case ENROLLMENT_STAGE_LAST:
+      NOTREACHED() << "Unexpected enrollment stage " << stage;
       return;
   }
 }
 
 void ConsumerManagementService::ContinueEnrollmentProcess(Profile* profile) {
   enrolling_profile_ = profile;
 
   // First, we need to ensure that the refresh token is available.
   const std::string& account_id = GetAccountIdFromProfile(profile);
   ProfileOAuth2TokenService* token_service =
@@ skipping 41 matching lines @@
 }
 
 void ConsumerManagementService::OnEnrollmentCompleted(EnrollmentStatus status) {
   if (status.status() != EnrollmentStatus::STATUS_SUCCESS) {
     LOG(ERROR) << "Failed to enroll the device."
                << " status=" << status.status()
                << " client_status=" << status.client_status()
                << " http_status=" << status.http_status()
                << " store_status=" << status.store_status()
                << " validation_status=" << status.validation_status();
-    EndEnrollment(ENROLLMENT_DM_SERVER_FAILED);
+    EndEnrollment(ENROLLMENT_STAGE_DM_SERVER_FAILED);
     return;
   }
 
-  EndEnrollment(ENROLLMENT_SUCCESS);
+  EndEnrollment(ENROLLMENT_STAGE_SUCCESS);
 }
 
-void ConsumerManagementService::EndEnrollment(ConsumerEnrollmentState state) {
+void ConsumerManagementService::EndEnrollment(EnrollmentStage stage) {
   Profile* profile = enrolling_profile_;
   enrolling_profile_ = NULL;
 
-  SetEnrollmentState(state);
+  SetEnrollmentStage(stage);
   if (user_manager::UserManager::Get()->IsCurrentUserOwner())
-    ShowDesktopNotificationAndResetState(state, profile);
+    ShowDesktopNotificationAndResetStage(stage, profile);
 }
 
-void ConsumerManagementService::ShowDesktopNotificationAndResetState(
-    ConsumerEnrollmentState state, Profile* profile) {
+void ConsumerManagementService::ShowDesktopNotificationAndResetStage(
+    EnrollmentStage stage, Profile* profile) {
   base::string16 title;
   base::string16 body;
   base::string16 button_label;
   base::Closure button_click_callback;
 
-  if (state == ENROLLMENT_SUCCESS) {
+  if (stage == ENROLLMENT_STAGE_SUCCESS) {
     title = l10n_util::GetStringUTF16(
         IDS_CONSUMER_MANAGEMENT_ENROLLMENT_NOTIFICATION_TITLE);
     body = l10n_util::GetStringUTF16(
         IDS_CONSUMER_MANAGEMENT_ENROLLMENT_NOTIFICATION_BODY);
     button_label = l10n_util::GetStringUTF16(
         IDS_CONSUMER_MANAGEMENT_NOTIFICATION_MODIFY_SETTINGS_BUTTON);
     button_click_callback = base::Bind(
         &ConsumerManagementService::OpenSettingsPage,
         weak_ptr_factory_.GetWeakPtr(),
         profile);
@@ skipping 23 matching lines @@
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  kEnrollmentNotificationId),
       base::string16(),  // display_source
       base::UTF8ToUTF16(kEnrollmentNotificationId),
       optional_field,
       new DesktopNotificationDelegate(kEnrollmentNotificationId,
                                       button_click_callback));
   notification.SetSystemPriority();
   g_browser_process->notification_ui_manager()->Add(notification, profile);
 
-  SetEnrollmentState(ENROLLMENT_NONE);
+  SetEnrollmentStage(ENROLLMENT_STAGE_NONE);
 }
 
 void ConsumerManagementService::OpenSettingsPage(Profile* profile) const {
   const GURL url(chrome::kChromeUISettingsURL);
   chrome::NavigateParams params(profile, url, content::PAGE_TRANSITION_LINK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
 void ConsumerManagementService::TryEnrollmentAgain(Profile* profile) const {
   const GURL base_url(chrome::kChromeUISettingsURL);
   const GURL url = base_url.Resolve(kConsumerManagementOverlay);
 
   chrome::NavigateParams params(profile, url, content::PAGE_TRANSITION_LINK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
+void ConsumerManagementService::NotifyStatusChanged() {
+  FOR_EACH_OBSERVER(Observer, observers_, OnConsumerManagementStatusChanged());
+}
+
 }  // namespace policy