Change fill-on-account-select to use Features API, not a custom flag

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/command_line.h"
+#include "base/feature_list.h"
 #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"
 #include "components/autofill/content/renderer/test_password_generation_agent.h"
 #include "components/autofill/core/common/autofill_constants.h"
-#include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form_field_prediction_map.h"
 #include "content/public/renderer/render_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using autofill::PasswordForm;
 using base::ASCIIToUTF16;
 using base::UTF16ToUTF8;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebFrame;
 using blink::WebInputElement;
 using blink::WebString;
 using blink::WebView;
 
+namespace password_manager {

[vabr (Chromium), 2016/06/15 09:15:33]

You should be able to just
#include "components/password_manager/core/common/password_manager_features.h"
instead of duplicatinng the declaration here, no?

[jww, 2016/06/15 17:17:56]

components/password_manager/core/common wasn't in the chrome/renderer/DEPS
include_rules, so I thought I'd just pre-declare it here instead. You're right
that it's pretty ugly, though, and I don't see any reason that
components/password_manager/core/common shouldn't be allowed in chrome/renderer,
so I'll update the DEPS.

[vabr (Chromium), 2016/06/16 07:03:38]

Acknowledged, this kind of dependency is OK.
(Also if it were not, the repeated declaration would still be a layering
violation in spirit.)

+namespace features {
+
+extern const base::Feature kFillOnAccountSelect;
+
+}  // namespace features
+}  // namespace password_manager
+
 namespace {
 
 const int kPasswordFillFormDataId = 1234;
 
 // The name of the username/password element in the form.
 const char kUsernameName[] = "username";
 const char kPasswordName[] = "password";
 const char kEmailName[] = "email";
 const char kCreditCardOwnerName[] = "creditcardowner";
 const char kCreditCardNumberName[] = "creditcardnumber";
@@ skipping 262 matching lines @@
     // Now retrieve the input elements so the test can access them.
     UpdateUsernameAndPasswordElements();
   }
 
   void TearDown() override {
     username_element_.reset();
     password_element_.reset();
     ChromeRenderViewTest::TearDown();
   }
 
+  void SetFillOnAccountSelect() {
+    base::FeatureList::ClearInstanceForTesting();
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->InitializeFromCommandLine(
+        password_manager::features::kFillOnAccountSelect.name, "");
+    base::FeatureList::SetInstance(std::move(feature_list));
+  }
+
   void UpdateOriginForHTML(const std::string& html) {
     std::string origin = "data:text/html;charset=utf-8," + html;
     fill_data_.origin = GURL(origin);
   }
 
   void UpdateUsernameAndPasswordElements() {
     WebDocument document = GetMainFrame()->document();
     WebElement element =
         document.getElementById(WebString::fromUTF8(kUsernameName));
     ASSERT_FALSE(element.isNull());
@@ skipping 943 matching lines @@
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, true);
   CheckSuggestions("baz", true);
   ClearUsernameAndPasswordFields();
 }
 
 // Tests that there is an autosuggestion from the password manager when the
 // user clicks on the password field when FillOnAccountSelect is enabled.
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyNoCredentialsOnPasswordClick) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   // Simulate the browser sending back the login info.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password element. This should produce no
   // message.
   render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, false);
   EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordSuggestions::ID));
 }
 
 // Tests the autosuggestions that are given when a password element is clicked,
 // the username element is not editable, and FillOnAccountSelect is enabled.
 // Specifically, tests when the user clicks on the password element after page
 // load, and the corresponding username element is readonly (and thus
 // uneditable), that the credentials for the already-filled username are
 // suggested.
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyCredentialsOnPasswordClick) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   // Simulate the browser sending back the login info.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Simulate the page loading with a prefilled username element that is
   // uneditable.
   username_element_.setValue("alicia");
@@ skipping 228 matching lines @@
 
   PasswordFormFillData no_username_fill_data = fill_data_;
   no_username_fill_data.username_field.name = base::string16();
   SimulateOnFillPasswordForm(no_username_fill_data);
 
   // The username and password should not have been autocompleted.
   CheckTextFieldsState("", false, "", false);
 }
 
 TEST_F(PasswordAutofillAgentTest, FillOnAccountSelectOnly) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   ClearUsernameAndPasswordFields();
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   CheckTextFieldsState(std::string(), false, std::string(), false);
   CheckSuggestions(std::string(), true);
 }
 
 TEST_F(PasswordAutofillAgentTest, FillOnAccountSelectOnlyReadonlyUsername) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   ClearUsernameAndPasswordFields();
 
   username_element_.setValue("alice");
   SetElementReadOnly(username_element_, true);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   CheckTextFieldsState(std::string("alice"), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyReadonlyNotPreferredUsername) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   ClearUsernameAndPasswordFields();
 
   username_element_.setValue("Carol");
   SetElementReadOnly(username_element_, true);
 
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   CheckTextFieldsState(std::string("Carol"), false, std::string(), false);
 }
 
 TEST_F(PasswordAutofillAgentTest, FillOnAccountSelectOnlyNoUsername) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   // Load a form with no username and update test data.
   LoadHTML(kVisibleFormWithNoUsernameHTML);
   username_element_.reset();
   WebDocument document = GetMainFrame()->document();
   WebElement element =
       document.getElementById(WebString::fromUTF8(kPasswordName));
   ASSERT_FALSE(element.isNull());
   password_element_ = element.to<blink::WebInputElement>();
   fill_data_.username_field = FormFieldData();
@@ skipping 103 matching lines @@
       password_element_, base::string16(), ASCIIToUTF16(kAlicePassword));
   ASSERT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordSuggestions::ID));
 }
 
 // Tests with fill-on-account-select enabled that if the username element is
 // read-only and filled with an unknown username, then the password field is not
 // highlighted as autofillable (regression test for https://crbug.com/442564).
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyReadonlyUnknownUsername) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      autofill::switches::kEnableFillOnAccountSelect);
+  SetFillOnAccountSelect();
 
   ClearUsernameAndPasswordFields();
 
   username_element_.setValue("foobar");
   SetElementReadOnly(username_element_, true);
 
   CheckTextFieldsState(std::string("foobar"), false, std::string(), false);
 }
 
 // Test that the last plain text field before a password field is chosen as a
@@ skipping 619 matching lines @@
   EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordSuggestions::ID));
 
   // But when the user clicks on the autofilled password field again it should
   // still produce a suggestion dropdown.
   SimulateElementClick("password");
   CheckSuggestions("", false);
 }
 
 }  // namespace autofill