Rewrite std::string("") to std::string(), Linux edition.

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/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 439 matching lines @@
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     ASSERT_EQ(1U, web_ui_.call_data().size());
     const TestWebUI::CallData& data = web_ui_.call_data()[0];
     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, "", false, GoogleServiceAuthError::NONE, "", true, "");
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           false,
+                           GoogleServiceAuthError::NONE,
+                           std::string(),
+                           true,
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
@@ skipping 15 matching lines @@
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     ASSERT_EQ(1U, web_ui_.call_data().size());
     const TestWebUI::CallData& data = web_ui_.call_data()[0];
     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, "", false, GoogleServiceAuthError::NONE, "", true, "");
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           false,
+                           GoogleServiceAuthError::NONE,
+                           std::string(),
+                           true,
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
@@ skipping 163 matching lines @@
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(false);
 
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     // Fake a failed signin attempt.
-    handler_->TryLogin(kTestUser, kTestPassword, "", "");
+    handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     GoogleServiceAuthError error(
         GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
     handler_->SigninFailed(error);
 
     ASSERT_EQ(2U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[1];
     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, "", false, GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS,
-        kTestUser, true, "");
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           false,
+                           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS,
+                           kTestUser,
+                           true,
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 TEST_P(SyncSetupHandlerTest, HandleCaptcha) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(false);
 
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     // Fake a failed signin attempt that requires a captcha.
-    handler_->TryLogin(kTestUser, kTestPassword, "", "");
+    handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     GoogleServiceAuthError error =
         GoogleServiceAuthError::FromClientLoginCaptchaChallenge(
             "token", GURL(kTestCaptchaImageUrl), GURL(kTestCaptchaUnlockUrl));
     handler_->SigninFailed(error);
     ASSERT_EQ(2U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[1];
     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, "", false, GoogleServiceAuthError::CAPTCHA_REQUIRED,
-        kTestUser, true, kTestCaptchaImageUrl);
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           false,
+                           GoogleServiceAuthError::CAPTCHA_REQUIRED,
+                           kTestUser,
+                           true,
+                           kTestCaptchaImageUrl);
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 // TODO(kochi): We need equivalent tests for ChromeOS.
 TEST_P(SyncSetupHandlerTest, UnrecoverableErrorInitializingSync) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(false);
 
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     ASSERT_EQ(1U, web_ui_.call_data().size());
     // Fake a successful GAIA request (gaia credentials valid, but signin not
     // complete yet).
-    handler_->TryLogin(kTestUser, kTestPassword, "", "");
+    handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     handler_->GaiaCredentialsValid();
     ASSERT_EQ(2U, web_ui_.call_data().size());
     EXPECT_EQ("SyncSetupOverlay.showSuccessAndSettingUp",
               web_ui_.call_data()[1].function_name);
     // Now fake a sync error.
     GoogleServiceAuthError none(GoogleServiceAuthError::NONE);
     EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
         .WillRepeatedly(Return(true));
     mock_signin_->SignOut();
     handler_->SigninFailed(none);
     ASSERT_EQ(3U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[2];
     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,
-        kTestUser, true, "");
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           true,
+                           GoogleServiceAuthError::NONE,
+                           kTestUser,
+                           true,
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 TEST_P(SyncSetupHandlerTest, GaiaErrorInitializingSync) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(false);
 
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     ASSERT_EQ(1U, web_ui_.call_data().size());
     // Fake a successful GAIA request (gaia credentials valid, but signin not
     // complete yet).
-    handler_->TryLogin(kTestUser, kTestPassword, "", "");
+    handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     handler_->GaiaCredentialsValid();
     ASSERT_EQ(2U, web_ui_.call_data().size());
     EXPECT_EQ("SyncSetupOverlay.showSuccessAndSettingUp",
               web_ui_.call_data()[1].function_name);
     // Now fake a sync gaia error.
     GoogleServiceAuthError unavailable(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
     EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
         .WillRepeatedly(Return(false));
     mock_signin_->SignOut();
     handler_->SigninFailed(unavailable);
     ASSERT_EQ(3U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[2];
     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, "", false, GoogleServiceAuthError::SERVICE_UNAVAILABLE,
-        kTestUser, true, "");
+    CheckShowSyncSetupArgs(dictionary,
+                           std::string(),
+                           false,
+                           GoogleServiceAuthError::SERVICE_UNAVAILABLE,
+                           kTestUser,
+                           true,
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 TEST_P(SyncSetupHandlerTest, TestSyncEverything) {
   std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), "", ENCRYPT_PASSWORDS);
+      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
   ListValue list_args;
   list_args.Append(new StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
 TEST_P(SyncSetupHandlerTest, TurnOnEncryptAll) {
   std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), "", ENCRYPT_ALL_DATA);
+      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_ALL_DATA);
   ListValue list_args;
   list_args.Append(new StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything());
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
 TEST_P(SyncSetupHandlerTest, TestPassphraseStillRequired) {
   std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), "", ENCRYPT_PASSWORDS);
