UserPolicyCache only becomes ready after policy has been fetched.

chrome/browser/policy/user_policy_cache.cc

 // Copyright (c) 2011 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/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 10 matching lines @@
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 // Decodes a CloudPolicySettings object into two maps with mandatory and
 // recommended settings, respectively. The implementation is generated code
 // in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   PolicyMap* mandatory, PolicyMap* recommended);
 
-UserPolicyCache::UserPolicyCache(const FilePath& backing_file_path)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+UserPolicyCache::UserPolicyCache(const FilePath& backing_file_path,
+                                 bool wait_for_policy_fetch)
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
+      disk_cache_ready_(false),
+      fetch_ready_(!wait_for_policy_fetch) {
   disk_cache_ = new UserPolicyDiskCache(weak_ptr_factory_.GetWeakPtr(),
                                         backing_file_path);
 }
 
 UserPolicyCache::~UserPolicyCache() {
 }
 
 void UserPolicyCache::Load() {
   disk_cache_->Load();
 }
@@ skipping 22 matching lines @@
 void UserPolicyCache::SetUnmanaged() {
   DCHECK(CalledOnValidThread());
   SetUnmanagedInternal(base::Time::NowFromSystemTime());
 
   em::CachedCloudPolicyResponse cached_policy;
   cached_policy.set_unmanaged(true);
   cached_policy.set_timestamp(base::Time::NowFromSystemTime().ToTimeT());
   disk_cache_->Store(cached_policy);
 }
 
+void UserPolicyCache::SetFetchingDone() {
+  if (!fetch_ready_)
+    DVLOG(1) << "SetFetchingDone, cache is now fetch_ready_";
+  fetch_ready_ = true;
+  CheckIfReady();
+}
+
 void UserPolicyCache::OnDiskCacheLoaded(
     UserPolicyDiskCache::LoadResult result,
     const em::CachedCloudPolicyResponse& cached_response) {
   if (IsReady())
     return;
 
   if (result == UserPolicyDiskCache::LOAD_RESULT_SUCCESS) {
     if (cached_response.unmanaged()) {
       SetUnmanagedInternal(base::Time::FromTimeT(cached_response.timestamp()));
     } else if (cached_response.has_cloud_policy()) {
       base::Time timestamp;
       if (SetPolicyInternal(cached_response.cloud_policy(), &timestamp, true))
         set_last_policy_refresh_time(timestamp);
     }
   }
 
   // Ready to feed policy up the chain!
-  SetReady();
+  disk_cache_ready_ = true;
+  CheckIfReady();
 }
 
 bool UserPolicyCache::DecodePolicyData(const em::PolicyData& policy_data,
                                        PolicyMap* mandatory,
                                        PolicyMap* recommended) {
   // TODO(jkummerow): Verify policy_data.device_token(). Needs final
   // specification which token we're actually sending / expecting to get back.
   em::CloudPolicySettings policy;
   if (!policy.ParseFromString(policy_data.policy_value())) {
     LOG(WARNING) << "Failed to parse CloudPolicySettings protobuf.";
     return false;
   }
   DecodePolicy(policy, mandatory, recommended);
   MaybeDecodeOldstylePolicy(policy_data.policy_value(), mandatory, recommended);
   return true;
 }
 
+void UserPolicyCache::CheckIfReady() {
+  if (!IsReady() && disk_cache_ready_ && fetch_ready_)
+    SetReady();
+}
+
 // Everything below is only needed for supporting old-style GenericNamedValue
 // based policy data and can be removed once this support is no longer needed.
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 
 void UserPolicyCache::MaybeDecodeOldstylePolicy(
     const std::string& policy_data,
     PolicyMap* mandatory,
     PolicyMap* recommended) {
@@ skipping 98 matching lines @@
       return list;
     }
     default:
       NOTREACHED() << "Unhandled value type";
   }
 
   return NULL;
 }
 
 }  // namespace policy