Fix device policy recovery on CrOS login

chrome/browser/chromeos/login/parallel_authenticator_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/login/parallel_authenticator.h"
 
 #include <string>
 
+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/login/mock_login_status_consumer.h"
 #include "chrome/browser/chromeos/login/mock_url_fetchers.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/test_attempt_state.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
 #include "chromeos/cryptohome/mock_cryptohome_library.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/mock_url_fetcher_factory.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 13 matching lines @@
       : OnlineAttempt(state, resolver) {
   }
 };
 
 class ParallelAuthenticatorTest : public testing::Test {
  public:
   ParallelAuthenticatorTest()
       : username_("me@nowhere.org"),
         password_("fakepass"),
         hash_ascii_("0a010000000000a0" + std::string(16, '0')),
-        user_manager_enabler_(new MockUserManager) {
+        user_manager_enabler_(new MockUserManager),
+        mock_caller_(NULL) {
   }
 
   virtual ~ParallelAuthenticatorTest() {
     DCHECK(!mock_caller_);
   }
 
   virtual void SetUp() {
+    CommandLine::ForCurrentProcess()->AppendSwitch(switches::kLoginManager);
+
     mock_caller_ = new cryptohome::MockAsyncMethodCaller;
     cryptohome::AsyncMethodCaller::InitializeForTesting(mock_caller_);
 
     mock_cryptohome_library_ .reset(new MockCryptohomeLibrary());
     CryptohomeLibrary::SetForTest(mock_cryptohome_library_.get());
 
     auth_ = new ParallelAuthenticator(&consumer_);
     state_.reset(new TestAttemptState(UserContext(username_,
                                                   password_,
                                                   std::string()),
@@ skipping 244 matching lines @@
   SetOwnerState(false, false);
   // Remove the real DeviceSettingsProvider and replace it with a stub.
   device_settings_provider =
       CrosSettings::Get()->GetProvider(chromeos::kReportDeviceVersionInfo);
   EXPECT_TRUE(device_settings_provider != NULL);
   EXPECT_TRUE(
       CrosSettings::Get()->RemoveSettingsProvider(device_settings_provider));
   CrosSettings::Get()->AddSettingsProvider(&stub_settings_provider);
   CrosSettings::Get()->SetBoolean(kPolicyMissingMitigationMode, true);
 
+  // Initialize login state for this test to verify the login state is changed
+  // to SAFE_MODE.
+  LoginState::Initialize();
+
   EXPECT_EQ(ParallelAuthenticator::CONTINUE,
             SetAndResolveState(auth_.get(), state_.release()));
-  // Let the owner verification run.
+  EXPECT_TRUE(LoginState::Get()->IsInSafeMode());
+
+  // Simulate certificates load event. The exact certificates loaded are not
+  // actually used by the DeviceSettingsService, so it is OK to pass an empty
+  // list.
+  DeviceSettingsService::Get()->OnCertificatesLoaded(net::CertificateList(),
+                                                     true);
+  // Flush all the pending operations. The operations should induce an owner
+  // verification.
   device_settings_test_helper_.Flush();
   // and test that the mount has succeeded.
   state_.reset(new TestAttemptState(UserContext(username_,
                                                 password_,
                                                 std::string()),
                                     hash_ascii_,
                                     "",
                                     "",
                                     User::USER_TYPE_REGULAR,
                                     false));
   state_->PresetCryptohomeStatus(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_EQ(ParallelAuthenticator::OWNER_REQUIRED,
             SetAndResolveState(auth_.get(), state_.release()));
 
+  // Unset global objects used by this test.
+  LoginState::Shutdown();
   EXPECT_TRUE(
       CrosSettings::Get()->RemoveSettingsProvider(&stub_settings_provider));
   CrosSettings::Get()->AddSettingsProvider(device_settings_provider);
   DBusThreadManager::Get()->Shutdown();
 }
 
 TEST_F(ParallelAuthenticatorTest, DriveFailedMount) {
   FailOnLoginSuccess();
   ExpectLoginFailure(LoginFailure(LoginFailure::COULD_NOT_MOUNT_CRYPTOHOME));
 
@@ skipping 276 matching lines @@
       .WillOnce(Return(std::string()))
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(UserContext(username_,
                                           std::string(),
                                           std::string()));
   base::MessageLoop::current()->Run();
 }
 
 }  // namespace chromeos