Add policy domain for signin screen apps

components/policy/core/common/schema_registry.cc

 // Copyright 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 "components/policy/core/common/schema_registry.h"
 
 #include "base/logging.h"
 
 namespace policy {
 
 SchemaRegistry::Observer::~Observer() {}
 
 SchemaRegistry::InternalObserver::~InternalObserver() {}
 
 SchemaRegistry::SchemaRegistry() : schema_map_(new SchemaMap) {
   for (int i = 0; i < POLICY_DOMAIN_SIZE; ++i)
     domains_ready_[i] = false;
 #if !defined(ENABLE_EXTENSIONS)
-  domains_ready_[POLICY_DOMAIN_EXTENSIONS] = true;
+  SetExtensionsDomainsReady();
 #endif
 }
 
 SchemaRegistry::~SchemaRegistry() {
   for (auto& observer : internal_observers_)
     observer.OnSchemaRegistryShuttingDown(this);
 }
 
 void SchemaRegistry::RegisterComponent(const PolicyNamespace& ns,
                                        const Schema& schema) {
@@ skipping 39 matching lines @@
 void SchemaRegistry::SetReady(PolicyDomain domain) {
   if (domains_ready_[domain])
     return;
   domains_ready_[domain] = true;
   if (IsReady()) {
     for (auto& observer : observers_)
       observer.OnSchemaRegistryReady();
   }
 }
 
+void SchemaRegistry::SetAllDomainsReady() {
+  for (int i = 0; i < POLICY_DOMAIN_SIZE; ++i)
+    SetReady(static_cast<PolicyDomain>(i));
+}
+
+void SchemaRegistry::SetExtensionsDomainsReady() {
+  SetReady(POLICY_DOMAIN_EXTENSIONS);
+  SetReady(POLICY_DOMAIN_SIGNIN_EXTENSIONS);
+}
+
 void SchemaRegistry::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void SchemaRegistry::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void SchemaRegistry::AddInternalObserver(InternalObserver* observer) {
   internal_observers_.AddObserver(observer);
 }
 
 void SchemaRegistry::RemoveInternalObserver(InternalObserver* observer) {
   internal_observers_.RemoveObserver(observer);
 }
 
 void SchemaRegistry::Notify(bool has_new_schemas) {
   for (auto& observer : observers_)
     observer.OnSchemaRegistryUpdated(has_new_schemas);
 }
 
 CombinedSchemaRegistry::CombinedSchemaRegistry()
     : own_schema_map_(new SchemaMap) {
   // The combined registry is always ready, since it can always start tracking
   // another registry that is not ready yet and going from "ready" to "not
   // ready" is not allowed.
-  for (int i = 0; i < POLICY_DOMAIN_SIZE; ++i)
-    SetReady(static_cast<PolicyDomain>(i));
+  SetAllDomainsReady();
 }
 
 CombinedSchemaRegistry::~CombinedSchemaRegistry() {}
 
 void CombinedSchemaRegistry::Track(SchemaRegistry* registry) {
   registries_.insert(registry);
   registry->AddObserver(this);
   registry->AddInternalObserver(this);
   // Recombine the maps only if the |registry| has any components other than
   // POLICY_DOMAIN_CHROME.
@@ skipping 107 matching lines @@
 void ForwardingSchemaRegistry::OnSchemaRegistryShuttingDown(
     SchemaRegistry* registry) {
   DCHECK_EQ(wrapped_, registry);
   wrapped_->RemoveObserver(this);
   wrapped_->RemoveInternalObserver(this);
   wrapped_ = NULL;
   // Keep serving the same |schema_map_|.
 }
 
 }  // namespace policy