Replace base::Tuple in //chrome with std::tuple

chrome/renderer/autofill/password_autofill_agent_browsertest.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 <tuple>
+
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/renderer/autofill/password_generation_test_utils.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_autofill_agent.h"
@@ skipping 418 matching lines @@
 
   // Checks the message sent to PasswordAutofillManager to build the suggestion
   // list. |username| is the expected username field value, and |show_all| is
   // the expected flag for the PasswordAutofillManager, whether to show all
   // suggestions, or only those starting with |username|.
   void CheckSuggestions(const std::string& username, bool show_all) {
     const IPC::Message* message =
         render_thread_->sink().GetFirstMessageMatching(
             AutofillHostMsg_ShowPasswordSuggestions::ID);
     ASSERT_TRUE(message);
-    base::Tuple<int, base::i18n::TextDirection, base::string16, int, gfx::RectF>
+    std::tuple<int, base::i18n::TextDirection, base::string16, int, gfx::RectF>
         args;
     AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args);
-    EXPECT_EQ(kPasswordFillFormDataId, base::get<0>(args));
-    EXPECT_EQ(ASCIIToUTF16(username), base::get<2>(args));
+    EXPECT_EQ(kPasswordFillFormDataId, std::get<0>(args));
+    EXPECT_EQ(ASCIIToUTF16(username), std::get<2>(args));
     EXPECT_EQ(show_all,
-              static_cast<bool>(base::get<3>(args) & autofill::SHOW_ALL));
+              static_cast<bool>(std::get<3>(args) & autofill::SHOW_ALL));
 
     render_thread_->sink().ClearMessages();
   }
 
   void ExpectFormSubmittedWithUsernameAndPasswords(
       const std::string& username_value,
       const std::string& password_value,
       const std::string& new_password_value) {
     const IPC::Message* message =
         render_thread_->sink().GetFirstMessageMatching(
             AutofillHostMsg_PasswordFormSubmitted::ID);
     ASSERT_TRUE(message);
-    base::Tuple<autofill::PasswordForm> args;
+    std::tuple<autofill::PasswordForm> args;
     AutofillHostMsg_PasswordFormSubmitted::Read(message, &args);
-    EXPECT_EQ(ASCIIToUTF16(username_value), base::get<0>(args).username_value);
-    EXPECT_EQ(ASCIIToUTF16(password_value), base::get<0>(args).password_value);
+    EXPECT_EQ(ASCIIToUTF16(username_value), std::get<0>(args).username_value);
+    EXPECT_EQ(ASCIIToUTF16(password_value), std::get<0>(args).password_value);
     EXPECT_EQ(ASCIIToUTF16(new_password_value),
-              base::get<0>(args).new_password_value);
+              std::get<0>(args).new_password_value);
   }
 
   void ExpectInPageNavigationWithUsernameAndPasswords(
       const std::string& username_value,
       const std::string& password_value,
       const std::string& new_password_value) {
     const IPC::Message* message =
         render_thread_->sink().GetFirstMessageMatching(
             AutofillHostMsg_InPageNavigation::ID);
     ASSERT_TRUE(message);
-    base::Tuple<autofill::PasswordForm> args;
+    std::tuple<autofill::PasswordForm> args;
     AutofillHostMsg_InPageNavigation::Read(message, &args);
-    EXPECT_EQ(ASCIIToUTF16(username_value), base::get<0>(args).username_value);
-    EXPECT_EQ(ASCIIToUTF16(password_value), base::get<0>(args).password_value);
+    EXPECT_EQ(ASCIIToUTF16(username_value), std::get<0>(args).username_value);
+    EXPECT_EQ(ASCIIToUTF16(password_value), std::get<0>(args).password_value);
     EXPECT_EQ(ASCIIToUTF16(new_password_value),
-              base::get<0>(args).new_password_value);
+              std::get<0>(args).new_password_value);
   }
 
   base::string16 username1_;
   base::string16 username2_;
   base::string16 username3_;
   base::string16 password1_;
   base::string16 password2_;
   base::string16 password3_;
   base::string16 alternate_username3_;
   PasswordFormFillData fill_data_;
@@ skipping 14 matching lines @@
    * returns false.  May be we should mock URL loading to cirmcuvent this?
    TODO(jcivelli): find a way to make the security origin not deny access to the
                    password manager and then reenable this code.
 
   // The form has been loaded, we should have sent the browser a message about
   // the form.
   const IPC::Message* msg = render_thread_.sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsParsed::ID);
   ASSERT_TRUE(msg != NULL);
 
-  base::Tuple1<std::vector<PasswordForm> > forms;
+  std::tuple<std::vector<PasswordForm> > forms;
   AutofillHostMsg_PasswordFormsParsed::Read(msg, &forms);
   ASSERT_EQ(1U, forms.a.size());
   PasswordForm password_form = forms.a[0];
   EXPECT_EQ(PasswordForm::SCHEME_HTML, password_form.scheme);
   EXPECT_EQ(ASCIIToUTF16(kUsernameName), password_form.username_element);
   EXPECT_EQ(ASCIIToUTF16(kPasswordName), password_form.password_element);
   */
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
@@ skipping 244 matching lines @@
   ASSERT_EQ(1u, forms3.size());
   EXPECT_FALSE(form_util::IsWebNodeVisible(forms3[0]));
 }
 
 TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) {
   render_thread_->sink().ClearMessages();
   LoadHTML(kVisibleFormWithNoUsernameHTML);
   const IPC::Message* message = render_thread_->sink()
       .GetFirstMessageMatching(AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
-  base::Tuple<std::vector<autofill::PasswordForm>, bool> param;
+  std::tuple<std::vector<autofill::PasswordForm>, bool> param;
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_TRUE(base::get<0>(param).size());
+  EXPECT_TRUE(std::get<0>(param).size());
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kEmptyFormHTML);
   message = render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(base::get<0>(param).size());
+  EXPECT_FALSE(std::get<0>(param).size());
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kNonVisibleFormHTML);
   message = render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(base::get<0>(param).size());
+  EXPECT_FALSE(std::get<0>(param).size());
 }
 
 TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest_Redirection) {
   render_thread_->sink().ClearMessages();
   LoadHTML(kEmptyWebpage);
   EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_PasswordFormsRendered::ID));
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kRedirectionWebpage);
@@ skipping 1507 matching lines @@
 
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSendSubmitEvent(username_element_.form());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   ExpectFormSubmittedWithUsernameAndPasswords("Alice", "mypassword", "");
 }
 
 }  // namespace autofill