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/task.h"
 #include "base/time.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_backend_impl.h"
 #include "chrome/browser/policy/device_management_policy_cache.h"
 #include "chrome/browser/policy/device_token_fetcher.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 {
@@ skipping 26 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)
+    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) {
   Initialize();
 }
+
+DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
+    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list,
+    DeviceManagementBackend* backend,
+    Profile* profile,
+    DeviceTokenFetcher* token_fetcher)
+    : ConfigurationPolicyProvider(policy_list),
+      backend_(backend),
+      profile_(profile),
+      token_fetcher_(token_fetcher),
+      storage_dir_(GetOrCreateDeviceManagementDir(profile_->GetPath())),
+      policy_request_pending_(false) {
+  Initialize();
+}
 
 DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {}
 
 bool DeviceManagementPolicyProvider::Provide(
     ConfigurationPolicyStoreInterface* policy_store) {
   scoped_ptr<DictionaryValue> policies(cache_->GetPolicy());
   DecodePolicyValueTree(policies.get(), policy_store);
   return true;
 }
 
@@ skipping 21 matching lines @@
 
 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;
+  profile_ = NULL;
   if (token_fetcher_)
     token_fetcher_->Shutdown();
 }
 
 DeviceManagementBackend* DeviceManagementPolicyProvider::GetBackend() {
   if (!backend_.get()) {
     backend_.reset(new DeviceManagementBackendImpl(
         GetDeviceManagementURL()));
   }
   return backend_.get();
@@ skipping 11 matching lines @@
 
   // 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(GetBackend(), token_service_, token_path);
+  if (profile_) {
+    if (!token_fetcher_) {
+      token_fetcher_ =
+          new DeviceTokenFetcher(GetBackend(), profile_, 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();
@@ skipping 27 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