Handle policy refresh internally in ConfigurationPolicyPrefStore.

chrome/browser/policy/device_management_policy_provider_unittest.cc

 // Copyright (c) 2010 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 "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
@@ skipping 21 matching lines @@
  public:
   DeviceManagementPolicyProviderTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~DeviceManagementPolicyProviderTest() {}
 
   virtual void SetUp() {
     profile_.reset(new TestingProfile);
     CreateNewProvider();
-    EXPECT_TRUE(provider_->waiting_for_initial_policies());
+    EXPECT_TRUE(waiting_for_initial_policies());
     loop_.RunAllPending();
   }
 
   void CreateNewProvider() {
     backend_ = new MockDeviceManagementBackend;
     provider_.reset(new DeviceManagementPolicyProvider(
         ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
         backend_,
         profile_.get()));
     provider_->SetDeviceTokenFetcher(
@@ skipping 39 matching lines @@
   }
 
   void SimulateSuccessfulInitialPolicyFetch() {
     MockConfigurationPolicyStore store;
     EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedRegister());
     EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedBooleanPolicy(
             key::kDisableSpdy, true));
     SimulateSuccessfulLoginAndRunPending();
-    EXPECT_FALSE(provider_->waiting_for_initial_policies());
+    EXPECT_FALSE(waiting_for_initial_policies());
     EXPECT_CALL(store, Apply(kPolicyDisableSpdy, _)).Times(1);
     provider_->Provide(&store);
     ASSERT_EQ(1U, store.policy_map().size());
     Mock::VerifyAndClearExpectations(backend_);
     Mock::VerifyAndClearExpectations(&store);
   }
 
   virtual void TearDown() {
     loop_.RunAllPending();
   }
 
+  bool waiting_for_initial_policies() {

[danno, 2010/12/22 14:00:19]

const

[Mattias Nissler (ping if slow), 2010/12/22 14:11:04]

Done.

+    return provider_->waiting_for_initial_policies_;
+  }
+
   MockDeviceManagementBackend* backend_;  // weak
   scoped_ptr<DeviceManagementPolicyProvider> provider_;
 
  protected:
   DeviceManagementPolicyCache* cache(DeviceManagementPolicyProvider* provider) {
     return provider->cache_.get();
   }
 
   MessageLoop loop_;
 
  private:
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
   scoped_ptr<Profile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyProviderTest);
 };
 
 // If there's no login and no previously-fetched policy, the provider should
 // provide an empty policy.
 TEST_F(DeviceManagementPolicyProviderTest, InitialProvideNoLogin) {
   MockConfigurationPolicyStore store;
   EXPECT_CALL(store, Apply(_, _)).Times(0);
   provider_->Provide(&store);
   EXPECT_TRUE(store.policy_map().empty());
-  EXPECT_TRUE(provider_->waiting_for_initial_policies());
+  EXPECT_TRUE(waiting_for_initial_policies());
 }
 
 // If the login is successful and there's no previously-fetched policy, the
 // policy should be fetched from the server and should be available the first
 // time the Provide method is called.
 TEST_F(DeviceManagementPolicyProviderTest, InitialProvideWithLogin) {
-  EXPECT_TRUE(provider_->waiting_for_initial_policies());
+  EXPECT_TRUE(waiting_for_initial_policies());
   SimulateSuccessfulInitialPolicyFetch();
 }
 
 // If the login succeed but the device management backend is unreachable,
 // there should be no policy provided if there's no previously-fetched policy,
 TEST_F(DeviceManagementPolicyProviderTest, EmptyProvideWithFailedBackend) {
   MockConfigurationPolicyStore store;
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailRegister(
           DeviceManagementBackend::kErrorRequestFailed));
@@ skipping 141 matching lines @@
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailRegister(
           DeviceManagementBackend::kErrorServiceManagementNotSupported));
   SimulateSuccessfulLoginAndRunPending();
   // (1) The provider's DMPolicyCache should know that the device is not
   // managed.
   EXPECT_TRUE(cache(provider_.get())->is_device_unmanaged());
   // (2) On restart, the provider should detect that this is not the first
   // login.
   CreateNewProvider(1000*1000, 0, 0, 0, 0);
-  EXPECT_FALSE(provider_->waiting_for_initial_policies());
+  EXPECT_FALSE(waiting_for_initial_policies());
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedRegister());
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
   // (3) Since the backend call this time returned a device id, the "unmanaged"
   // marker should have been deleted.
   EXPECT_FALSE(cache(provider_.get())->is_device_unmanaged());
 }
 
 }  // namespace policy