Split UserCloudPolicyManager implementation.

chrome/browser/policy/user_cloud_policy_manager_factory.cc

+// Copyright (c) 2012 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/user_cloud_policy_manager_factory.h"
+
+#include "base/logging.h"
+#include "chrome/browser/policy/user_cloud_policy_manager.h"
+#include "chrome/browser/policy/user_cloud_policy_store.h"
+#include "chrome/browser/profiles/profile_dependency_manager.h"
+
+namespace policy {
+
+// static
+UserCloudPolicyManagerFactory* UserCloudPolicyManagerFactory::GetInstance() {
+  return Singleton<UserCloudPolicyManagerFactory>::get();
+}
+
+// static
+UserCloudPolicyManager* UserCloudPolicyManagerFactory::GetForProfile(
+    Profile* profile) {
+  return GetInstance()->GetManagerForProfile(profile);
+}
+
+// static
+scoped_ptr<UserCloudPolicyManager>
+    UserCloudPolicyManagerFactory::CreateForProfile(Profile* profile,
+                                                    bool force_immediate_load) {
+  return GetInstance()->CreateManagerForProfile(profile, force_immediate_load);
+}
+
+UserCloudPolicyManagerFactory::UserCloudPolicyManagerFactory()
+    : ProfileKeyedBaseFactory("UserCloudPolicyManager",
+                              ProfileDependencyManager::GetInstance()) {}
+
+UserCloudPolicyManagerFactory::~UserCloudPolicyManagerFactory() {}
+
+UserCloudPolicyManager* UserCloudPolicyManagerFactory::GetManagerForProfile(
+    Profile* profile) {
+  ManagerMap::const_iterator it = managers_.find(profile);
+  return it != managers_.end() ? it->second : NULL;
+}
+
+scoped_ptr<UserCloudPolicyManager>
+    UserCloudPolicyManagerFactory::CreateManagerForProfile(
+        Profile* profile,
+        bool force_immediate_load) {
+  scoped_ptr<policy::UserCloudPolicyStore> store(
+      policy::UserCloudPolicyStore::Create(profile));
+  if (force_immediate_load)
+    store->LoadImmediately();
+  return make_scoped_ptr(
+      new policy::UserCloudPolicyManager(profile, store.Pass()));
+}
+
+void UserCloudPolicyManagerFactory::ProfileShutdown(Profile* profile) {
+  UserCloudPolicyManager* manager = GetManagerForProfile(profile);
+  if (manager)
+    manager->Shutdown();

[Elliot Glaysher, 2012/11/27 23:31:22]

So if I understand correctly, ProfileShutdown is really the only part of the
PKSF system you actively use, since you otherwise manage your own pointers.
Doesn't this still run before the PrefService is destroyed?

[Mattias Nissler (ping if slow), 2012/11/28 09:47:06]

Mostly correct. However, I do already have a DependsOn() in
UserPolicySigninManagerFactory, and what is here now can be trivially switched
to full PKSF once we have PrefService as a PKS.

So you're right in that the move to PKSF doesn't buy much at this point; my main
motivation is to avoid #ifdef hell (if UserCloudPolicyManager were a regular
ProfileImpl member and I don't want it on OS_CHROMEOS, I'd have to sprinkle many
more #if !defined(OS_CHROMEOS) over profile.h, profile_impl.{cc,h},
testing_profile.h etc.).

Also, assuming that we're still willing to make PrefService a PKS, this seemed a
reasonable step in towards the ultimate goal.

I know all this is pretty weak justification, so if you say "screw it", I'm fine
with that ;)
Yes, and that is intentional. UserCloudPolicyManager::Shutdown() turns off some
things that should only run when the Profile is fully initialized, after the
Shutdown() call the thing still feeds policy into PrefService, but it will stop
refreshing it from the cloud for example. I thought that kind of thing was the
actually purpose of ProfileShutdown()?

+}
+
+void UserCloudPolicyManagerFactory::SetEmptyTestingFactory(Profile* profile) {}
+
+void UserCloudPolicyManagerFactory::CreateServiceNow(Profile* profile) {}
+
+void UserCloudPolicyManagerFactory::Register(Profile* profile,
+                                             UserCloudPolicyManager* instance) {
+  UserCloudPolicyManager*& entry = managers_[profile];
+  DCHECK(!entry);
+  entry = instance;
+}
+
+void UserCloudPolicyManagerFactory::Unregister(
+    Profile* profile,
+    UserCloudPolicyManager* instance) {
+  ManagerMap::iterator entry = managers_.find(profile);
+  if (entry != managers_.end()) {
+    DCHECK_EQ(instance, entry->second);
+    managers_.erase(entry);
+  } else {
+    NOTREACHED();
+  }
+}
+
+}  // namespace policy