Merge {Device,User}ActiveDirectoryPolicyManager into a single class

chrome/browser/chromeos/policy/user_policy_manager_factory_chromeos.cc

 // Copyright (c) 2013 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/chromeos/policy/user_policy_manager_factory_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/policy/active_directory_policy_manager.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
-#include "chrome/browser/chromeos/policy/user_active_directory_policy_manager.h"
 #include "chrome/browser/chromeos/policy/user_cloud_external_data_manager.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/install_attributes.h"
 #include "chrome/browser/policy/schema_registry_service.h"
 #include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chromeos/chromeos_paths.h"
@@ skipping 52 matching lines @@
 }
 
 // static
 UserCloudPolicyManagerChromeOS*
 UserPolicyManagerFactoryChromeOS::GetCloudPolicyManagerForProfile(
     Profile* profile) {
   return GetInstance()->GetCloudPolicyManager(profile);
 }
 
 // static
-UserActiveDirectoryPolicyManager*
+ActiveDirectoryPolicyManager*
 UserPolicyManagerFactoryChromeOS::GetActiveDirectoryPolicyManagerForProfile(
     Profile* profile) {
   return GetInstance()->GetActiveDirectoryPolicyManager(profile);
 }
 
 // static
 std::unique_ptr<ConfigurationPolicyProvider>
 UserPolicyManagerFactoryChromeOS::CreateForProfile(
     Profile* profile,
     bool force_immediate_load,
@@ skipping 12 matching lines @@
 UserPolicyManagerFactoryChromeOS::~UserPolicyManagerFactoryChromeOS() {}
 
 UserCloudPolicyManagerChromeOS*
 UserPolicyManagerFactoryChromeOS::GetCloudPolicyManager(Profile* profile) {
   // Get the manager for the original profile, since the PolicyService is
   // also shared between the incognito Profile and the original Profile.
   const auto it = cloud_managers_.find(profile->GetOriginalProfile());
   return it != cloud_managers_.end() ? it->second : nullptr;
 }
 
-UserActiveDirectoryPolicyManager*
+ActiveDirectoryPolicyManager*
 UserPolicyManagerFactoryChromeOS::GetActiveDirectoryPolicyManager(
     Profile* profile) {
   // Get the manager for the original profile, since the PolicyService is
   // also shared between the incognito Profile and the original Profile.
   const auto it =
       active_directory_managers_.find(profile->GetOriginalProfile());
   return it != active_directory_managers_.end() ? it->second : nullptr;
 }
 
 std::unique_ptr<ConfigurationPolicyProvider>
@@ skipping 14 matching lines @@
   // |user| should never be nullptr except for the signin profile. This object
   // is created as part of the Profile creation, which happens right after
   // sign-in. The just-signed-in User is the active user during that time.
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
   CHECK(user);
 
   // User policy exists for enterprise accounts only:
   // - For regular cloud-managed users (those who have a GAIA account), a
   //   |UserCloudPolicyManagerChromeOS| is created here.
-  // - For Active Directory managed users, a |UserActiveDirectoryPolicyManager|
+  // - For Active Directory managed users, an |ActiveDirectoryPolicyManager|
   //   is created.
   // - For device-local accounts, policy is provided by
   //   |DeviceLocalAccountPolicyService|.
   // All other user types do not have user policy.
   const AccountId& account_id = user->GetAccountId();
   if (user->IsSupervised() ||
       BrowserPolicyConnector::IsNonEnterpriseUser(account_id.GetUserEmail())) {
     return {};
   }
 
@@ skipping 79 matching lines @@
                                        backend_task_runner, io_task_runner,
                                        external_data_dir, store.get()));
   if (force_immediate_load)
     store->LoadImmediately();
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::FILE);
 
   if (is_active_directory) {
-    std::unique_ptr<UserActiveDirectoryPolicyManager> manager =
-        base::MakeUnique<UserActiveDirectoryPolicyManager>(account_id,
-                                                           std::move(store));
+    std::unique_ptr<ActiveDirectoryPolicyManager> manager =
+        ActiveDirectoryPolicyManager::CreateForUserPolicy(account_id,
+                                                          std::move(store));
     manager->Init(
         SchemaRegistryServiceFactory::GetForContext(profile)->registry());
 
     active_directory_managers_[profile] = manager.get();
     return std::move(manager);
   } else {
     std::unique_ptr<UserCloudPolicyManagerChromeOS> manager =
         base::MakeUnique<UserCloudPolicyManagerChromeOS>(
             std::move(store), std::move(external_data_manager),
             component_policy_cache_dir, wait_for_policy_fetch,
@@ skipping 23 matching lines @@
 
 void UserPolicyManagerFactoryChromeOS::BrowserContextShutdown(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   if (profile->IsOffTheRecord())
     return;
   UserCloudPolicyManagerChromeOS* cloud_manager =
       GetCloudPolicyManager(profile);
   if (cloud_manager)
     cloud_manager->Shutdown();
-  UserActiveDirectoryPolicyManager* active_directory_manager =
+  ActiveDirectoryPolicyManager* active_directory_manager =
       GetActiveDirectoryPolicyManager(profile);
   if (active_directory_manager)
     active_directory_manager->Shutdown();
 }
 
 void UserPolicyManagerFactoryChromeOS::BrowserContextDestroyed(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   cloud_managers_.erase(profile);
   active_directory_managers_.erase(profile);
   BrowserContextKeyedBaseFactory::BrowserContextDestroyed(context);
 }
 
 void UserPolicyManagerFactoryChromeOS::SetEmptyTestingFactory(
     content::BrowserContext* context) {}
 
 bool UserPolicyManagerFactoryChromeOS::HasTestingFactory(
     content::BrowserContext* context) {
   return false;
 }
 
 void UserPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy