Move DeviceManagementPolicyProvider into the profile.

chrome/browser/policy/device_token_fetcher.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_token_fetcher.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "chrome/browser/guid.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 
 namespace policy {
 
 namespace em = enterprise_management;
 
 DeviceTokenFetcher::DeviceTokenFetcher(
     DeviceManagementBackend* backend,
+    TokenService* token_service,
     const FilePath& token_path)
     : token_path_(token_path),
       backend_(backend),
+      token_service_(token_service),
       state_(kStateNotStarted),
       device_token_load_complete_event_(true, false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // The token fetcher gets initialized AuthTokens for the device management
-  // server are available. Install a notification observer to ensure that the
-  // device management token gets fetched after the AuthTokens are available.
+
+  auth_token_ = token_service_->GetTokenForService(
+      GaiaConstants::kDeviceManagementService);
+
   registrar_.Add(this,
                  NotificationType::TOKEN_AVAILABLE,
-                 NotificationService::AllSources());
+                 Source<TokenService>(token_service_));
 }
 
 void DeviceTokenFetcher::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (type == NotificationType::TOKEN_AVAILABLE) {
-    const Source<TokenService> token_service(source);
-    const TokenService::TokenAvailableDetails* token_details =
-        Details<const TokenService::TokenAvailableDetails>(details).ptr();
-    if (token_details->service() == GaiaConstants::kDeviceManagementService) {
-      if (!HasAuthToken()) {
-        auth_token_ = token_details->token();
-        SendServerRequestIfPossible();
+    if (Source<TokenService>(source).ptr() == token_service_) {
+      const TokenService::TokenAvailableDetails* token_details =
+          Details<const TokenService::TokenAvailableDetails>(details).ptr();
+      if (token_details->service() == GaiaConstants::kDeviceManagementService) {
+        if (!HasAuthToken()) {
+          auth_token_ = token_details->token();
+          SendServerRequestIfPossible();
+        }
       }
     }
   } else {
     NOTREACHED();
   }
 }
 
 void DeviceTokenFetcher::HandleRegisterResponse(
     const em::DeviceRegisterResponse& response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 33 matching lines @@
     // The file calls for loading the persisted token must be deferred to the
     // FILE thread.
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         NewRunnableMethod(this,
                           &DeviceTokenFetcher::AttemptTokenLoadFromDisk));
   }
 }
 
+void DeviceTokenFetcher::Shutdown() {
+  token_service_ = NULL;
+  backend_ = NULL;
+}
+
 void DeviceTokenFetcher::AttemptTokenLoadFromDisk() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (file_util::PathExists(token_path_)) {
     std::string data;
     em::DeviceCredentials device_credentials;
     if (file_util::ReadFileToString(token_path_, &data) &&
         device_credentials.ParseFromArray(data.c_str(), data.size())) {
       device_token_ = device_credentials.device_token();
       device_id_ = device_credentials.device_id();
       if (!device_token_.empty() && !device_id_.empty()) {
@@ skipping 17 matching lines @@
 
 void DeviceTokenFetcher::MakeReadyToRequestDeviceToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SetState(kStateReadyToRequestDeviceTokenFromServer);
   SendServerRequestIfPossible();
 }
 
 void DeviceTokenFetcher::SendServerRequestIfPossible() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state_ == kStateReadyToRequestDeviceTokenFromServer
-      && HasAuthToken()) {
+      && HasAuthToken()
+      && backend_) {
     em::DeviceRegisterRequest register_request;
     SetState(kStateRequestingDeviceTokenFromServer);
     backend_->ProcessRegisterRequest(auth_token_,
                                      GetDeviceID(),
                                      register_request,
                                      this);
   }
 }
 
 bool DeviceTokenFetcher::IsTokenPending() {
@@ skipping 55 matching lines @@
   DCHECK(no_error);
   file_util::WriteFile(path, data.c_str(), data.length());
 }
 
 // static
 std::string DeviceTokenFetcher::GenerateNewDeviceID() {
   return guid::GenerateGUID();
 }
 
 }  // namespace policy