Add a flag for fill on account select without highlighting

components/autofill/content/renderer/password_autofill_agent.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 "components/autofill/content/renderer/password_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 30 matching lines @@
 #include "url/gurl.h"
 
 namespace autofill {
 namespace {
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
 // Experiment information
 const char kFillOnAccountSelectFieldTrialName[] = "FillOnAccountSelect";
-const char kFillOnAccountSelectFieldTrialEnabledGroup[] = "Enable";
+const char kFillOnAccountSelectFieldTrialEnabledWithHighlightGroup[] =
+    "EnableWithHighlight";
+const char kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup[] =
+    "EnableWithNoHighlight";
 
 // Maps element names to the actual elements to simplify form filling.
 typedef std::map<base::string16, blink::WebInputElement> FormInputElementMap;
 
 // Use the shorter name when referencing SavePasswordProgressLogger::StringID
 // values to spare line breaks. The code provides enough context for that
 // already.
 typedef SavePasswordProgressLogger Logger;
 
 // Utility struct for form lookup and autofill. When we parse the DOM to look up
@@ skipping 69 matching lines @@
 bool ShouldFillOnAccountSelect() {
   std::string group_name =
       base::FieldTrialList::FindFullName(kFillOnAccountSelectFieldTrialName);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableFillOnAccountSelect)) {
     return false;
   }
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableFillOnAccountSelect) ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableFillOnAccountSelectNoHighlighting)) {
+    return true;
+  }
+
+  return group_name ==
+             kFillOnAccountSelectFieldTrialEnabledWithHighlightGroup ||
+         group_name ==
+             kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup;
+}
+
+bool ShouldHighlightFields() {
+  std::string group_name =
+      base::FieldTrialList::FindFullName(kFillOnAccountSelectFieldTrialName);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableFillOnAccountSelect) ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableFillOnAccountSelect)) {
     return true;
   }
 
-  return group_name == kFillOnAccountSelectFieldTrialEnabledGroup;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableFillOnAccountSelectNoHighlighting)) {
+    return false;
+  }
+
+  return group_name !=
+         kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup;
 }
 
 // Helper to search the given form element for the specified input elements in
 // |data|, and add results to |result|.
 bool FindFormInputElements(blink::WebFormElement* form_element,
                            const PasswordFormFillData& data,
                            FormElements* result) {
   return FindFormInputElement(form_element, data.password_field, result) &&
          (!FillDataContainsUsername(data) ||
           FindFormInputElement(form_element, data.username_field, result));
@@ skipping 258 matching lines @@
   // If we can't modify the password, don't try to set the username
   if (!IsElementAutocompletable(password_element))
     return false;
 
   bool form_contains_username_field = FillDataContainsUsername(fill_data);
   // If the form contains an autocompletable username field, try to set the
   // username to the preferred name, but only if:
   //   (a) The fill-on-account-select flag is not set, and
   //   (b) The username element isn't prefilled
   //
-  // If (a) is false, then just mark the username element as autofilled and
-  // return so the fill step is skipped.
+  // If (a) is false, then just mark the username element as autofilled if the
+  // user is not in the "no highlighting" group and return so the fill step is
+  // skipped.
   //
   // If there is no autocompletable username field, and (a) is false, then the
   // username element cannot be autofilled, but the user should still be able to
   // select to fill the password element, so the password element must be marked
-  // as autofilled and the fill step should also be skipped.
+  // as autofilled and the fill step should also be skipped if the user is not
+  // in the "no highlighting" group.
   //
   // In all other cases, do nothing.
   bool form_has_fillable_username = form_contains_username_field &&
                                     IsElementAutocompletable(username_element);
 
   if (ShouldFillOnAccountSelect()) {
+    if (!ShouldHighlightFields()) {
+      return false;
+    }
+
     if (form_has_fillable_username) {
       username_element.setAutofilled(true);
     } else {
       password_element.setAutofilled(true);
     }
     return false;
   }
 
   if (form_has_fillable_username && username_element.value().isEmpty()) {
     // TODO(tkent): Check maxlength and pattern.
@@ skipping 875 matching lines @@
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::FrameDetached(
     blink::WebFrame* frame) {
   agent_->FrameDetached(frame);
 }
 
 }  // namespace autofill