src/chrome/browser/policy/cloud/user_cloud_policy_manager_factory.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
   6
   7 #include "base/logging.h"
   8 #include "base/message_loop/message_loop_proxy.h"
   9 #include "base/sequenced_task_runner.h"
  10 #include "chrome/browser/policy/cloud/cloud_external_data_manager.h"
  11 #include "chrome/browser/policy/cloud/user_cloud_policy_manager.h"
  12 #include "chrome/browser/policy/cloud/user_cloud_policy_store.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
  15
  16 namespace policy {
  17
  18 // static
  19 UserCloudPolicyManagerFactory* UserCloudPolicyManagerFactory::GetInstance() {
  20   return Singleton<UserCloudPolicyManagerFactory>::get();
  21 }
  22
  23 // static
  24 UserCloudPolicyManager* UserCloudPolicyManagerFactory::GetForProfile(
  25     Profile* profile) {
  26   return GetInstance()->GetManagerForProfile(profile);
  27 }
  28
  29 // static
  30 scoped_ptr<UserCloudPolicyManager>
  31 UserCloudPolicyManagerFactory::CreateForProfile(
  32     Profile* profile,
  33     bool force_immediate_load,
  34     scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
  35   return GetInstance()->CreateManagerForProfile(
  36       profile, force_immediate_load, background_task_runner);
  37 }
  38
  39 UserCloudPolicyManagerFactory::UserCloudPolicyManagerFactory()
  40     : BrowserContextKeyedBaseFactory(
  41         "UserCloudPolicyManager",
  42         BrowserContextDependencyManager::GetInstance()) {}
  43
  44 UserCloudPolicyManagerFactory::~UserCloudPolicyManagerFactory() {}
  45
  46 UserCloudPolicyManager* UserCloudPolicyManagerFactory::GetManagerForProfile(
  47     Profile* profile) {
  48   // Get the manager for the original profile, since the PolicyService is
  49   // also shared between the incognito Profile and the original Profile.
  50   ManagerMap::const_iterator it = managers_.find(profile->GetOriginalProfile());
  51   return it != managers_.end() ? it->second : NULL;
  52 }
  53
  54 scoped_ptr<UserCloudPolicyManager>
  55     UserCloudPolicyManagerFactory::CreateManagerForProfile(
  56         Profile* profile,
  57         bool force_immediate_load,
  58         scoped_refptr<base::SequencedTaskRunner> background_task_runner) {
  59   scoped_ptr<UserCloudPolicyStore> store(
  60       UserCloudPolicyStore::Create(profile, background_task_runner));
  61   if (force_immediate_load)
  62     store->LoadImmediately();
  63   scoped_ptr<UserCloudPolicyManager> manager(
  64       new UserCloudPolicyManager(profile,
  65                                  store.Pass(),
  66                                  scoped_ptr<CloudExternalDataManager>(),
  67                                  base::MessageLoopProxy::current()));
  68   manager->Init();
  69   return manager.Pass();
  70 }
  71
  72 void UserCloudPolicyManagerFactory::BrowserContextShutdown(
  73     content::BrowserContext* context) {
  74   Profile* profile = static_cast<Profile*>(context);
  75   if (profile->IsOffTheRecord())
  76     return;
  77   UserCloudPolicyManager* manager = GetManagerForProfile(profile);
  78   if (manager)
  79     manager->Shutdown();
  80 }
  81
  82 void UserCloudPolicyManagerFactory::SetEmptyTestingFactory(
  83     content::BrowserContext* profile) {
  84 }
  85
  86 void UserCloudPolicyManagerFactory::CreateServiceNow(
  87     content::BrowserContext* profile) {
  88 }
  89
  90 void UserCloudPolicyManagerFactory::Register(Profile* profile,
  91                                              UserCloudPolicyManager* instance) {
  92   UserCloudPolicyManager*& entry = managers_[profile];
  93   DCHECK(!entry);
  94   entry = instance;
  95 }
  96
  97 void UserCloudPolicyManagerFactory::Unregister(
  98     Profile* profile,
  99     UserCloudPolicyManager* instance) {
 100   ManagerMap::iterator entry = managers_.find(profile);
 101   if (entry != managers_.end()) {
 102     DCHECK_EQ(instance, entry->second);
 103     managers_.erase(entry);
 104   } else {
 105     NOTREACHED();
 106   }
 107 }
 108
 109 }  // namespace policy