Allow signin to continue even if sync is disabled by policy.

chrome/browser/signin/signin_tracker_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/signin/signin_tracker.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/fake_auth_status_provider.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_manager_fake.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnRef;
 
+namespace {
+
 class MockTokenService : public TokenService {
  public:
   MockTokenService() { }
   virtual ~MockTokenService() { }
 
   MOCK_CONST_METHOD1(HasTokenForService, bool(const char*));
 };
 
 ProfileKeyedService* BuildMockTokenService(Profile* profile) {
   return new MockTokenService;
 }
 
 class MockObserver : public SigninTracker::Observer {
  public:
   MockObserver() {}
   ~MockObserver() {}
 
   MOCK_METHOD0(GaiaCredentialsValid, void(void));
   MOCK_METHOD1(SigninFailed, void(const GoogleServiceAuthError&));
   MOCK_METHOD0(SigninSuccess, void(void));
 };
 
+}  // namespace
+
 class SigninTrackerTest : public testing::Test {
  public:
   SigninTrackerTest() {}
   virtual void SetUp() OVERRIDE {
     profile_.reset(ProfileSyncServiceMock::MakeSignedInTestingProfile());
     mock_token_service_ = static_cast<MockTokenService*>(
         TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_.get(), BuildMockTokenService));
     mock_pss_ = static_cast<ProfileSyncServiceMock*>(
         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
@@ skipping 220 matching lines @@
       content::Source<Profile>(profile_.get()),
       content::Details<const GoogleServiceSigninSuccessDetails>(&details));
 
   // Still waiting for auth, so sync state changes should be ignored.
   EXPECT_CALL(*mock_pss_, waiting_for_auth()).WillOnce(Return(true));
   tracker_->OnStateChanged();
   // Now mimic an auth error - this should cause us to fail (not waiting for
   // auth, but still have no credentials).
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
-  EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error));
-  EXPECT_CALL(*mock_pss_, waiting_for_auth()).WillOnce(Return(false));
+  FakeAuthStatusProvider provider(mock_signin_manager_->signin_global_error());
+  provider.set_auth_error(error);
+  EXPECT_CALL(*mock_pss_, waiting_for_auth()).WillRepeatedly(Return(false));
   EXPECT_CALL(observer_, SigninFailed(error));
   tracker_->OnStateChanged();
 }
 
 // Test cases for initial state = SERVICES_INITIALIZING.
 TEST_F(SigninTrackerTest, SigninSuccess) {
   // Reset the |tracker_| and restart with initial state parameter for its
   // constructor later.
   tracker_.reset();
   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
@@ skipping 30 matching lines @@
 }
 
 TEST_F(SigninTrackerTest, SigninFailedGoogleServiceAuthError) {
   tracker_.reset();
   EXPECT_CALL(*mock_token_service_, HasTokenForService(_))
       .WillRepeatedly(Return(true));
   mock_signin_manager_->StartSignInWithCredentials("0", "username@gmail.com",
                                                    "password");
   // Inject authentication error.
   GoogleServiceAuthError error(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
+  FakeAuthStatusProvider provider(mock_signin_manager_->signin_global_error());
+  provider.set_auth_error(error);
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn()).WillRepeatedly(
       Return(true));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable()).WillRepeatedly(
       Return(true));
   EXPECT_CALL(*mock_pss_, waiting_for_auth()).WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error));
   EXPECT_CALL(*mock_pss_, HasUnrecoverableError()).WillRepeatedly(
       Return(false));
   EXPECT_CALL(*mock_pss_, sync_initialized()).WillRepeatedly(Return(true));
   // Any error should result in SigninFailed() being called.
   EXPECT_CALL(observer_, SigninFailed(error));
   tracker_.reset(new SigninTracker(profile_.get(), &observer_,
                                    SigninTracker::SERVICES_INITIALIZING));
 }
 
 
 TEST_F(SigninTrackerTest, SigninFailedWhenInitializing) {
   tracker_.reset();
   // SigninFailed() should be called.
   GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
   EXPECT_CALL(observer_, SigninFailed(error));
   tracker_.reset(new SigninTracker(profile_.get(), &observer_,
                                    SigninTracker::SERVICES_INITIALIZING));
   tracker_->OnStateChanged();
 }