Chromad: Prevent session from starting without policy

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos_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/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
 const char kOAuth2AccessTokenData[] =
     "{"
     "  \"access_token\": \"5678\","
     "  \"expires_in\": 3600"
     "}";
 
 class UserCloudPolicyManagerChromeOSTest : public testing::Test {
  public:
   // Note: This method has to be public, so that a pointer to it may be obtained
   // in the test.
-  void MakeManagerWithPreloadedStore(bool wait_for_fetch,
-                                     int fetch_timeout_seconds) {
+  void MakeManagerWithPreloadedStore(int fetch_timeout_seconds) {
     std::unique_ptr<MockCloudPolicyStore> store =
         base::MakeUnique<MockCloudPolicyStore>();
     store->policy_.reset(new em::PolicyData(policy_data_));
     store->policy_map_.CopyFrom(policy_map_);
     store->NotifyStoreLoaded();
-    CreateManager(std::move(store), wait_for_fetch, fetch_timeout_seconds);
+    CreateManager(std::move(store), fetch_timeout_seconds);
     // The manager gets already initialized by this point if the store is
     // initialized and there is no blocking for policy fetch.
-    EXPECT_NE(wait_for_fetch,
+    EXPECT_NE(fetch_timeout_seconds != 0,
               manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
     InitAndConnectManager();
     EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   }
 
  protected:
   UserCloudPolicyManagerChromeOSTest()
       : store_(NULL),
         external_data_manager_(NULL),
         task_runner_(new base::TestSimpleTaskRunner()),
@@ skipping 60 matching lines @@
       token_forwarder_->Shutdown();
     if (manager_) {
       manager_->RemoveObserver(&observer_);
       manager_->Shutdown();
     }
     signin_profile_ = NULL;
     profile_ = NULL;
     profile_manager_->DeleteTestingProfile(chrome::kInitialProfile);
   }
 
-  void MakeManagerWithEmptyStore(bool wait_for_fetch, int fetch_timeout) {
+  void MakeManagerWithEmptyStore(int fetch_timeout) {
     std::unique_ptr<MockCloudPolicyStore> store =
         base::MakeUnique<MockCloudPolicyStore>();
     EXPECT_CALL(*store, Load());
-    CreateManager(std::move(store), wait_for_fetch, fetch_timeout);
+    CreateManager(std::move(store), fetch_timeout);
     EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
     InitAndConnectManager();
     Mock::VerifyAndClearExpectations(store_);
     EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
     EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   }
 
   // Expects a pending URLFetcher for the |expected_url|, and returns it with
   // prepared to deliver a response to its delegate.
   net::TestURLFetcher* PrepareOAuthFetcher(const GURL& expected_url) {
@@ skipping 135 matching lines @@
   // Required by ProfileHelper to get the signin Profile context.
   std::unique_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;
   TestingProfile* signin_profile_;
 
   chromeos::FakeChromeUserManager* user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
 
  private:
   void CreateManager(std::unique_ptr<MockCloudPolicyStore> store,
-                     bool wait_for_fetch,
                      int fetch_timeout_seconds) {
     store_ = store.get();
     external_data_manager_ = new MockCloudExternalDataManager;
     external_data_manager_->SetPolicyStore(store_);
     manager_.reset(new UserCloudPolicyManagerChromeOS(
         std::move(store),
         base::WrapUnique<MockCloudExternalDataManager>(external_data_manager_),
-        base::FilePath(), wait_for_fetch,
-        base::TimeDelta::FromSeconds(fetch_timeout_seconds), task_runner_,
-        task_runner_, task_runner_));
+        base::FilePath(), base::TimeDelta::FromSeconds(fetch_timeout_seconds),
+        task_runner_, task_runner_, task_runner_));
     manager_->AddObserver(&observer_);
-    should_create_token_forwarder_ = !wait_for_fetch;
+    should_create_token_forwarder_ = (fetch_timeout_seconds == 0);
   }
 
   void InitAndConnectManager() {
     manager_->Init(&schema_registry_);
     manager_->Connect(&prefs_, &device_management_service_, NULL);
     if (should_create_token_forwarder_) {
       // Create the UserCloudPolicyTokenForwarder, which fetches the access
       // token using the OAuth2PolicyFetcher and forwards it to the
       // UserCloudPolicyManagerChromeOS. This service is automatically created
       // for regular Profiles but not for testing Profiles.
       ProfileOAuth2TokenService* token_service =
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
       ASSERT_TRUE(token_service);
       SigninManagerBase* signin_manager =
           SigninManagerFactory::GetForProfile(profile_);
       ASSERT_TRUE(signin_manager);
       token_forwarder_.reset(new UserCloudPolicyTokenForwarder(
           manager_.get(), token_service, signin_manager));
     }
   }
 
   bool should_create_token_forwarder_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyManagerChromeOSTest);
 };
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFirstFetch) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the policy cache is empty.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreLoaded();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // This starts the OAuth2 policy token fetcher using the signin Profile.
   // The manager will then issue the registration request.
   MockDeviceManagementJob* register_request = IssueOAuthToken(false);
   ASSERT_TRUE(register_request);
 
   // Reply with a valid registration response. This triggers the initial policy
   // fetch.
   FetchPolicy(base::Bind(&MockDeviceManagementJob::SendResponse,
                          base::Unretained(register_request),
                          DM_STATUS_SUCCESS, register_blob_));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingRefreshFetch) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when a previously cached policy and DMToken already exist.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Set the initially cached data and initialize the CloudPolicyService.
   // The initial policy fetch is issued using the cached DMToken.
   store_->policy_.reset(new em::PolicyData(policy_data_));
   FetchPolicy(base::Bind(&MockCloudPolicyStore::NotifyStoreLoaded,
                          base::Unretained(store_)));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest,
        BlockingRefreshFetchWithPreloadedStore) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when a previously cached policy and DMToken are already
   // loaded before the manager is constructed. The manager is still
   // uninitialized after the Init() call, despite that the store is already
   // initialized. The manager becomes initialized only after the policy is
   // fetched, and this is triggered from Connect() with the client registration
   // performed by cloud policy service (as opposed to the registration normally
   // performed by the manager).
   FetchPolicy(base::Bind(
       &UserCloudPolicyManagerChromeOSTest::MakeManagerWithPreloadedStore,
-      base::Unretained(this), true, 1000));
+      base::Unretained(this), 1000));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFetchStoreError) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the initial store load fails.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreError();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // This starts the OAuth2 policy token fetcher using the signin Profile.
   // The manager will then issue the registration request.
   MockDeviceManagementJob* register_request = IssueOAuthToken(false);
   ASSERT_TRUE(register_request);
 
   // Reply with a valid registration response. This triggers the initial policy
   // fetch.
   FetchPolicy(base::Bind(&MockDeviceManagementJob::SendResponse,
                          base::Unretained(register_request),
                          DM_STATUS_SUCCESS, register_blob_));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFetchOAuthError) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the OAuth2 token fetch fails.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreLoaded();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // This starts the OAuth2 policy token fetcher using the signin Profile.
   // The manager will initialize with no policy after the token fetcher fails.
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
 
   // The PolicyOAuth2TokenFetcher posts delayed retries on some errors. This
   // data will make it fail immediately.
   net::TestURLFetcher* fetcher = PrepareOAuthFetcher(
       GaiaUrls::GetInstance()->client_login_to_oauth2_url());
   ASSERT_TRUE(fetcher);
   fetcher->set_response_code(400);
   fetcher->SetResponseString("Error=BadAuthentication");
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(PolicyBundle().Equals(manager_->policies()));
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFetchRegisterError) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the device management registration fails.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreError();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // This starts the OAuth2 policy token fetcher using the signin Profile.
   // The manager will then issue the registration request.
   MockDeviceManagementJob* register_request = IssueOAuthToken(false);
   ASSERT_TRUE(register_request);
 
   // Now make it fail.
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
   register_request->SendResponse(DM_STATUS_TEMPORARY_UNAVAILABLE,
                                  em::DeviceManagementResponse());
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(PolicyBundle().Equals(manager_->policies()));
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFetchPolicyFetchError) {
   // Tests the initialization of a manager whose Profile is waiting for the
   // initial fetch, when the policy fetch request fails.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreLoaded();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // This starts the OAuth2 policy token fetcher using the signin Profile.
   // The manager will then issue the registration request.
   MockDeviceManagementJob* register_request = IssueOAuthToken(false);
@@ skipping 18 matching lines @@
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get())).Times(AtLeast(1));
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   policy_request->SendResponse(DM_STATUS_TEMPORARY_UNAVAILABLE,
                                em::DeviceManagementResponse());
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(PolicyBundle().Equals(manager_->policies()));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, BlockingFetchTimeout) {
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(true, 1000));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(1000));
 
   // Initialize the CloudPolicyService without any stored data.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   store_->NotifyStoreLoaded();
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->core()->client()->is_registered());
 
   // Triggering the timeout should invoke our callback.
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get())).Times(AtLeast(1));
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   manager_->ForceTimeoutForTest();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(PolicyBundle().Equals(manager_->policies()));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, NonBlockingFirstFetch) {
   // Tests the first policy fetch request by a Profile that isn't managed.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(false, 0));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(0));
 
   // Initialize the CloudPolicyService without any stored data. Since the
   // manager is not waiting for the initial fetch, it will become initialized
   // once the store is ready.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
   store_->NotifyStoreLoaded();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
@@ skipping 25 matching lines @@
 
   // The refresh scheduler takes care of the initial fetch for unmanaged users.
   // Running the task runner issues the initial fetch.
   FetchPolicy(
       base::Bind(&base::TestSimpleTaskRunner::RunUntilIdle, task_runner_));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest, NonBlockingRefreshFetch) {
   // Tests a non-blocking initial policy fetch for a Profile that already has
   // a cached DMToken.
-  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(false, 0));
+  ASSERT_NO_FATAL_FAILURE(MakeManagerWithEmptyStore(0));
 
   // Set the initially cached data and initialize the CloudPolicyService.
   // The initial policy fetch is issued using the cached DMToken.
   EXPECT_FALSE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
   store_->policy_.reset(new em::PolicyData(policy_data_));
   store_->NotifyStoreLoaded();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(manager_->core()->service()->IsInitializationComplete());
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
   EXPECT_TRUE(manager_->core()->client()->is_registered());
 
   // The refresh scheduler takes care of the initial fetch for unmanaged users.
   // Running the task runner issues the initial fetch.
   FetchPolicy(
       base::Bind(&base::TestSimpleTaskRunner::RunUntilIdle, task_runner_));
 }
 
 TEST_F(UserCloudPolicyManagerChromeOSTest,
        NonBlockingRefreshFetchWithPreloadedStore) {
   // Tests the initialization of a manager with non-blocking initial policy
   // fetch, when a previously cached policy and DMToken are already loaded
   // before the manager is constructed. The manager gets initialized straight
   // away after the construction.
-  MakeManagerWithPreloadedStore(false, 0);
+  MakeManagerWithPreloadedStore(0);
   EXPECT_TRUE(manager_->policies().Equals(expected_bundle_));
 }
 
 }  // namespace policy