Consolidate data storage and notifications in the cloud policy subsystem

chrome/browser/policy/browser_policy_connector.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/browser_policy_connector.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/cloud_policy_provider.h"
 #include "chrome/browser/policy/cloud_policy_provider_impl.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/dummy_cloud_policy_provider.h"
 #include "chrome/browser/policy/dummy_configuration_policy_provider.h"
 #include "chrome/browser/policy/user_policy_cache.h"
-#include "chrome/browser/policy/user_policy_identity_strategy.h"
+#include "chrome/browser/policy/user_policy_token_cache.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/policy/configuration_policy_provider_win.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/policy/configuration_policy_provider_mac.h"
 #elif defined(OS_POSIX)
 #include "chrome/browser/policy/config_dir_policy_provider.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/policy/device_policy_cache.h"
-#include "chrome/browser/policy/device_policy_identity_strategy.h"
-#include "content/common/notification_service.h"
 #endif
 
 namespace policy {
 
 namespace {
 
 // Subdirectory in the user's profile for storing user policies.
 const FilePath::CharType kPolicyDir[] = FILE_PATH_LITERAL("Device Management");
 // File in the above directory for stroing user policy dmtokens.
 const FilePath::CharType kTokenCacheFile[] = FILE_PATH_LITERAL("Token");
@@ skipping 51 matching lines @@
       managed_cloud_provider_(managed_cloud_provider),
       recommended_cloud_provider_(recommended_cloud_provider),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
 
 BrowserPolicyConnector::~BrowserPolicyConnector() {
   // Shutdown device cloud policy.
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get())
     device_cloud_policy_subsystem_->Shutdown();
   device_cloud_policy_subsystem_.reset();
-  device_identity_strategy_.reset();
+  device_data_store_.reset();
 #endif
 
   // Shutdown user cloud policy.
   if (user_cloud_policy_subsystem_.get())
     user_cloud_policy_subsystem_->Shutdown();
   user_cloud_policy_subsystem_.reset();
-  user_identity_strategy_.reset();
+  user_data_store_.reset();
+  user_policy_token_cache_ = NULL;
 }
 
 ConfigurationPolicyProvider*
     BrowserPolicyConnector::GetManagedPlatformProvider() const {
   return managed_platform_provider_.get();
 }
 
 ConfigurationPolicyProvider*
     BrowserPolicyConnector::GetManagedCloudProvider() const {
   return managed_cloud_provider_.get();
@@ skipping 46 matching lines @@
   }
 #else
   return new DummyConfigurationPolicyProvider(policy_list);
 #endif
 }
 
 void BrowserPolicyConnector::SetDeviceCredentials(
     const std::string& owner_email,
     const std::string& gaia_token) {
 #if defined(OS_CHROMEOS)
-  if (device_identity_strategy_.get())
-    device_identity_strategy_->SetAuthCredentials(owner_email, gaia_token);
+  if (device_data_store_.get()) {
+    device_data_store_->set_user_name(owner_email);
+    device_data_store_->SetGaiaToken(gaia_token);
+  }
 #endif
 }
 
 bool BrowserPolicyConnector::IsEnterpriseManaged() {
 #if defined(OS_CHROMEOS)
   return install_attributes_.get() && install_attributes_->IsEnterpriseDevice();
 #else
   return false;
 #endif
 }
