Explicitly wait for user policy before completing login.

chrome/browser/policy/user_policy_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/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/proto/old_generic_format.pb.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 // Decodes a CloudPolicySettings object into a PolicyMap. All the policies will
 // be POLICY_SCOPE_USER. The PolicyLevel is decoded from the protobuf.
 // The implementation is generated code in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy, PolicyMap* map);
 
 UserPolicyCache::UserPolicyCache(const FilePath& backing_file_path,
-                                 bool wait_for_policy_fetch)
+                                 bool wait_for_policy_fetch,
+                                 const base::Closure& callback)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       disk_cache_ready_(false),
-      fetch_ready_(!wait_for_policy_fetch) {
+      fetch_ready_(!wait_for_policy_fetch),
+      ready_callback_(callback) {
   disk_cache_ = new UserPolicyDiskCache(weak_ptr_factory_.GetWeakPtr(),
                                         backing_file_path);
 }
 
 UserPolicyCache::~UserPolicyCache() {
 }
 
 void UserPolicyCache::Load() {
   disk_cache_->Load();
 }
@@ skipping 66 matching lines @@
   if (!policy.ParseFromString(policy_data.policy_value())) {
     LOG(WARNING) << "Failed to parse CloudPolicySettings protobuf.";
     return false;
   }
   DecodePolicy(policy, policies);
   MaybeDecodeOldstylePolicy(policy_data.policy_value(), policies);
   return true;
 }
 
 void UserPolicyCache::CheckIfReady() {
-  if (!IsReady() && disk_cache_ready_ && fetch_ready_)
+  if (!IsReady() && disk_cache_ready_ && fetch_ready_) {
     SetReady();

[Mattias Nissler (ping if slow), 2012/02/16 10:24:11]

Are you going to clean up all the existing ready-state stuff in a later CL?

+    if (!ready_callback_.is_null()) {
+      ready_callback_.Run();
+      ready_callback_.Reset();
+    }
+  }
 }
 
 // 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,
@@ skipping 99 matching lines @@
       return list;
     }
     default:
       NOTREACHED() << "Unhandled value type";
   }
 
   return NULL;
 }
 
 }  // namespace policy