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

chrome/browser/signin/signin_global_error_unittest.cc

 // Copyright (c) 2013 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_global_error.h"
 
 #include "base/memory/scoped_ptr.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_factory.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-class FakeAuthStatusProvider : public SigninGlobalError::AuthStatusProvider {
- public:
-  FakeAuthStatusProvider() : auth_error_(GoogleServiceAuthError::None()) {}
-
-  // AuthStatusProvider implementation.
-  GoogleServiceAuthError GetAuthStatus() const OVERRIDE { return auth_error_; }
-
-  void set_auth_error(const GoogleServiceAuthError& error) {
-    auth_error_ = error;
-  }
-
- private:
-  GoogleServiceAuthError auth_error_;
-};
-
 class SigninGlobalErrorTest : public testing::Test {
  public:
   void SetUp() OVERRIDE {
     // Create a signed-in profile.
     profile_.reset(new TestingProfile());
 
     SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
         profile_.get(), FakeSigninManager::Build);
     SigninManager* manager =
         SigninManagerFactory::GetForProfile(profile_.get());
       manager->SetAuthenticatedUsername("testuser@test.com");
     global_error_ = manager->signin_global_error();
   }
 
   scoped_ptr<TestingProfile> profile_;
   SigninGlobalError* global_error_;
 };
 
 TEST_F(SigninGlobalErrorTest, NoAuthStatusProviders) {
   ASSERT_FALSE(global_error_->HasBadge());
 }
 
 TEST_F(SigninGlobalErrorTest, NoErrorAuthStatusProviders) {
-  FakeAuthStatusProvider provider;
-  global_error_->AddProvider(&provider);
-  ASSERT_FALSE(global_error_->HasBadge());
-  global_error_->RemoveProvider(&provider);
+  {
+    // Add a provider (removes itself on exiting this scope).
+    FakeAuthStatusProvider provider(global_error_);
+    ASSERT_FALSE(global_error_->HasBadge());
+  }
   ASSERT_FALSE(global_error_->HasBadge());
 }
 
 TEST_F(SigninGlobalErrorTest, ErrorAuthStatusProvider) {
-  FakeAuthStatusProvider provider;
-  FakeAuthStatusProvider error_provider;
-  error_provider.set_auth_error(GoogleServiceAuthError(
-      GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
-  global_error_->AddProvider(&provider);
-  ASSERT_FALSE(global_error_->HasBadge());
-  global_error_->AddProvider(&error_provider);
-  ASSERT_TRUE(global_error_->HasBadge());
-  global_error_->RemoveProvider(&error_provider);
-  ASSERT_FALSE(global_error_->HasBadge());
-  global_error_->RemoveProvider(&provider);
+  {
+    FakeAuthStatusProvider provider(global_error_);
+    ASSERT_FALSE(global_error_->HasBadge());
+    {
+      FakeAuthStatusProvider error_provider(global_error_);
+      error_provider.SetAuthError(GoogleServiceAuthError(
+          GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
+      ASSERT_TRUE(global_error_->HasBadge());
+    }
+    // error_provider is removed now that we've left that scope.
+    ASSERT_FALSE(global_error_->HasBadge());
+  }
+  // All providers should be removed now.
   ASSERT_FALSE(global_error_->HasBadge());
 }
 
 TEST_F(SigninGlobalErrorTest, AuthStatusProviderErrorTransition) {
-  FakeAuthStatusProvider provider0;
-  FakeAuthStatusProvider provider1;
-  global_error_->AddProvider(&provider0);
-  global_error_->AddProvider(&provider1);
-  ASSERT_FALSE(global_error_->HasBadge());
-  provider0.set_auth_error(
-      GoogleServiceAuthError(GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
-  ASSERT_FALSE(global_error_->HasBadge());
-  global_error_->AuthStatusChanged();
-  ASSERT_TRUE(global_error_->HasBadge());
-  provider1.set_auth_error(
-      GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DISABLED));
-  global_error_->AuthStatusChanged();
-  ASSERT_TRUE(global_error_->HasBadge());
+  {
+    FakeAuthStatusProvider provider0(global_error_);
+    FakeAuthStatusProvider provider1(global_error_);
+    ASSERT_FALSE(global_error_->HasBadge());
+    provider0.SetAuthError(
+        GoogleServiceAuthError(
+            GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
+    ASSERT_TRUE(global_error_->HasBadge());
+    provider1.SetAuthError(
+        GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DISABLED));
+    ASSERT_TRUE(global_error_->HasBadge());
 
-  // Now resolve the auth errors - badge should go away.
-  provider0.set_auth_error(GoogleServiceAuthError::None());
-  global_error_->AuthStatusChanged();
-  ASSERT_TRUE(global_error_->HasBadge());
-  provider1.set_auth_error(GoogleServiceAuthError::None());
-  global_error_->AuthStatusChanged();
-  ASSERT_FALSE(global_error_->HasBadge());
-
-  global_error_->RemoveProvider(&provider0);
-  ASSERT_FALSE(global_error_->HasBadge());
-  global_error_->RemoveProvider(&provider1);
+    // Now resolve the auth errors - badge should go away.
+    provider0.SetAuthError(GoogleServiceAuthError::None());
+    ASSERT_TRUE(global_error_->HasBadge());
+    provider1.SetAuthError(GoogleServiceAuthError::None());
+    ASSERT_FALSE(global_error_->HasBadge());
+  }
   ASSERT_FALSE(global_error_->HasBadge());
 }
 
 // Verify that SigninGlobalError ignores certain errors.
 TEST_F(SigninGlobalErrorTest, AuthStatusEnumerateAllErrors) {
   typedef struct {
     GoogleServiceAuthError::State error_state;
     bool is_error;
   } ErrorTableEntry;
 
   ErrorTableEntry table[] = {
     { GoogleServiceAuthError::NONE, false },
     { GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS, true },
     { GoogleServiceAuthError::USER_NOT_SIGNED_UP, true },
     { GoogleServiceAuthError::CONNECTION_FAILED, false },
     { GoogleServiceAuthError::CAPTCHA_REQUIRED, true },
     { GoogleServiceAuthError::ACCOUNT_DELETED, true },
     { GoogleServiceAuthError::ACCOUNT_DISABLED, true },
     { GoogleServiceAuthError::SERVICE_UNAVAILABLE, true },
     { GoogleServiceAuthError::TWO_FACTOR, true },
     { GoogleServiceAuthError::REQUEST_CANCELED, true },
     { GoogleServiceAuthError::HOSTED_NOT_ALLOWED, true },
   };
   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(table) == GoogleServiceAuthError::NUM_STATES,
       kTable_size_does_not_match_number_of_auth_error_types);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(table); ++i) {
-    FakeAuthStatusProvider provider;
-    provider.set_auth_error(GoogleServiceAuthError(table[i].error_state));
+    FakeAuthStatusProvider provider(global_error_);
+    provider.SetAuthError(GoogleServiceAuthError(table[i].error_state));
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile_.get());
-    global_error_->AddProvider(&provider);
     EXPECT_EQ(global_error_->HasBadge(), table[i].is_error);
     // Should badge the wrench menu if there's an error.
     EXPECT_EQ(service->GetFirstBadgeResourceID() != 0, table[i].is_error);
 #if defined(OS_CHROMEOS)
     // Only on chromeos do we have a separate menu item - on other platforms
     // there's code in WrenchMenuModel to re-use the "sign in to chrome"
     // menu item to display auth status/errors.
     EXPECT_EQ(global_error_->HasMenuItem(), table[i].is_error);
 #else
     EXPECT_FALSE(global_error_->HasMenuItem());
 #endif
     EXPECT_EQ(global_error_->MenuItemLabel().empty(), !table[i].is_error);
     EXPECT_EQ(global_error_->GetBubbleViewMessage().empty(),
               !table[i].is_error);
     EXPECT_FALSE(global_error_->GetBubbleViewTitle().empty());
     EXPECT_FALSE(global_error_->GetBubbleViewAcceptButtonLabel().empty());
     EXPECT_TRUE(global_error_->GetBubbleViewCancelButtonLabel().empty());
-    global_error_->RemoveProvider(&provider);
   }
 }