@@ skipping 19 matching lines @@
 
 void BrowserPolicyConnector::DeviceStopAutoRetry() {
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get())
     device_cloud_policy_subsystem_->StopAutoRetry();
 #endif
 }
 
 void BrowserPolicyConnector::FetchDevicePolicy() {
 #if defined(OS_CHROMEOS)
-  if (device_identity_strategy_.get())
-    return device_identity_strategy_->FetchPolicy();
+  if (device_data_store_.get()) {
+    DCHECK(!device_data_store_->device_token().empty());
+    device_data_store_->NotifyDeviceTokenChanged();
+  }
 #endif
 }
 
 void BrowserPolicyConnector::InitializeUserPolicy(const std::string& user_name,
                                                   const FilePath& policy_dir,
                                                   TokenService* token_service) {
   DCHECK(token_service);
 
   // Throw away the old backend.
   user_cloud_policy_subsystem_.reset();
-  user_identity_strategy_.reset();
+  user_data_store_.reset();
+  user_policy_token_cache_ = NULL;
   registrar_.RemoveAll();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
     token_service_ = token_service;
     registrar_.Add(this,
                    NotificationType::TOKEN_AVAILABLE,
                    Source<TokenService>(token_service_));
 
     FilePath policy_cache_dir = policy_dir.Append(kPolicyDir);
     UserPolicyCache* user_policy_cache =
         new UserPolicyCache(policy_cache_dir.Append(kPolicyCacheFile));
+    user_data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
+    user_policy_token_cache_ = new UserPolicyTokenCache(
+        user_data_store_->GetWeakPtr(),
+        policy_cache_dir.Append(kTokenCacheFile));
 
     // Prepending user caches meaning they will take precedence of device policy
     // caches.
     managed_cloud_provider_->PrependCache(user_policy_cache);
     recommended_cloud_provider_->PrependCache(user_policy_cache);
-    user_identity_strategy_.reset(
-        new UserPolicyIdentityStrategy(
-            user_name,
-            policy_cache_dir.Append(kTokenCacheFile)));
     user_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
-        user_identity_strategy_.get(),
+        user_data_store_.get(),
         user_policy_cache));
 
     // Initiate the DM-Token load.
-    user_identity_strategy_->LoadTokenCache();
+    user_policy_token_cache_->Load();
 
+    user_data_store_->set_user_name(user_name);
     if (token_service_->HasTokenForService(
             GaiaConstants::kDeviceManagementService)) {
-      user_identity_strategy_->SetAuthToken(
-          token_service_->GetTokenForService(
+      user_data_store_->SetGaiaToken(token_service_->GetTokenForService(
               GaiaConstants::kDeviceManagementService));
     }
 
     user_cloud_policy_subsystem_->CompleteInitialization(
         prefs::kUserPolicyRefreshRate,
         kServiceInitializationStartupDelay);
   }
 }
 
 void BrowserPolicyConnector::ScheduleServiceInitialization(
     int64 delay_milliseconds) {
   if (user_cloud_policy_subsystem_.get()) {
     user_cloud_policy_subsystem_->
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get()) {
     device_cloud_policy_subsystem_->
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #endif
 }
 
 void BrowserPolicyConnector::InitializeDevicePolicy() {
 #if defined(OS_CHROMEOS)
   // Throw away the old backend.
   device_cloud_policy_subsystem_.reset();
-  device_identity_strategy_.reset();
+  device_data_store_.reset();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableDevicePolicy)) {
-    device_identity_strategy_.reset(new DevicePolicyIdentityStrategy());
+    device_data_store_.reset(CloudPolicyDataStore::CreateForDevicePolicies());
     install_attributes_.reset(new EnterpriseInstallAttributes(
         chromeos::CrosLibrary::Get()->GetCryptohomeLibrary()));
     DevicePolicyCache* device_policy_cache =
-        new DevicePolicyCache(device_identity_strategy_.get(),
+        new DevicePolicyCache(device_data_store_.get(),
                               install_attributes_.get());
 
     managed_cloud_provider_->AppendCache(device_policy_cache);
     recommended_cloud_provider_->AppendCache(device_policy_cache);
 
     device_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
-        device_identity_strategy_.get(),
+        device_data_store_.get(),
         device_policy_cache));
 
     // Initialize the subsystem once the message loops are spinning.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         method_factory_.NewRunnableMethod(
             &BrowserPolicyConnector::InitializeDevicePolicySubsystem));
   }
 #endif
 }
@@ skipping 12 matching lines @@
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (type == NotificationType::TOKEN_AVAILABLE) {
     const TokenService* token_source =
         Source<const TokenService>(source).ptr();
     DCHECK_EQ(token_service_, token_source);
     const TokenService::TokenAvailableDetails* token_details =
         Details<const TokenService::TokenAvailableDetails>(details).ptr();
     if (token_details->service() == GaiaConstants::kDeviceManagementService) {
-      if (user_identity_strategy_.get()) {
-        user_identity_strategy_->SetAuthToken(token_details->token());
+      if (user_data_store_.get()) {
+        user_data_store_->SetGaiaToken(token_details->token());
       }
     }
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace