Enable components_browsertests on Android

components/autofill/content/renderer/password_form_conversion_utils_browsertest.cc

 // Copyright 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 "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/core/common/password_form.h"
@@ skipping 87 matching lines @@
   std::string ProduceHTML() const {
     return html_ + "</FORM>";
   }
 
  private:
   std::string html_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordFormBuilder);
 };
 
-class PasswordFormConversionUtilsTest : public content::RenderViewTest {
+// RenderVIewTest-based tests crash on Android
+// http://crbug.com/187500
+#if defined(OS_ANDROID)
+#define MAYBE_PasswordFormConversionUtilsTest \
+  DISABLED_PasswordFormConversionUtilsTest
+#else
+#define MAYBE_PasswordFormConversionUtilsTest PasswordFormConversionUtilsTest
+#endif  // defined(OS_ANDROID)
+
+class MAYBE_PasswordFormConversionUtilsTest : public content::RenderViewTest {
  public:
-  PasswordFormConversionUtilsTest() : content::RenderViewTest() {}
-  ~PasswordFormConversionUtilsTest() override {}
+  MAYBE_PasswordFormConversionUtilsTest() : content::RenderViewTest() {}
+  ~MAYBE_PasswordFormConversionUtilsTest() override {}
 
  protected:
   // Loads the given |html|, retrieves the sole WebFormElement from it, and then
   // calls CreatePasswordForm() to convert it into a |password_form|. Note that
   // ASSERT() can only be used in void functions, this is why |password_form| is
   // passed in as a pointer to a scoped_ptr.
   void LoadHTMLAndConvertForm(const std::string& html,
                               scoped_ptr<PasswordForm>* password_form) {
     LoadHTML(html.c_str());
 
     WebFrame* frame = GetMainFrame();
     ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
     WebVector<WebFormElement> forms;
     frame->document().forms(forms);
     ASSERT_EQ(1U, forms.size());
 
     WebVector<WebFormControlElement> control_elements;
     forms[0].getFormControlElements(control_elements);
     for (size_t i = 0; i < control_elements.size(); ++i) {
       WebInputElement* input_element = toWebInputElement(&control_elements[i]);
       if (input_element->hasAttribute("set-activated-submit"))
         input_element->setActivatedSubmit(true);
     }
 
     *password_form = CreatePasswordForm(forms[0], nullptr, nullptr);
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(PasswordFormConversionUtilsTest);
+  DISALLOW_COPY_AND_ASSIGN(MAYBE_PasswordFormConversionUtilsTest);
 };
 
 }  // namespace
 
-TEST_F(PasswordFormConversionUtilsTest, BasicFormAttributes) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, BasicFormAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username", "johnsmith", NULL);
   builder.AddSubmitButton("inactive_submit", false);
   builder.AddSubmitButton("active_submit", true);
   builder.AddSubmitButton("inactive_submit2", false);
   builder.AddPasswordField("password", "secret", NULL);
   std::string html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
   ASSERT_TRUE(password_form);
 
   EXPECT_EQ("data:", password_form->signon_realm);
   EXPECT_EQ(GURL(kTestFormActionURL), password_form->action);
   EXPECT_EQ(base::UTF8ToUTF16("active_submit"), password_form->submit_element);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
   EXPECT_EQ(PasswordForm::SCHEME_HTML, password_form->scheme);
   EXPECT_FALSE(password_form->ssl_valid);
   EXPECT_FALSE(password_form->preferred);
   EXPECT_FALSE(password_form->blacklisted_by_user);
   EXPECT_EQ(PasswordForm::TYPE_MANUAL, password_form->type);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, DisabledFieldsAreIgnored) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, DisabledFieldsAreIgnored) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username", "johnsmith", NULL);
   builder.AddDisabledUsernameField();
   builder.AddDisabledPasswordField();
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddSubmitButton("submit", true);
   std::string html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, IdentifyingUsernameFields) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, IdentifyingUsernameFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below, plus the corresponding expectations.
   struct TestCase {
     const char* autocomplete[3];
     const char* expected_username_element;
     const char* expected_username_value;
     const char* expected_other_possible_usernames;
   } cases[] = {
       // When no elements are marked with autocomplete='username', the text-type
       // input field before the first password element should get selected as
@@ skipping 64 matching lines @@
         EXPECT_TRUE(password_form->other_possible_usernames.empty());
       }
 
       // Do a basic sanity check that we are still having a password field.
       EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
       EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
     }
   }
 }
 
-TEST_F(PasswordFormConversionUtilsTest, IdentifyingTwoPasswordFields) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, IdentifyingTwoPasswordFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below, plus the corresponding expectations.
   struct TestCase {
     const char* password_values[2];
     const char* expected_password_element;
     const char* expected_password_value;
     const char* expected_new_password_element;
     const char* expected_new_password_value;
   } cases[] = {
       // Twp non-empty fields with the same value should be treated as a new
@@ skipping 34 matching lines @@
               password_form->new_password_value);
 
     // Do a basic sanity check that we are still selecting the right username.
     EXPECT_EQ(base::UTF8ToUTF16("username1"), password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
     EXPECT_THAT(password_form->other_possible_usernames,
                 testing::ElementsAre(base::UTF8ToUTF16("Smith")));
   }
 }
 