+      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
   ListValue list_args;
   list_args.Append(new StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
@@ skipping 95 matching lines @@
 }
 
 // Walks through each user selectable type, and tries to sync just that single
 // data type.
 TEST_P(SyncSetupHandlerTest, TestSyncIndividualTypes) {
   syncer::ModelTypeSet user_selectable_types = GetAllTypes();
   syncer::ModelTypeSet::Iterator it;
   for (it = user_selectable_types.First(); it.Good(); it.Inc()) {
     syncer::ModelTypeSet type_to_set;
     type_to_set.Put(it.Get());
-    std::string args = GetConfiguration(
-        NULL, CHOOSE_WHAT_TO_SYNC, type_to_set, "", ENCRYPT_PASSWORDS);
+    std::string args = GetConfiguration(NULL,
+                                        CHOOSE_WHAT_TO_SYNC,
+                                        type_to_set,
+                                        std::string(),
+                                        ENCRYPT_PASSWORDS);
     ListValue list_args;
     list_args.Append(new StringValue(args));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
     EXPECT_CALL(*mock_pss_,
                 OnUserChoseDatatypes(false, ModelTypeSetMatches(type_to_set)));
     handler_->HandleConfigure(&list_args);
 
     ExpectDone();
     Mock::VerifyAndClearExpectations(mock_pss_);
     web_ui_.ClearTrackedCalls();
   }
 }
 
 TEST_P(SyncSetupHandlerTest, TestSyncAllManually) {
-  std::string args = GetConfiguration(
-      NULL, CHOOSE_WHAT_TO_SYNC, GetAllTypes(), "", ENCRYPT_PASSWORDS);
+  std::string args = GetConfiguration(NULL,
+                                      CHOOSE_WHAT_TO_SYNC,
+                                      GetAllTypes(),
+                                      std::string(),
+                                      ENCRYPT_PASSWORDS);
   ListValue list_args;
   list_args.Append(new StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_,
               OnUserChoseDatatypes(false, ModelTypeSetMatches(GetAllTypes())));
   handler_->HandleConfigure(&list_args);
@@ skipping 42 matching lines @@
     ASSERT_EQ(1U, web_ui_.call_data().size());
     const TestWebUI::CallData& data = web_ui_.call_data()[0];
     EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
     std::string page;
     ASSERT_TRUE(data.arg1->GetAsString(&page));
     EXPECT_EQ(page, "login");
     DictionaryValue* dictionary;
     ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
     // We should display a login screen with a non-editable username filled in.
     CheckShowSyncSetupArgs(dictionary,
-                           "",
+                           std::string(),
                            false,
                            GoogleServiceAuthError::NONE,
                            kTestUser,
                            false,
-                           "");
+                           std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 TEST_P(SyncSetupHandlerTest, ShowSetupSyncEverything) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
@@ skipping 144 matching lines @@
 // displayed to the user.
 TEST_P(SyncSetupHandlerTest, SubmitAuthWithInvalidUsername) {
   EXPECT_CALL(*mock_signin_, IsAllowedUsername(_)).
       WillRepeatedly(Return(false));
 
   // Generate a blob of json that matches what would be submitted by the login
   // javascript code.
   DictionaryValue args;
   args.SetString("user", "user@not_allowed.com");
   args.SetString("pass", "password");
-  args.SetString("captcha", "");
-  args.SetString("otp", "");
-  args.SetString("accessCode", "");
+  args.SetString("captcha", std::string());
+  args.SetString("otp", std::string());
+  args.SetString("accessCode", std::string());
   std::string json;
   base::JSONWriter::Write(&args, &json);
   ListValue list_args;
   list_args.Append(new StringValue(json));
 
   // Mimic a login attempt from the UI.
   handler_->HandleSubmitAuth(&list_args);
 
   // Should result in the login page being displayed again.
   ASSERT_EQ(1U, web_ui_.call_data().size());
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
   std::string page;
   ASSERT_TRUE(data.arg1->GetAsString(&page));
   EXPECT_EQ(page, "login");
 
   // Also make sure that the appropriate error message is being passed.
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   std::string err = l10n_util::GetStringUTF8(IDS_SYNC_LOGIN_NAME_PROHIBITED);
-  CheckShowSyncSetupArgs(
-      dictionary, err, false, GoogleServiceAuthError::NONE, "", true, "");
+  CheckShowSyncSetupArgs(dictionary,
+                         err,
+                         false,
+                         GoogleServiceAuthError::NONE,
+                         std::string(),
+                         true,
+                         std::string());
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
 
 INSTANTIATE_TEST_CASE_P(SyncSetupHandlerTestWithParam,
                         SyncSetupHandlerTest,
                         Values(true, false));