Explicitly wait for user policy before completing login.

chrome/browser/policy/user_policy_cache_unittest.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/bind.h"
+#include "base/callback.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/values.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/proto/old_generic_format.pb.h"
 #include "content/test/test_browser_thread.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using testing::_;
 
 namespace em = enterprise_management;
 
+namespace {
+
+// Used to verify if a callback was invoked or not.
+void SetTrue(bool* flag) {

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

Use a MOCK_METHOD on UserPolicyCacheTest instead?

+  *flag = true;
+}
+
+}  // namespace
+
 namespace policy {
 
 // Decodes a CloudPolicySettings object into a PolicyMap.
 // The implementation is generated code in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   PolicyMap* policies);
 
 // The implementations of these methods are in cloud_policy_generated.cc.
 Value* DecodeIntegerValue(google::protobuf::int64 value);
 ListValue* DecodeStringList(const em::StringList& string_list);
@@ skipping 160 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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(*cache.policy()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(UserPolicyCacheTest, LoadNoFile) {
-  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(*cache.policy()));
   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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(*cache.policy()));
   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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   cache.Load();
   loop_.RunAllPending();
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(*cache.policy()));
   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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetPolicy) {
-  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   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(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
   policy = CreateHomepagePolicy("http://www.example.com",
                                 base::Time::NowFromSystemTime(),
                                 em::PolicyOptions::RECOMMENDED);
   SetPolicy(&cache, policy);
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_RECOMMENDED,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, ResetPolicy) {
-  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
 
   em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy);
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 
   em::PolicyFetchResponse* empty_policy =
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, empty_policy);
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, PersistPolicy) {
   {
-    UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+    UserPolicyCache cache(test_file(), false, base::Closure());
     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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   cache.Load();
   loop_.RunAllPending();
   PolicyMap expected;
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   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(key::kHomepageLocation,
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.chromium.org"));
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, SetReady) {
-  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   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(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   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 16 matching lines @@
                                 em::PolicyOptions::RECOMMENDED);
   expected.Set(key::kHomepageLocation,
                POLICY_LEVEL_RECOMMENDED,
                POLICY_SCOPE_USER,
                Value::CreateStringValue("http://www.example.com"));
   SetPolicy(&cache, policy);
   EXPECT_TRUE(expected.Equals(*cache.policy()));
 }
 
 TEST_F(UserPolicyCacheTest, CheckReadyNoWaiting) {
-  UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
+  UserPolicyCache cache(test_file(), false, base::Closure());
   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 */);
+  bool ready_callback_was_invoked_ = false;
+  UserPolicyCache cache(test_file(),
+                        true,
+                        base::Bind(SetTrue, &ready_callback_was_invoked_));
   EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(ready_callback_was_invoked_);
   cache.Load();
   loop_.RunAllPending();
   EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(ready_callback_was_invoked_);
   cache.SetFetchingDone();
   EXPECT_TRUE(cache.IsReady());
+  EXPECT_TRUE(ready_callback_was_invoked_);
 }
 
 TEST_F(UserPolicyCacheTest, CheckReadyWaitForDisk) {
-  UserPolicyCache cache(test_file(), true  /* wait_for_policy_fetch */);
+  bool ready_callback_was_invoked_ = false;
+  UserPolicyCache cache(test_file(),
+                        true,
+                        base::Bind(SetTrue, &ready_callback_was_invoked_));
   EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(ready_callback_was_invoked_);
   cache.SetFetchingDone();
   EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(ready_callback_was_invoked_);
   cache.Load();
   loop_.RunAllPending();
   EXPECT_TRUE(cache.IsReady());
+  EXPECT_TRUE(ready_callback_was_invoked_);
 }
 
 }  // namespace policy