Enable fetching of admin policies for login 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 {
 
@@ skipping 168 matching lines @@
       for (ComponentMap::const_iterator comp_it = reg_component_map.begin();
            comp_it != reg_component_map.end(); ++comp_it) {
         map[domain_it->first][comp_it->first] = comp_it->second;
       }
     }
   }
   schema_map_ = new SchemaMap(map);
   Notify(has_new_schemas);
 }
 
-ForwardingSchemaRegistry::ForwardingSchemaRegistry(SchemaRegistry* wrapped)
-    : wrapped_(wrapped) {
+ForwardingSchemaRegistry::ForwardingSchemaRegistry(SchemaRegistry* wrapped,
+                                                   bool forward_readiness)
+    : wrapped_(wrapped), forward_readiness_(forward_readiness) {
   schema_map_ = wrapped_->schema_map();
   wrapped_->AddObserver(this);
   wrapped_->AddInternalObserver(this);
+  UpdateReadiness();
 }
 
 ForwardingSchemaRegistry::~ForwardingSchemaRegistry() {
   if (wrapped_) {
     wrapped_->RemoveObserver(this);
     wrapped_->RemoveInternalObserver(this);
   }
 }
 
 void ForwardingSchemaRegistry::RegisterComponents(
@@ skipping 11 matching lines @@
   if (wrapped_)
     wrapped_->UnregisterComponent(ns);
   // Ignore otherwise.
 }
 
 void ForwardingSchemaRegistry::OnSchemaRegistryUpdated(bool has_new_schemas) {
   schema_map_ = wrapped_->schema_map();
   Notify(has_new_schemas);
 }
 
+void ForwardingSchemaRegistry::OnSchemaRegistryReady() {
+  UpdateReadiness();
+}
+
 void ForwardingSchemaRegistry::OnSchemaRegistryShuttingDown(
     SchemaRegistry* registry) {
   DCHECK_EQ(wrapped_, registry);
   wrapped_->RemoveObserver(this);
   wrapped_->RemoveInternalObserver(this);
   wrapped_ = NULL;
   // Keep serving the same |schema_map_|.
 }
 
+void ForwardingSchemaRegistry::UpdateReadiness() {

[Andrew T Wilson (Slow), 2016/10/28 14:49:56]

How can UpdateReadiness() be called when wrapped_ is NULL? You remove the
observer before setting it to null.

Also, not totally clear when you *wouldn't* want forward_readiness_ = true. Can
you clarify this in the class documentation (i.e. exactly when it becomes ready
when forward_readiness_ = false)?

[emaxx, 2016/10/31 15:51:20]

You are right, check for NULL wrapped_ is unnecessary. I've remove it.
I introduced this flag because I was afraid to break the existing code by this
change.

The original behavior of this class was to have separate readiness state for the
wrapped registry and for the forwarding registry.
This may make sense in some scenarios: imagine a piece of code that accepts a
registry and is then controlling its readiness in one part and observing it in
another part - then it's really important to not have any unexpected switches of
the readiness.

So what I found in the existing code was the following structure:

1. The DeviceLocalAccountPolicyBroker instance owns a SchemaRegistry instance.
2. The DeviceLocalAccountExtensionTracker class contains a code that calls
SetReady method on this SchemaRegistry.
3. The ComponentCloudPolicyService instance observes the readiness state of that
same SchemaRegistry.
4. ProfileImpl constructor calls SchemaRegistryServiceFactory::CreateForContext,
which internally creates a ForwardingSchemaRegistry instance that wraps that
same SchemaRegistry.
5. Now all the profile-tied stuff that works with SchemaRegistry* is in case of
device-local account really working with a ForwardingSchemaRegistry instance.
For instance, a ManagedValueStoreCache::ExtensionTracker instance is constructed
that calls SetReady on the registry. And there is a number of observers of the
registry state.

So I really don't know how to make sure that none of the observers mentioned in
#5 could actually break if the forwarding schema registry may become ready
earlier...

+  if (forward_readiness_ && wrapped_ && wrapped_->IsReady()) {
+    for (int i = 0; i < POLICY_DOMAIN_SIZE; ++i)
+      SetReady(static_cast<PolicyDomain>(i));
+  }
+}
+
 }  // namespace policy