Move DeviceManagementPolicyProvider into the profile.

chrome/browser/policy/device_management_policy_provider.cc

 // Copyright (c) 2010 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_management_policy_provider.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/task.h"
@@ skipping 38 matching lines @@
       provider->InitializeAfterIOThreadExists();
   }
 
  private:
   base::WeakPtr<DeviceManagementPolicyProvider> provider_;
 };
 
 DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list,
     DeviceManagementBackend* backend,
+    TokenService* token_service,
     const FilePath& storage_dir)
     : ConfigurationPolicyProvider(policy_list),
       backend_(backend),
+      token_service_(token_service),
       storage_dir_(GetOrCreateDeviceManagementDir(storage_dir)),
       policy_request_pending_(false) {
   Initialize();
 }
 
-DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
-    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list)
-    : ConfigurationPolicyProvider(policy_list),
-      policy_request_pending_(false) {
-  FilePath user_dir;
-  if (!PathService::Get(chrome::DIR_USER_DATA, &user_dir))
-    NOTREACHED();
-  storage_dir_ = GetOrCreateDeviceManagementDir(user_dir);
-  Initialize();
-}
-
 DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {}
 
 bool DeviceManagementPolicyProvider::Provide(
     ConfigurationPolicyStoreInterface* policy_store) {
   scoped_ptr<DictionaryValue> policies(cache_->GetPolicy());
   DecodePolicyValueTree(policies.get(), policy_store);
   return true;
 }
 
 void DeviceManagementPolicyProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  if ((type == NotificationType::DEVICE_TOKEN_AVAILABLE) &&
-      (token_fetcher_.get() == Source<DeviceTokenFetcher>(source).ptr())) {
-    if (!policy_request_pending_) {
-      if (IsPolicyStale())
-        SendPolicyRequest();
+  if (type == NotificationType::DEVICE_TOKEN_AVAILABLE) {
+    if (token_fetcher_.get() == Source<DeviceTokenFetcher>(source).ptr() &&
+        !policy_request_pending_ &&
+        IsPolicyStale()) {
+      SendPolicyRequest();
     }
   } else {
     NOTREACHED();
   }
 }
 
 void DeviceManagementPolicyProvider::HandlePolicyResponse(
     const em::DevicePolicyResponse& response) {
   cache_->SetPolicy(response);
   NotifyStoreOfPolicyChange();
   policy_request_pending_ = false;
 }
 
 void DeviceManagementPolicyProvider::OnError(
     DeviceManagementBackend::ErrorCode code) {
   LOG(WARNING) << "could not provide policy from the device manager (error = "
                << code << ")";
   policy_request_pending_ = false;
   // TODO(danno): do something sensible in the error case, perhaps retry later?
 }
 
+void DeviceManagementPolicyProvider::Shutdown() {
+  token_service_ = NULL;
+  if (token_fetcher_)
+    token_fetcher_->Shutdown();
+}
+
 DeviceManagementBackend* DeviceManagementPolicyProvider::GetBackend() {
   if (!backend_.get()) {
     backend_.reset(new DeviceManagementBackendImpl(
         GetDeviceManagementURL()));
   }
   return backend_.get();
 }
 
 void DeviceManagementPolicyProvider::Initialize() {
   registrar_.Add(this,
                  NotificationType::DEVICE_TOKEN_AVAILABLE,
                  NotificationService::AllSources());
 
   const FilePath policy_path = storage_dir_.Append(
       FILE_PATH_LITERAL("Policy"));
   cache_.reset(new DeviceManagementPolicyCache(policy_path));
   cache_->LoadPolicyFromFile();
 
   // Defer initialization that requires the IOThread until after the IOThread
   // has been initialized.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           new InitializeAfterIOThreadExistsTask(AsWeakPtr()));
 }
 
 void DeviceManagementPolicyProvider::InitializeAfterIOThreadExists() {
   const FilePath token_path = storage_dir_.Append(
       FILE_PATH_LITERAL("Token"));
-  token_fetcher_ = new DeviceTokenFetcher(GetBackend(), token_path);
-  token_fetcher_->StartFetching();
+  if (token_service_) {
+    token_fetcher_ =
+        new DeviceTokenFetcher(GetBackend(), token_service_, token_path);
+    token_fetcher_->StartFetching();
+  }
 }
 
 void DeviceManagementPolicyProvider::SendPolicyRequest() {
   if (!policy_request_pending_) {
     em::DevicePolicyRequest policy_request;
     policy_request.set_policy_scope(kChromePolicyScope);
     em::DevicePolicySettingRequest* setting =
         policy_request.add_setting_request();
     setting->set_key(kChromeDevicePolicySettingKey);
     GetBackend()->ProcessPolicyRequest(token_fetcher_->GetDeviceToken(),
@@ skipping 25 matching lines @@
   const FilePath device_management_dir = user_data_dir.Append(
       FILE_PATH_LITERAL("Device Management"));
   if (!file_util::DirectoryExists(device_management_dir)) {
     if (!file_util::CreateDirectory(device_management_dir))
       NOTREACHED();
   }
   return device_management_dir;
 }
 
 }  // namespace policy