Merge 130722 - On ChromeOS, the user is always signed in and we should not

chrome/browser/ui/webui/sync_setup_handler_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/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 195 matching lines @@
   }
 
   scoped_ptr<Profile> profile_;
   ProfileSyncServiceMock* mock_pss_;
   GoogleServiceAuthError error_;
   SigninManagerMock* mock_signin_;
   TestWebUI web_ui_;
   scoped_ptr<TestingSyncSetupHandler> handler_;
 };
 
+#if !defined(OS_CHROMEOS)
 static void CheckInt(const DictionaryValue* dictionary,
                      const std::string& key,
                      int expected_value) {
   int actual_value;
   EXPECT_TRUE(dictionary->GetInteger(key, &actual_value)) <<
       "Did not expect to find value for " << key;;
   EXPECT_EQ(actual_value, expected_value) <<
       "Mismatch found for " << key;;
 }
+#endif
 
 static void CheckBool(const DictionaryValue* dictionary,
                       const std::string& key,
                       bool expected_value,
                       bool is_optional) {
   if (is_optional && !expected_value) {
     EXPECT_FALSE(dictionary->HasKey(key)) <<
         "Did not expect to find value for " << key;;
   } else {
     bool actual_value;
     EXPECT_TRUE(dictionary->GetBoolean(key, &actual_value)) <<
         "No value found for " << key;
     EXPECT_EQ(actual_value, expected_value) <<
         "Mismatch found for " << key;
   }
 }
 
 static void CheckBool(const DictionaryValue* dictionary,
                       const std::string& key,
                       bool expected_value) {
   return CheckBool(dictionary, key, expected_value, false);
 }
 
+#if !defined(OS_CHROMEOS)
 static void CheckString(const DictionaryValue* dictionary,
                         const std::string& key,
                         const std::string& expected_value,
                         bool is_optional) {
   if (is_optional && expected_value.empty()) {
     EXPECT_FALSE(dictionary->HasKey(key)) <<
         "Did not expect to find value for " << key;
   } else {
     std::string actual_value;
     EXPECT_TRUE(dictionary->GetString(key, &actual_value)) <<
         "No value found for " << key;
     EXPECT_EQ(actual_value, expected_value) <<
         "Mismatch found for " << key;
   }
 }
+#endif
 
+#if !defined(OS_CHROMEOS)
 // Validates that the expected args are being passed off to javascript.
 static void CheckShowSyncSetupArgs(const DictionaryValue* dictionary,
                                    std::string error_message,
                                    bool fatal_error,
                                    int error,
                                    std::string user,
                                    bool user_is_editable,
                                    std::string captcha_url) {
   // showSyncSetupPage() expects to be passed a dictionary with the following
   // named values set:
   // error_message: custom error message to display.
   // fatalError: true if there was a fatal error while logging in.
   // error: GoogleServiceAuthError from previous login attempt (0 if none).
   // user: The email the user most recently entered.
   // editable_user: Whether the username field should be editable.
   // captchaUrl: The captcha image to display to the user (empty if none).
   //
   // The code below validates these arguments.
 
   CheckString(dictionary, "error_message", error_message, true);
   CheckString(dictionary, "user", user, false);
   CheckString(dictionary, "captchaUrl", captcha_url, false);
   CheckInt(dictionary, "error", error);
   CheckBool(dictionary, "fatalError", fatal_error, true);
   CheckBool(dictionary, "editable_user", user_is_editable);
 }
+#endif
 
 TEST_F(SyncSetupHandlerTest, Basic) {
 }
 
+#if !defined(OS_CHROMEOS)
 TEST_F(SyncSetupHandlerTest, DisplayBasicLogin) {
   EXPECT_CALL(*mock_pss_, AreCredentialsAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   handler_->OpenSyncSetup(false);
   EXPECT_EQ(&web_ui_,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
   ASSERT_EQ(1U, web_ui_.call_data().size());
@@ skipping 112 matching lines @@
   EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
   std::string page;
   ASSERT_TRUE(data.arg1->GetAsString(&page));
   EXPECT_EQ(page, "login");
   // Now make sure that the appropriate params are being passed.
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckShowSyncSetupArgs(
       dictionary, "", true, GoogleServiceAuthError::NONE, "", true, "");
 }
+#endif  // !OS_CHROMEOS
 
+#if !defined(OS_CHROMEOS)
+// TODO(kochi): We need equivalent tests for ChromeOS.
 TEST_F(SyncSetupHandlerTest, UnrecoverableErrorInitializingSync) {
   EXPECT_CALL(*mock_pss_, AreCredentialsAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(false);
   ASSERT_EQ(1U, web_ui_.call_data().size());
   // Fake a successful GAIA request (gaia credentials valid, but signin not
   // complete yet).
@@ skipping 54 matching lines @@
   std::string page;
   ASSERT_TRUE(data.arg1->GetAsString(&page));
   EXPECT_EQ(page, "login");
   // Now make sure that the appropriate params are being passed.
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckShowSyncSetupArgs(
       dictionary, "", false, GoogleServiceAuthError::SERVICE_UNAVAILABLE,
       kTestUser, true, "");
 }
+#endif  // !OS_CHROMEOS
 
 TEST_F(SyncSetupHandlerTest, TestSyncEverything) {
   std::string args =
       "{\"syncAllDataTypes\":true,"
       "\"sync_apps\":true,"
       "\"sync_autofill\":true,"
       "\"sync_bookmarks\":true,"
       "\"sync_extensions\":true,"
       "\"sync_passwords\":true,"
       "\"sync_preferences\":true,"
@@ skipping 256 matching lines @@
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   // This should display the sync setup dialog (not login).
   SetDefaultExpectationsForConfigPage();
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
 }
 
+#if !defined(OS_CHROMEOS)
 TEST_F(SyncSetupHandlerTest, ShowSyncSetupWithAuthError) {
   // Initialize the system to a signed in state, but with an auth error.
   error_ = GoogleServiceAuthError(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   SetupInitializedProfileSyncService();
   mock_signin_->SetAuthenticatedUsername(kTestUser);
   EXPECT_CALL(*mock_pss_, AreCredentialsAvailable())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
@@ skipping 15 matching lines @@
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   // We should display a login screen with a non-editable username filled in.
   CheckShowSyncSetupArgs(dictionary,
                          "",
                          false,
                          GoogleServiceAuthError::NONE,
                          kTestUser,
                          false,
                          "");
 }
+#endif
 
 TEST_F(SyncSetupHandlerTest, ShowSetupSyncEverything) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
@@ skipping 135 matching lines @@
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }