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/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/notifications/notification.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"
@@ skipping 27 matching lines @@
 const char* kEnrollmentNotificationUrl = "chrome://consumer-management/enroll";
 
 // URL
 const char* kConsumerManagementOverlay = "/consumer-management-overlay";
 
 }  // namespace
 
 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_token_service_(NULL),
       is_observing_token_service_(false),
       weak_ptr_factory_(this) {
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                  content::NotificationService::AllSources());
 }
 
 ConsumerManagementService::~ConsumerManagementService() {
   registrar_.Remove(this,
                     chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                     content::NotificationService::AllSources());
   if (is_observing_token_service_) {
     enrolling_token_service_->RemoveObserver(this);
     is_observing_token_service_ = false;
   }
 }
 
 // static
 void ConsumerManagementService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(
       prefs::kConsumerManagementEnrollmentState, ENROLLMENT_NONE);
 }
 
+void ConsumerManagementService::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ConsumerManagementService::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 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::SetEnrollmentState(
     ConsumerEnrollmentState state) {
   PrefService* prefs = g_browser_process->local_state();
   prefs->SetInteger(prefs::kConsumerManagementEnrollmentState, state);
+
+  NotifyEnrollmentStateChanged();

[bartfab (slow), 2014/08/20 14:40:02]

Nit: Since this is the only caller of NotifyEnrollmentStateChanged(), you might
as well fold the two into one method.

[davidyu, 2014/08/21 09:40:29]

Done.

 }
 
 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));
@@ skipping 52 matching lines @@
     const cryptohome::BaseReply& reply) {
   if (!dbus_success || reply.error() != 0) {
     LOG(ERROR) << "Failed to flush and sign boot lockbox.";
     callback.Run(false);
     return;
   }
 
   callback.Run(true);
 }
 
+bool ConsumerManagementService::IsEnrolled() const {
+  const enterprise_management::PolicyData* policy_data =
+      device_settings_service_->policy_data();
+  return policy_data && policy_data->management_mode() ==

[bartfab (slow), 2014/08/20 14:40:02]

What if policy data has not been retrieved yet? The device may still be
enrolled. It looks like this method should take a callback that it invokes once
it knows for sure whether the device is enrolled or not.

[davidyu, 2014/08/21 09:40:29]

Added a unknown state which is returned when policy data is not ready. Observers
will be notified when policy data is ready.

+      enterprise_management::PolicyData::CONSUMER_MANAGED;
+}
+
+bool ConsumerManagementService::IsEnrolling() const {
+  ConsumerEnrollmentState state = GetEnrollmentState();
+  return state > ENROLLMENT_NONE && state < ENROLLMENT_SUCCESS;
+}
+
+bool ConsumerManagementService::IsUnenrolling() const {
+  // TODO(davidyu): Implement this.

[bartfab (slow), 2014/08/20 14:40:02]

Nit: Can you add a bug number?

[davidyu, 2014/08/21 09:40:29]

Done.

+  return false;
+}
+
 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 221 matching lines @@
               message_center::NotifierId::SYSTEM_COMPONENT, id),
           base::string16(),  // display_source
           base::UTF8ToUTF16(id),
           optional_field,
           new DesktopNotificationDelegate(id, button_click_callback)));
   notification->SetSystemPriority();
 
   g_browser_process->notification_ui_manager()->Add(*notification, profile);
 }
 
+void ConsumerManagementService::NotifyEnrollmentStateChanged() {
+  FOR_EACH_OBSERVER(Observer,
+                    observers_,
+                    OnConsumerManagementEnrollmentStateChanged(this));
+}
+
 ConsumerManagementService::DesktopNotificationDelegate::
 DesktopNotificationDelegate(
     const std::string& id,
     const base::Closure& button_click_callback)
     : id_(id),
       button_click_callback_(button_click_callback) {
 }
 
 void ConsumerManagementService::DesktopNotificationDelegate::ButtonClick(
     int button_index) {
   button_click_callback_.Run();
 }
 
 }  // namespace policy