Support cloud policy for extensions on the desktop platforms.

chrome/browser/chromeos/policy/user_cloud_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_cloud_policy_manager_factory_chromeos.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 namespace {
 
 // Subdirectory in the user's profile for storing legacy user policies.
 const base::FilePath::CharType kDeviceManagementDir[] =
     FILE_PATH_LITERAL("Device Management");
+
 // File in the above directory for storing legacy user policy dmtokens.
 const base::FilePath::CharType kToken[] = FILE_PATH_LITERAL("Token");
+
 // This constant is used to build two different paths. It can be a file inside
 // kDeviceManagementDir where legacy user policy data is stored, and it can be
 // a directory inside the profile directory where other resources are stored.
 const base::FilePath::CharType kPolicy[] = FILE_PATH_LITERAL("Policy");
-// Directory under kPolicy, in the user's profile dir, where external policy
-// resources are stored.
-const base::FilePath::CharType kResourceDir[] = FILE_PATH_LITERAL("Resources");
+
+// Directory under kPolicy, in the user's profile dir, where policy for
+// components is cached.
+const base::FilePath::CharType kComponentsDir[] =
+    FILE_PATH_LITERAL("Components");
+
 // Directory in which to store external policy data. This is specified relative
 // to kPolicy.
 const base::FilePath::CharType kPolicyExternalDataDir[] =
     FILE_PATH_LITERAL("External Data");
 
 // Timeout in seconds after which to abandon the initial policy fetch and start
 // the session regardless.
 const int kInitialPolicyFetchTimeoutSeconds = 10;
 
 }  // namespace
@@ skipping 80 matching lines @@
 
   DeviceManagementService* device_management_service =
       connector->device_management_service();
   if (wait_for_initial_policy)
     device_management_service->ScheduleInitialization(0);
 
   base::FilePath profile_dir = profile->GetPath();
   const base::FilePath legacy_dir = profile_dir.Append(kDeviceManagementDir);
   const base::FilePath policy_cache_file = legacy_dir.Append(kPolicy);
   const base::FilePath token_cache_file = legacy_dir.Append(kToken);
-  const base::FilePath resource_cache_dir =
-      profile_dir.Append(kPolicy).Append(kResourceDir);
+  const base::FilePath component_policy_cache_dir =
+      profile_dir.Append(kPolicy).Append(kComponentsDir);
   const base::FilePath external_data_dir =
         profile_dir.Append(kPolicy).Append(kPolicyExternalDataDir);
   base::FilePath policy_key_dir;
   CHECK(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &policy_key_dir));
 
   scoped_ptr<UserCloudPolicyStoreChromeOS> store(
       new UserCloudPolicyStoreChromeOS(
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient(),
           chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
           background_task_runner,
           username, policy_key_dir, token_cache_file, policy_cache_file));
 
   scoped_refptr<base::SequencedTaskRunner> backend_task_runner =
       content::BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
           content::BrowserThread::GetBlockingPool()->GetSequenceToken());
   scoped_refptr<base::SequencedTaskRunner> io_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO);
   scoped_ptr<CloudExternalDataManager> external_data_manager(
       new UserCloudExternalDataManager(base::Bind(&GetChromePolicyDetails),
                                        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::GetMessageLoopProxyForThread(
+          content::BrowserThread::FILE);
+
   scoped_ptr<UserCloudPolicyManagerChromeOS> manager(
       new UserCloudPolicyManagerChromeOS(
           store.PassAs<CloudPolicyStore>(),
           external_data_manager.Pass(),
+          component_policy_cache_dir,
+          wait_for_initial_policy,
+          base::TimeDelta::FromSeconds(kInitialPolicyFetchTimeoutSeconds),
           base::MessageLoopProxy::current(),
-          resource_cache_dir,
-          wait_for_initial_policy,
-          base::TimeDelta::FromSeconds(kInitialPolicyFetchTimeoutSeconds)));
+          file_task_runner,
+          io_task_runner));
   manager->Init(SchemaRegistryServiceFactory::GetForContext(profile));
   manager->Connect(g_browser_process->local_state(),
                    device_management_service,
                    g_browser_process->system_request_context(),
                    affiliation);
 
   DCHECK(managers_.find(profile) == managers_.end());
   managers_[profile] = manager.get();
   return manager.Pass();
 }
@@ skipping 15 matching lines @@
   BrowserContextKeyedBaseFactory::BrowserContextDestroyed(context);
 }
 
 void UserCloudPolicyManagerFactoryChromeOS::SetEmptyTestingFactory(
     content::BrowserContext* context) {}
 
 void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy