Support policies referencing external data for device-local accounts

chrome/browser/chromeos/policy/device_local_account_policy_service.cc

 // Copyright (c) 2012 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/device_local_account_policy_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
+#include "chrome/browser/chromeos/policy/device_local_account_external_data_service.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_store.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/policy/cloud/cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.h"
 #include "chrome/browser/policy/cloud/device_management_service.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Creates and initializes a cloud policy client. Returns NULL if the device
 // doesn't have credentials in device settings (i.e. is not
@@ skipping 23 matching lines @@
 std::string GetCacheSubdirectoryForAccountID(const std::string& account_id) {
   return base::HexEncode(account_id.c_str(), account_id.size());
 }
 
 // Cleans up the cache directory by removing subdirectories that are not found
 // in |subdirectories_to_keep|. Only caches whose cache directory is found in
 // |subdirectories_to_keep| may be running while the clean-up is in progress.
 void DeleteOrphanedExtensionCaches(
     const std::set<std::string>& subdirectories_to_keep) {
   base::FilePath cache_root_dir;
-  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_CACHE,
+  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   base::FileEnumerator enumerator(cache_root_dir,
                                   false,
                                   base::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     const std::string subdirectory(path.BaseName().MaybeAsASCII());
     if (subdirectories_to_keep.find(subdirectory) ==
         subdirectories_to_keep.end()) {
       base::DeleteFile(path, true);
     }
   }
 }
 
 // Removes the subdirectory belonging to |account_id_to_delete| from the cache
 // directory. No cache belonging to |account_id_to_delete| may be running while
 // the removal is in progress.
 void DeleteObsoleteExtensionCache(const std::string& account_id_to_delete) {
   base::FilePath cache_root_dir;
-  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_CACHE,
+  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   const base::FilePath path = cache_root_dir
       .Append(GetCacheSubdirectoryForAccountID(account_id_to_delete));
   if (base::DirectoryExists(path))
     base::DeleteFile(path, true);
 }
 
 }  // namespace
 
 DeviceLocalAccountPolicyBroker::DeviceLocalAccountPolicyBroker(
     const DeviceLocalAccount& account,
     scoped_ptr<DeviceLocalAccountPolicyStore> store,
+    scoped_refptr<DeviceLocalAccountExternalDataManager> external_data_manager,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : account_id_(account.account_id),
       user_id_(account.user_id),
       store_(store.Pass()),
+      external_data_manager_(external_data_manager),
       core_(PolicyNamespaceKey(dm_protocol::kChromePublicAccountPolicyType,
                                store_->account_id()),
             store_.get(),
             task_runner) {
   base::FilePath cache_root_dir;
-  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_CACHE,
+  CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   extension_loader_ = new chromeos::DeviceLocalAccountExternalPolicyLoader(
       store_.get(),
       cache_root_dir.Append(
           GetCacheSubdirectoryForAccountID(account.account_id)));
 }
 
 DeviceLocalAccountPolicyBroker::~DeviceLocalAccountPolicyBroker() {
+  external_data_manager_->SetPolicyStore(NULL);
+  external_data_manager_->Disconnect();
 }
 
 void DeviceLocalAccountPolicyBroker::Initialize() {
   store_->Load();
 }
 
 void DeviceLocalAccountPolicyBroker::ConnectIfPossible(
     chromeos::DeviceSettingsService* device_settings_service,
-    DeviceManagementService* device_management_service) {
+    DeviceManagementService* device_management_service,
+    scoped_refptr<net::URLRequestContextGetter> request_context) {
   if (core_.client())
     return;
 
   scoped_ptr<CloudPolicyClient> client(CreateClient(device_settings_service,
                                                     device_management_service));
   if (!client)
     return;
 
   core_.Connect(client.Pass());
+  external_data_manager_->Connect(request_context);
   core_.StartRefreshScheduler();
   UpdateRefreshDelay();
 }
 
-void DeviceLocalAccountPolicyBroker::Disconnect() {
-  core_.Disconnect();
-}
-
 void DeviceLocalAccountPolicyBroker::UpdateRefreshDelay() {
   if (core_.refresh_scheduler()) {
     const Value* policy_value =
         store_->policy_map().GetValue(key::kPolicyRefreshRate);
     int delay = 0;
     if (policy_value && policy_value->GetAsInteger(&delay))
       core_.refresh_scheduler()->SetRefreshDelay(delay);
   }
 }
 
 std::string DeviceLocalAccountPolicyBroker::GetDisplayName() const {
   std::string display_name;
   const base::Value* display_name_value =
       store_->policy_map().GetValue(policy::key::kUserDisplayName);
   if (display_name_value)
     display_name_value->GetAsString(&display_name);
   return display_name;
 }
 
 DeviceLocalAccountPolicyService::DeviceLocalAccountPolicyService(
     chromeos::SessionManagerClient* session_manager_client,
     chromeos::DeviceSettingsService* device_settings_service,
     chromeos::CrosSettings* cros_settings,
     scoped_refptr<base::SequencedTaskRunner> store_background_task_runner,
-    scoped_refptr<base::SequencedTaskRunner> extension_cache_task_runner)
+    scoped_refptr<base::SequencedTaskRunner> extension_cache_task_runner,
+    scoped_refptr<base::SequencedTaskRunner>
+        external_data_service_backend_task_runner,
+    scoped_refptr<base::SequencedTaskRunner> io_task_runner,
+    scoped_refptr<net::URLRequestContextGetter> request_context)
     : session_manager_client_(session_manager_client),
       device_settings_service_(device_settings_service),
       cros_settings_(cros_settings),
       device_management_service_(NULL),
       waiting_for_cros_settings_(false),
       orphan_cache_deletion_state_(NOT_STARTED),
       store_background_task_runner_(store_background_task_runner),
       extension_cache_task_runner_(extension_cache_task_runner),
