Don't register gmail users at the device management server

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/rand_util.h"
 #include "base/task.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/profile.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_policy_cache.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 
 namespace policy {
 
@@ skipping 40 matching lines @@
       provider->RefreshTaskExecute();
   }
 
  private:
   base::WeakPtr<DeviceManagementPolicyProvider> provider_;
 };
 
 DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list,
     DeviceManagementBackend* backend,
-    TokenService* token_service,
-    const FilePath& storage_dir)
+    Profile* profile)
     : ConfigurationPolicyProvider(policy_list),
       backend_(backend),
-      token_service_(token_service),
-      storage_dir_(GetOrCreateDeviceManagementDir(storage_dir)),
+      profile_(profile),
+      storage_dir_(GetOrCreateDeviceManagementDir(profile_->GetPath())),
       policy_request_pending_(false),
       refresh_task_pending_(false),
       policy_refresh_rate_ms_(kPolicyRefreshRateInMilliseconds),
       policy_refresh_max_earlier_ms_(kPolicyRefreshMaxEarlierInMilliseconds),
       policy_refresh_error_delay_ms_(kPolicyRefreshErrorDelayInMilliseconds),
       token_fetch_error_delay_ms_(kDeviceTokenRefreshErrorDelayInMilliseconds) {
   Initialize();
 }
 
 DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {}
@@ skipping 41 matching lines @@
   token_fetch_error_delay_ms_ *= 2;
   if (token_fetch_error_delay_ms_ > policy_refresh_rate_ms_)
     token_fetch_error_delay_ms_ = policy_refresh_rate_ms_;
 }
 
 void DeviceManagementPolicyProvider::OnNotManaged() {
   VLOG(1) << "This device is not managed.";
 }
 
 void DeviceManagementPolicyProvider::Shutdown() {
-  token_service_ = NULL;
+  profile_ = NULL;
   if (token_fetcher_)
     token_fetcher_->Shutdown();
 }
 
 void DeviceManagementPolicyProvider::Initialize() {
   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"));
-  if (token_service_) {
-    token_fetcher_ =
-        new DeviceTokenFetcher(backend_.get(), token_service_, token_path);
+  if (profile_) {
+    if (!token_fetcher_) {
+      token_fetcher_ = new DeviceTokenFetcher(
+          backend_.get(), profile_, GetTokenPath());
+    }
     registrar_.Init(token_fetcher_);
     registrar_.AddObserver(this);
     token_fetcher_->StartFetching();
   }
 }
 
 void DeviceManagementPolicyProvider::SendPolicyRequest() {
   if (!policy_request_pending_) {
     policy_request_pending_ = true;
     em::DevicePolicyRequest policy_request;
@@ skipping 37 matching lines @@
                                  delay_in_milliseconds);
 }
 
 int64 DeviceManagementPolicyProvider::GetRefreshTaskDelay() {
   int64 delay = policy_refresh_rate_ms_;
   if (policy_refresh_max_earlier_ms_)
     delay -= base::RandGenerator(policy_refresh_max_earlier_ms_);
   return delay;
 }
 
+FilePath DeviceManagementPolicyProvider::GetTokenPath() {
+  return storage_dir_.Append(FILE_PATH_LITERAL("Token"));
+}
+
+void DeviceManagementPolicyProvider::SetDeviceTokenFetcher(
+    DeviceTokenFetcher* token_fetcher) {
+  DCHECK(!token_fetcher_);
+  token_fetcher_ = token_fetcher;
+}
+
 // static
 std::string DeviceManagementPolicyProvider::GetDeviceManagementURL() {
   return CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kDeviceManagementUrl);
 }
 
 // static
 FilePath DeviceManagementPolicyProvider::GetOrCreateDeviceManagementDir(
     const FilePath& user_data_dir) {
   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