-TEST_F(PasswordFormConversionUtilsTest, IdentifyingThreePasswordFields) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, IdentifyingThreePasswordFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below, plus the corresponding expectations.
   struct TestCase {
     const char* password_values[3];
     const char* expected_password_element;
     const char* expected_password_value;
     const char* expected_new_password_element;
     const char* expected_new_password_value;
   } cases[] = {
       // Two fields with the same value, and one different: we should treat this
@@ skipping 40 matching lines @@
               password_form->new_password_value);
 
     // Do a basic sanity check that we are still selecting the right username.
     EXPECT_EQ(base::UTF8ToUTF16("username1"), password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
     EXPECT_THAT(password_form->other_possible_usernames,
                 testing::ElementsAre(base::UTF8ToUTF16("Smith")));
   }
 }
 
-TEST_F(PasswordFormConversionUtilsTest,
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        IdentifyingPasswordFieldsWithAutocompleteAttributes) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below, plus the corresponding expectations.
   struct TestCase {
     const char* autocomplete[3];
     const char* expected_password_element;
     const char* expected_password_value;
     const char* expected_new_password_element;
     const char* expected_new_password_value;
     bool expected_new_password_marked_by_site;
@@ skipping 117 matching lines @@
               password_form->password_value);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_element),
               password_form->new_password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_value),
               password_form->new_password_value);
     EXPECT_EQ(cases[i].expected_new_password_marked_by_site,
               password_form->new_password_marked_by_site);
   }
 }
 
-TEST_F(PasswordFormConversionUtilsTest, InvalidFormDueToBadActionURL) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, InvalidFormDueToBadActionURL) {
   PasswordFormBuilder builder("invalid_target");
   builder.AddUsernameField("username", "JohnSmith", NULL);
   builder.AddSubmitButton("submit", true);
   builder.AddPasswordField("password", "secret", NULL);
   std::string html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
   EXPECT_FALSE(password_form);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, InvalidFormDueToNoPasswordFields) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       InvalidFormDueToNoPasswordFields) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username1", "John", NULL);
   builder.AddUsernameField("username2", "Smith", NULL);
   builder.AddSubmitButton("submit", true);
   std::string html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
   EXPECT_FALSE(password_form);
 }
 
-TEST_F(PasswordFormConversionUtilsTest,
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormsDueToConfusingPasswordFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below.
   const char* cases[][3] = {
       // No autocomplete attributes to guide us, and we see:
       //  * three password values that are all different,
       //  * three password values that are all the same;
       //  * three password values with the first and last matching.
       // In any case, we should just give up on this form.
       {"alpha", "beta", "gamma"},
@@ skipping 10 matching lines @@
     builder.AddPasswordField("password3", cases[i][2], NULL);
     builder.AddSubmitButton("submit", true);
     std::string html = builder.ProduceHTML();
 
     scoped_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
     EXPECT_FALSE(password_form);
   }
 }
 
-TEST_F(PasswordFormConversionUtilsTest,
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormDueToTooManyPasswordFieldsWithoutAutocompleteAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username1", "John", NULL);
   builder.AddPasswordField("password1", "alpha", NULL);
   builder.AddPasswordField("password2", "alpha", NULL);
   builder.AddPasswordField("password3", "alpha", NULL);
   builder.AddPasswordField("password4", "alpha", NULL);
   builder.AddSubmitButton("submit", true);
   std::string html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(html, &password_form));
   EXPECT_FALSE(password_form);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, LayoutClassificationLogin) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationLogin) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddHiddenField();
   builder.AddUsernameField("username", "", nullptr);
   builder.AddPasswordField("password", "", nullptr);
   builder.AddSubmitButton("submit", false);
   std::string login_html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> login_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(login_html, &login_form));
   ASSERT_TRUE(login_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, login_form->layout);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, LayoutClassificationSignup) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationSignup) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("someotherfield", "", nullptr);
   builder.AddUsernameField("username", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit", false);
   std::string signup_html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> signup_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(signup_html, &signup_form));
   ASSERT_TRUE(signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, signup_form->layout);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, LayoutClassificationChange) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationChange) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username", "", nullptr);
   builder.AddPasswordField("old_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit", false);
   std::string change_html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> change_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(change_html, &change_form));
   ASSERT_TRUE(change_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, change_form->layout);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, LayoutClassificationLoginPlusSignup_A) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       LayoutClassificationLoginPlusSignup_A) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddUsernameField("username2", "", nullptr);
   builder.AddUsernameField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit", false);
   std::string login_plus_signup_html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(login_plus_signup_html, &login_plus_signup_form));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
-TEST_F(PasswordFormConversionUtilsTest, LayoutClassificationLoginPlusSignup_B) {
+TEST_F(MAYBE_PasswordFormConversionUtilsTest,
+       LayoutClassificationLoginPlusSignup_B) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddUsernameField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddUsernameField("username2", "", nullptr);
   builder.AddUsernameField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddUsernameField("someotherfield2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit", false);
   std::string login_plus_signup_html = builder.ProduceHTML();
 
   scoped_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(login_plus_signup_html, &login_plus_signup_form));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
 }  // namespace autofill