UserPolicyCache only becomes ready after policy has been fetched.

chrome/browser/policy/user_policy_cache_unittest.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/file_util.h"
@@ skipping 189 matching lines @@
   string_list.add_entries("ponies");
   string_list.add_entries("more ponies");
   scoped_ptr<ListValue> decoded(DecodeStringList(string_list));
   ListValue expected;
   expected.Append(Value::CreateStringValue("ponies"));
   expected.Append(Value::CreateStringValue("more ponies"));
   EXPECT_TRUE(decoded->Equals(&expected));
 }
 
 TEST_F(UserPolicyCacheTest, Empty) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadNoFile) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, RejectFuture) {
   scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime() +
                                base::TimeDelta::FromMinutes(5),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadWithFile) {
   scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
   EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadWithData) {
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(UserPolicyCacheTest, SetPolicy) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy);
   em::PolicyFetchResponse* policy2 =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy2);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   PolicyMap empty;
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
   EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
   SetPolicy(&cache, policy);
   EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(UserPolicyCacheTest, ResetPolicy) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
 
   em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 
   em::PolicyFetchResponse* empty_policy =
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, empty_policy);
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(UserPolicyCacheTest, PersistPolicy) {
   {
-    UserPolicyCache cache(test_file());
+    UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
     scoped_ptr<em::PolicyFetchResponse> policy(
         CreateHomepagePolicy("http://www.example.com",
                              base::Time::NowFromSystemTime(),
                              em::PolicyOptions::MANDATORY));
     cache.SetPolicy(*policy);
   }
 
   loop_.RunAllPending();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(UserPolicyCacheTest, FreshPolicyOverride) {
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
 
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   em::PolicyFetchResponse* updated_policy =
       CreateHomepagePolicy("http://www.chromium.org",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, updated_policy);
 
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.chromium.org"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(UserPolicyCacheTest, SetReady) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   cache.AddObserver(&observer);
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_CALL(observer, OnCacheUpdate(_)).Times(0);
   cache.SetPolicy(*policy);
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   // Switching the cache to ready should send a notification.
   EXPECT_CALL(observer, OnCacheUpdate(_)).Times(1);
   SetReady(&cache);
   cache.RemoveObserver(&observer);
 }
 
 // Test case for the temporary support for GenericNamedValues in the
 // CloudPolicySettings protobuf. Can be removed when this support is no longer
 // required.
 TEST_F(UserPolicyCacheTest, OldStylePolicy) {
-  UserPolicyCache cache(test_file());
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
   em::PolicyFetchResponse* policy = new em::PolicyFetchResponse();
   em::PolicyData signed_response;
   em::LegacyChromeSettingsProto settings;
   em::GenericNamedValue* named_value = settings.add_named_value();
   named_value->set_name("HomepageLocation");
   em::GenericValue* value_container = named_value->mutable_value();
   value_container->set_value_type(em::GenericValue::VALUE_TYPE_STRING);
   value_container->set_string_value("http://www.example.com");
   EXPECT_TRUE(
       settings.SerializeToString(signed_response.mutable_policy_value()));
@@ skipping 12 matching lines @@
   EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
   // If new-style policy comes in, it should override old-style policy.
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
   SetPolicy(&cache, policy);
   EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
+TEST_F(UserPolicyCacheTest, CheckReadyNoWaiting) {
+  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  EXPECT_FALSE(cache.IsReady());
+  cache.Load();
+  loop_.RunAllPending();
+  EXPECT_TRUE(cache.IsReady());
+}
+
+TEST_F(UserPolicyCacheTest, CheckReadyWaitForFetch) {
+  UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
+  EXPECT_FALSE(cache.IsReady());
+  cache.Load();
+  loop_.RunAllPending();
+  EXPECT_FALSE(cache.IsReady());
+  cache.SetFetchingDone();
+  EXPECT_TRUE(cache.IsReady());
+}
+
+TEST_F(UserPolicyCacheTest, CheckReadyWaitForDisk) {
+  UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
+  EXPECT_FALSE(cache.IsReady());
+  cache.SetFetchingDone();
+  EXPECT_FALSE(cache.IsReady());
+  cache.Load();
+  loop_.RunAllPending();
+  EXPECT_TRUE(cache.IsReady());
+}
+
 }  // namespace policy