+      request_context_(request_context),
       local_accounts_subscription_(cros_settings_->AddSettingsObserver(
           chromeos::kAccountsPrefDeviceLocalAccounts,
           base::Bind(&DeviceLocalAccountPolicyService::
                          UpdateAccountListIfNonePending,
                      base::Unretained(this)))),
       weak_factory_(this) {
+  external_data_service_.reset(new DeviceLocalAccountExternalDataService(
+      this,
+      external_data_service_backend_task_runner,
+      io_task_runner));
   UpdateAccountList();
 }
 
 DeviceLocalAccountPolicyService::~DeviceLocalAccountPolicyService() {
+  DCHECK(!request_context_);
+  DCHECK(policy_brokers_.empty());
+}
+
+void DeviceLocalAccountPolicyService::Shutdown() {
+  device_management_service_ = NULL;
+  request_context_ = NULL;
   DeleteBrokers(&policy_brokers_);
 }
 
 void DeviceLocalAccountPolicyService::Connect(
     DeviceManagementService* device_management_service) {
   DCHECK(!device_management_service_);
   device_management_service_ = device_management_service;
 
   // Connect the brokers.
   for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
        it != policy_brokers_.end(); ++it) {
     it->second->ConnectIfPossible(device_settings_service_,
-                                  device_management_service_);
+                                  device_management_service_,
+                                  request_context_);
   }
 }
 
-void DeviceLocalAccountPolicyService::Disconnect() {
-  DCHECK(device_management_service_);
-  device_management_service_ = NULL;
-
-  // Disconnect the brokers.
-  for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
-       it != policy_brokers_.end(); ++it) {
-    it->second->Disconnect();
-  }
-}
-
 DeviceLocalAccountPolicyBroker*
     DeviceLocalAccountPolicyService::GetBrokerForUser(
         const std::string& user_id) {
   PolicyBrokerMap::iterator entry = policy_brokers_.find(user_id);
   if (entry == policy_brokers_.end())
     return NULL;
 
   return entry->second;
 }
 
@@ skipping 149 matching lines @@
       broker.reset(broker_it->second);
       old_policy_brokers.erase(broker_it);
       broker_initialized = true;
     } else {
       scoped_ptr<DeviceLocalAccountPolicyStore> store(
           new DeviceLocalAccountPolicyStore(it->account_id,
                                             session_manager_client_,
                                             device_settings_service_,
                                             store_background_task_runner_));
       store->AddObserver(this);
+      scoped_refptr<DeviceLocalAccountExternalDataManager>
+          external_data_manager =
+              external_data_service_->GetExternalDataManager(it->account_id,
+                                                             store.get());
       broker.reset(new DeviceLocalAccountPolicyBroker(
           *it,
           store.Pass(),
+          external_data_manager,
           base::MessageLoopProxy::current()));
     }
 
     // Fire up the cloud connection for fetching policy for the account from
     // the cloud if this is an enterprise-managed device.
     broker->ConnectIfPossible(device_settings_service_,
-                              device_management_service_);
+                              device_management_service_,
+                              request_context_);
 
     policy_brokers_[it->user_id] = broker.release();
     if (!broker_initialized) {
       // The broker must be initialized after it has been added to
       // |policy_brokers_|.
       policy_brokers_[it->user_id]->Initialize();
     }
 
     if (orphan_cache_deletion_state_ == NOT_STARTED) {
       subdirectories_to_keep.insert(
@@ skipping 65 matching lines @@
         CloudPolicyStore* store) {
   for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
        it != policy_brokers_.end(); ++it) {
     if (it->second->core()->store() == store)
       return it->second;
   }
   return NULL;
 }
 
 }  // namespace policy