Consolidate data storage and notifications in the cloud policy subsystem

chrome/browser/policy/device_token_fetcher.cc

Index: chrome/browser/policy/device_token_fetcher.cc
diff --git a/chrome/browser/policy/device_token_fetcher.cc b/chrome/browser/policy/device_token_fetcher.cc
index d418b343d18e15a27bc9ed258c6ea6a7eca3e0be..2d85e3232b83baf50513224c6fff3ae6bf79a9bb 100644
--- a/chrome/browser/policy/device_token_fetcher.cc
+++ b/chrome/browser/policy/device_token_fetcher.cc
@@ -32,9 +32,11 @@ namespace em = enterprise_management;
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
+    CloudPolicyData* data,
     PolicyNotifier* notifier) {
   Initialize(service,
              cache,
+             data,
              notifier,
              new DelayedWorkScheduler);
 }
@@ -42,10 +44,12 @@ DeviceTokenFetcher::DeviceTokenFetcher(
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
+    CloudPolicyData* data,
     PolicyNotifier* notifier,
     DelayedWorkScheduler* scheduler) {
   Initialize(service,
              cache,
+             data,
              notifier,
              scheduler);
 }
@@ -54,24 +58,14 @@ DeviceTokenFetcher::~DeviceTokenFetcher() {
   scheduler_->CancelDelayedWork();
 }
 
-void DeviceTokenFetcher::FetchToken(
-    const std::string& auth_token,
-    const std::string& device_id,
-    em::DeviceRegisterRequest_Type policy_type,
-    const std::string& machine_id,
-    const std::string& machine_model) {
+void DeviceTokenFetcher::FetchToken() {
   SetState(STATE_INACTIVE);
-  auth_token_ = auth_token;
-  device_id_ = device_id;
-  policy_type_ = policy_type;
-  machine_id_ = machine_id;
-  machine_model_ = machine_model;
   FetchTokenInternal();
 }
 
 void DeviceTokenFetcher::FetchTokenInternal() {
   DCHECK(state_ != STATE_TOKEN_AVAILABLE);
-  if (auth_token_.empty() || device_id_.empty()) {
+  if (data_->gaia_token().empty() || data_->device_id().empty()) {
     // Maybe this device is unmanaged, just exit. The CloudPolicyController
     // will call FetchToken() again if something changes.
     return;
@@ -79,12 +73,13 @@ void DeviceTokenFetcher::FetchTokenInternal() {
   // Construct a new backend, which will discard any previous requests.
   backend_.reset(service_->CreateBackend());
   em::DeviceRegisterRequest request;
-  request.set_type(policy_type_);
-  if (!machine_id_.empty())
-    request.set_machine_id(machine_id_);
-  if (!machine_model_.empty())
-    request.set_machine_model(machine_model_);
-  backend_->ProcessRegisterRequest(auth_token_, device_id_, request, this);
+  request.set_type(data_->policy_register_type());
+  if (!data_->machine_id().empty())
+    request.set_machine_id(data_->machine_id());
+  if (!data_->machine_model().empty())
+    request.set_machine_model(data_->machine_model());
+  backend_->ProcessRegisterRequest(data_->gaia_token(), data_->device_id(),
+                                   request, this);
 }
 
 void DeviceTokenFetcher::SetUnmanagedState() {
@@ -95,31 +90,15 @@ void DeviceTokenFetcher::SetUnmanagedState() {
   SetState(STATE_UNMANAGED);
 }
 
-const std::string& DeviceTokenFetcher::GetDeviceToken() {
-  return device_token_;
-}
-
 void DeviceTokenFetcher::StopAutoRetry() {
   scheduler_->CancelDelayedWork();
   backend_.reset();
-  device_token_.clear();
-  auth_token_.clear();
-  device_id_.clear();
-}
-
-void DeviceTokenFetcher::AddObserver(DeviceTokenFetcher::Observer* observer) {
-  observer_list_.AddObserver(observer);
-}
-
-void DeviceTokenFetcher::RemoveObserver(
-    DeviceTokenFetcher::Observer* observer) {
-  observer_list_.RemoveObserver(observer);
 }
 
 void DeviceTokenFetcher::HandleRegisterResponse(
     const em::DeviceRegisterResponse& response) {
   if (response.has_device_management_token()) {
-    device_token_ = response.device_management_token();
+    data_->SetDeviceToken(response.device_management_token(), false);
     SetState(STATE_TOKEN_AVAILABLE);
   } else {
     NOTREACHED();
@@ -150,11 +129,13 @@ void DeviceTokenFetcher::OnError(DeviceManagementBackend::ErrorCode code) {
 
 void DeviceTokenFetcher::Initialize(DeviceManagementService* service,
                                     CloudPolicyCacheBase* cache,
+                                    CloudPolicyData* data,
                                     PolicyNotifier* notifier,
                                     DelayedWorkScheduler* scheduler) {
   service_ = service;
   cache_ = cache;
   notifier_ = notifier;
+  data_ = data;
   effective_token_fetch_error_delay_ms_ = kTokenFetchErrorDelayMilliseconds;
   state_ = STATE_INACTIVE;
   scheduler_.reset(scheduler);
@@ -171,15 +152,11 @@ void DeviceTokenFetcher::SetState(FetcherState state) {
   base::Time delayed_work_at;
   switch (state_) {
     case STATE_INACTIVE:
-      device_token_.clear();
-      auth_token_.clear();
-      device_id_.clear();
       notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
                         CloudPolicySubsystem::NO_DETAILS,
                         PolicyNotifier::TOKEN_FETCHER);
       break;
     case STATE_TOKEN_AVAILABLE:
-      FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceTokenAvailable());
       notifier_->Inform(CloudPolicySubsystem::SUCCESS,
                         CloudPolicySubsystem::NO_DETAILS,
                         PolicyNotifier::TOKEN_FETCHER);