Consolidate data storage and notifications in the cloud policy subsystem

chrome/browser/policy/device_token_fetcher.cc

 // Copyright (c) 2011 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/policy/device_token_fetcher.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
+#include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 
 namespace {
 
 // Retry after 5 minutes (with exponential backoff) after token fetch errors.
 const int64 kTokenFetchErrorDelayMilliseconds = 5 * 60 * 1000;
 // Retry after max 3 hours after token fetch errors.
 const int64 kTokenFetchErrorMaxDelayMilliseconds = 3 * 60 * 60 * 1000;
 // For unmanaged devices, check once per day whether they're still unmanaged.
 const int64 kUnmanagedDeviceRefreshRateMilliseconds = 24 * 60 * 60 * 1000;
 
 }  // namespace
 
 namespace policy {
 
 namespace em = enterprise_management;
 
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
+    CloudPolicyDataStore* data_store,
     PolicyNotifier* notifier) {
   Initialize(service,
              cache,
+             data_store,
              notifier,
              new DelayedWorkScheduler);
 }
 
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
+    CloudPolicyDataStore* data_store,
     PolicyNotifier* notifier,
     DelayedWorkScheduler* scheduler) {
-  Initialize(service,
-             cache,
-             notifier,
-             scheduler);
+  Initialize(service, cache, data_store, notifier, scheduler);
 }
 
 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_store_->gaia_token().empty() || data_store_->device_id().empty()) {
     // Maybe this device is unmanaged, just exit. The CloudPolicyController
     // will call FetchToken() again if something changes.
     return;
   }
   // 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_store_->policy_register_type());
+  if (!data_store_->machine_id().empty())
+    request.set_machine_id(data_store_->machine_id());
+  if (!data_store_->machine_model().empty())
+    request.set_machine_model(data_store_->machine_model());
+  backend_->ProcessRegisterRequest(data_store_->gaia_token(),
+                                   data_store_->device_id(),
+                                   request, this);
 }
 
 void DeviceTokenFetcher::SetUnmanagedState() {
   // The call to |cache_->SetUnmanaged()| has to happen first because it sets
   // the timestamp that |SetState()| needs to determine the correct refresh
   // time.
   cache_->SetUnmanaged();
   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()) {
     UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchOK,
                               kMetricTokenSize);
-    device_token_ = response.device_management_token();
+    data_store_->SetDeviceToken(response.device_management_token(), false);
     SetState(STATE_TOKEN_AVAILABLE);
   } else {
     NOTREACHED();
     UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchBadResponse,
                               kMetricTokenSize);
     SetState(STATE_ERROR);
   }
 }
 
 void DeviceTokenFetcher::OnError(DeviceManagementBackend::ErrorCode code) {
@@ skipping 12 matching lines @@
       // until the user logs-in again.
       SetState(STATE_BAD_AUTH);
       break;
     default:
       SetState(STATE_ERROR);
   }
 }
 
 void DeviceTokenFetcher::Initialize(DeviceManagementService* service,
                                     CloudPolicyCacheBase* cache,
+                                    CloudPolicyDataStore* data_store,
                                     PolicyNotifier* notifier,
                                     DelayedWorkScheduler* scheduler) {
   service_ = service;
   cache_ = cache;
   notifier_ = notifier;
+  data_store_ = data_store;
   effective_token_fetch_error_delay_ms_ = kTokenFetchErrorDelayMilliseconds;
   state_ = STATE_INACTIVE;
   scheduler_.reset(scheduler);
 
   if (cache_->is_unmanaged())
     SetState(STATE_UNMANAGED);
 }
 
 void DeviceTokenFetcher::SetState(FetcherState state) {
   state_ = state;
   if (state_ != STATE_TEMPORARY_ERROR)
     effective_token_fetch_error_delay_ms_ = kTokenFetchErrorDelayMilliseconds;
 
   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);
       break;
     case STATE_UNMANAGED:
       delayed_work_at = cache_->last_policy_refresh_time() +
           base::TimeDelta::FromMilliseconds(
               kUnmanagedDeviceRefreshRateMilliseconds);
       notifier_->Inform(CloudPolicySubsystem::UNMANAGED,
                         CloudPolicySubsystem::NO_DETAILS,
@@ skipping 45 matching lines @@
     case STATE_UNMANAGED:
     case STATE_ERROR:
     case STATE_TEMPORARY_ERROR:
     case STATE_BAD_AUTH:
       FetchTokenInternal();
       break;
   }
 }
 
 }  // namespace policy