Enable fetching of admin policies for login screen apps

chrome/browser/extensions/api/storage/managed_value_store_cache.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/extensions/api/storage/managed_value_store_cache.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 21 matching lines @@
 #include "extensions/browser/value_store/value_store_change.h"
 #include "extensions/browser/value_store/value_store_factory.h"
 #include "extensions/common/api/storage.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/one_shot_event.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#endif
+
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace extensions {
 class ExtensionRegistry;
 
 namespace storage = api::storage;
 
 namespace {
 
@@ skipping 179 matching lines @@
   // profile, regardless of its type, therefore all extensions policy domains
   // are marked as ready here.
   schema_registry_->SetExtensionsDomainsReady();
 }
 
 ManagedValueStoreCache::ManagedValueStoreCache(
     BrowserContext* context,
     const scoped_refptr<ValueStoreFactory>& factory,
     const scoped_refptr<SettingsObserverList>& observers)
     : profile_(Profile::FromBrowserContext(context)),
-      policy_domain_(policy::POLICY_DOMAIN_EXTENSIONS),
+      policy_domain_(GetPolicyDomain(profile_)),
       policy_service_(
           policy::ProfilePolicyConnectorFactory::GetForBrowserContext(context)
               ->policy_service()),
       storage_factory_(factory),
       observers_(observers) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   policy_service_->AddObserver(policy_domain_, this);
 
   extension_tracker_.reset(new ExtensionTracker(profile_, policy_domain_));
@@ skipping 72 matching lines @@
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ManagedValueStoreCache::UpdatePolicyOnFILE,
                  base::Unretained(this),
                  ns.component_id,
                  base::Passed(current.DeepCopy())));
 }
 
+// static
+policy::PolicyDomain ManagedValueStoreCache::GetPolicyDomain(Profile* profile) {
+#if defined(OS_CHROMEOS)
+  return chromeos::ProfileHelper::IsSigninProfile(profile)
+             ? policy::POLICY_DOMAIN_SIGNIN_EXTENSIONS
+             : policy::POLICY_DOMAIN_EXTENSIONS;
+#else
+  return policy::POLICY_DOMAIN_EXTENSIONS;
+#endif
+}
+
 void ManagedValueStoreCache::UpdatePolicyOnFILE(
     const std::string& extension_id,
     std::unique_ptr<policy::PolicyMap> current_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   if (!HasStore(extension_id) && current_policy->empty()) {
     // Don't create the store now if there are no policies configured for this
     // extension. If the extension uses the storage.managed API then the store
     // will be created at RunWithValueStoreForExtension().
     return;
@@ skipping 22 matching lines @@
   return raw_store;
 }
 
 bool ManagedValueStoreCache::HasStore(const std::string& extension_id) const {
   // Note: Currently only manage extensions (not apps).
   return storage_factory_->HasSettings(settings_namespace::MANAGED,
                                        kManagedModelType, extension_id);
 }
 
 }  // namespace extensions