components/autofill/content/renderer/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/autofill_agent.h"

#include <stddef.h>

#include <tuple>

#include "base/bind.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/i18n/case_conversion.h"
#include "base/location.h"
#include "base/metrics/field_trial.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "components/autofill/content/renderer/form_autofill_util.h"
#include "components/autofill/content/renderer/form_tracker.h"
#include "components/autofill/content/renderer/password_autofill_agent.h"
#include "components/autofill/content/renderer/password_generation_agent.h"
#include "components/autofill/content/renderer/renderer_save_password_progress_logger.h"
#include "components/autofill/core/common/autofill_constants.h"
#include "components/autofill/core/common/autofill_data_validation.h"
#include "components/autofill/core/common/autofill_features.h"
#include "components/autofill/core/common/autofill_switches.h"
#include "components/autofill/core/common/autofill_util.h"
#include "components/autofill/core/common/form_data.h"
#include "components/autofill/core/common/form_data_predictions.h"
#include "components/autofill/core/common/form_field_data.h"
#include "components/autofill/core/common/password_form.h"
#include "components/autofill/core/common/password_form_fill_data.h"
#include "components/autofill/core/common/save_password_progress_logger.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/origin_util.h"
#include "content/public/common/url_constants.h"
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_view.h"
#include "net/cert/cert_status_flags.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
#include "third_party/blink/public/platform/web_keyboard_event.h"
#include "third_party/blink/public/platform/web_url_request.h"
#include "third_party/blink/public/web/web_console_message.h"
#include "third_party/blink/public/web/web_document.h"
#include "third_party/blink/public/web/web_element_collection.h"
#include "third_party/blink/public/web/web_form_control_element.h"
#include "third_party/blink/public/web/web_form_element.h"
#include "third_party/blink/public/web/web_local_frame.h"
#include "third_party/blink/public/web/web_node.h"
#include "third_party/blink/public/web/web_option_element.h"
#include "third_party/blink/public/web/web_user_gesture_indicator.h"
#include "third_party/blink/public/web/web_view.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/events/keycodes/keyboard_codes.h"

using blink::WebAutofillState;
using blink::WebAutofillClient;
using blink::WebConsoleMessage;
using blink::WebDocument;
using blink::WebElement;
using blink::WebElementCollection;
using blink::WebFormControlElement;
using blink::WebFormElement;
using blink::WebFrame;
using blink::WebInputElement;
using blink::WebKeyboardEvent;
using blink::WebLocalFrame;
using blink::WebNode;
using blink::WebOptionElement;
using blink::WebString;
using blink::WebUserGestureIndicator;
using blink::WebVector;

namespace autofill {

namespace {

// Time to wait, in ms, o ensure that only a single select change will be acted
// upon, instead of multiple in close succession (debounce time).
size_t kWaitTimeForSelectOptionsChangesMs = 50;

// Whether the "single click" autofill feature is enabled, through command-line
// or field trial.
bool IsSingleClickEnabled() {
  return base::FeatureList::IsEnabled(features::kSingleClickAutofill);
}

// Gets all the data list values (with corresponding label) for the given
// element.
void GetDataListSuggestions(const WebInputElement& element,
                            std::vector<base::string16>* values,
                            std::vector<base::string16>* labels) {
  for (const auto& option : element.FilteredDataListOptions()) {
    values->push_back(option.Value().Utf16());
    if (option.Value() != option.Label())
      labels->push_back(option.Label().Utf16());
    else
      labels->push_back(base::string16());
  }
}

// Trim the vector before sending it to the browser process to ensure we
// don't send too much data through the IPC.
void TrimStringVectorForIPC(std::vector<base::string16>* strings) {
  // Limit the size of the vector.
  if (strings->size() > kMaxListSize)
    strings->resize(kMaxListSize);

  // Limit the size of the strings in the vector.
  for (size_t i = 0; i < strings->size(); ++i) {
    if ((*strings)[i].length() > kMaxDataLength)
      (*strings)[i].resize(kMaxDataLength);
  }
}

}  // namespace

AutofillAgent::ShowSuggestionsOptions::ShowSuggestionsOptions()
    : autofill_on_empty_values(false),
      requires_caret_at_end(false),
      show_full_suggestion_list(false),
      show_password_suggestions_only(false),
      autoselect_first_suggestion(false) {}

AutofillAgent::AutofillAgent(content::RenderFrame* render_frame,
                             PasswordAutofillAgent* password_autofill_agent,
                             PasswordGenerationAgent* password_generation_agent,
                             blink::AssociatedInterfaceRegistry* registry)
    : content::RenderFrameObserver(render_frame),
      form_cache_(render_frame->GetWebFrame()),
      password_autofill_agent_(password_autofill_agent),
      password_generation_agent_(password_generation_agent),
      autofill_query_id_(0),
      query_node_autofill_state_(WebAutofillState::kNotFilled),
      ignore_text_changes_(false),
      is_popup_possibly_visible_(false),
      is_generation_popup_possibly_visible_(false),
      is_user_gesture_required_(true),
      is_secure_context_required_(false),
      form_tracker_(render_frame),
      binding_(this),
      weak_ptr_factory_(this) {
  render_frame->GetWebFrame()->SetAutofillClient(this);
  password_autofill_agent->SetAutofillAgent(this);
  AddFormObserver(this);
  registry->AddInterface(
      base::Bind(&AutofillAgent::BindRequest, base::Unretained(this)));
}

AutofillAgent::~AutofillAgent() {
  RemoveFormObserver(this);
}

void AutofillAgent::BindRequest(mojom::AutofillAgentAssociatedRequest request) {
  binding_.Bind(std::move(request));
}

bool AutofillAgent::FormDataCompare::operator()(const FormData& lhs,
                                                const FormData& rhs) const {
  return std::tie(lhs.name, lhs.origin, lhs.action, lhs.is_form_tag) <
         std::tie(rhs.name, rhs.origin, rhs.action, rhs.is_form_tag);
}

void AutofillAgent::DidCommitProvisionalLoad(bool is_same_document_navigation,
                                             ui::PageTransition transition) {
  blink::WebFrame* frame = render_frame()->GetWebFrame();
  // TODO(dvadym): check if we need to check if it is main frame navigation
  // http://crbug.com/443155
  if (frame->Parent())
    return;  // Not a top-level navigation.

  if (is_same_document_navigation)
    return;

  // Navigation to a new page or a page refresh.

  element_.Reset();

  form_cache_.Reset();
  ResetLastInteractedElements();
  OnFormNoLongerSubmittable();
}

void AutofillAgent::DidFinishDocumentLoad() {
  ProcessForms();
}

void AutofillAgent::DidChangeScrollOffset() {
  if (element_.IsNull())
    return;

  if (!focus_requires_scroll_) {
    // Post a task here since scroll offset may change during layout.
    // (https://crbug.com/804886)
    weak_ptr_factory_.InvalidateWeakPtrs();
    render_frame()
        ->GetTaskRunner(blink::TaskType::kInternalUserInteraction)
        ->PostTask(FROM_HERE,
                   base::BindOnce(&AutofillAgent::DidChangeScrollOffsetImpl,
                                  weak_ptr_factory_.GetWeakPtr(), element_));
  } else if (!IsKeyboardAccessoryEnabled()) {
    HidePopup();
  }
}

void AutofillAgent::DidChangeScrollOffsetImpl(
    const WebFormControlElement& element) {
  if (element != element_ || element_.IsNull() || focus_requires_scroll_ ||
      !is_popup_possibly_visible_ || !element_.Focused())
    return;

  FormData form;
  FormFieldData field;
  if (form_util::FindFormAndFieldForFormControlElement(element_, &form,
                                                       &field)) {
    GetAutofillDriver()->TextFieldDidScroll(
        form, field,
        render_frame()->GetRenderView()->ElementBoundsInWindow(element_));
  }

  // Ignore subsequent scroll offset changes.
  if (!IsKeyboardAccessoryEnabled())
    HidePopup();
}

void AutofillAgent::FocusedNodeChanged(const WebNode& node) {
  was_focused_before_now_ = false;

  if ((IsKeyboardAccessoryEnabled() || !focus_requires_scroll_) &&
      WebUserGestureIndicator::IsProcessingUserGesture(
          node.IsNull() ? nullptr : node.GetDocument().GetFrame())) {
    focused_node_was_last_clicked_ = true;
    HandleFocusChangeComplete();
  }

  HidePopup();

  if (node.IsNull() || !node.IsElementNode()) {
    if (!last_interacted_form_.IsNull()) {
      // Focus moved away from the last interacted form to somewhere else on
      // the page.
      GetAutofillDriver()->FocusNoLongerOnForm();
    }
    return;
  }

  WebElement web_element = node.ToConst<WebElement>();
  const WebInputElement* element = ToWebInputElement(&web_element);

  if (!last_interacted_form_.IsNull() &&
      (!element || last_interacted_form_ != element->Form())) {
    // The focused element is not part of the last interacted form (could be
    // in a different form).
    GetAutofillDriver()->FocusNoLongerOnForm();
    return;
  }

  if (!element || !element->IsEnabled() || element->IsReadOnly() ||
      !element->IsTextField())
    return;

  element_ = *element;

  FormData form;
  FormFieldData field;
  if (form_util::FindFormAndFieldForFormControlElement(element_, &form,
                                                       &field)) {
    GetAutofillDriver()->FocusOnFormField(
        form, field,
        render_frame()->GetRenderView()->ElementBoundsInWindow(element_));
  }
}

void AutofillAgent::OnDestruct() {
  Shutdown();
  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
}

void AutofillAgent::FireHostSubmitEvents(const WebFormElement& form,
                                         bool known_success,
                                         SubmissionSource source) {
  FormData form_data;
  if (!form_util::ExtractFormData(form, &form_data))
    return;

  FireHostSubmitEvents(form_data, known_success, source);
}

void AutofillAgent::FireHostSubmitEvents(const FormData& form_data,
                                         bool known_success,
                                         SubmissionSource source) {
  // We don't want to fire duplicate submission event.
  if (!submitted_forms_.insert(form_data).second)
    return;

  GetAutofillDriver()->FormSubmitted(form_data, known_success, source,
                                     base::TimeTicks::Now());
}

void AutofillAgent::Shutdown() {
  binding_.Close();
  weak_ptr_factory_.InvalidateWeakPtrs();
}

void AutofillAgent::TextFieldDidEndEditing(const WebInputElement& element) {
  GetAutofillDriver()->DidEndTextFieldEditing();
}

void AutofillAgent::SetUserGestureRequired(bool required) {
  form_tracker_.set_user_gesture_required(required);
}

void AutofillAgent::TextFieldDidChange(const WebFormControlElement& element) {
  form_tracker_.TextFieldDidChange(element);
}

void AutofillAgent::OnTextFieldDidChange(const WebInputElement& element) {
  if (password_generation_agent_ &&
      password_generation_agent_->TextDidChangeInTextField(element)) {
    is_popup_possibly_visible_ = true;
    return;
  }

  if (password_autofill_agent_->TextDidChangeInTextField(element)) {
    is_popup_possibly_visible_ = true;
    element_ = element;
    return;
  }

  ShowSuggestionsOptions options;
  options.requires_caret_at_end = true;
  ShowSuggestions(element, options);

  FormData form;
  FormFieldData field;
  if (form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                       &field)) {
    GetAutofillDriver()->TextFieldDidChange(
        form, field,
        render_frame()->GetRenderView()->ElementBoundsInWindow(element),
        base::TimeTicks::Now());
  }
}

void AutofillAgent::TextFieldDidReceiveKeyDown(const WebInputElement& element,
                                               const WebKeyboardEvent& event) {
  if (event.windows_key_code == ui::VKEY_DOWN ||
      event.windows_key_code == ui::VKEY_UP) {
    ShowSuggestionsOptions options;
    options.autofill_on_empty_values = true;
    options.requires_caret_at_end = true;
    options.autoselect_first_suggestion =
        ShouldAutoselectFirstSuggestionOnArrowDown();
    ShowSuggestions(element, options);
  }
}

void AutofillAgent::OpenTextDataListChooser(const WebInputElement& element) {
  ShowSuggestionsOptions options;
  options.autofill_on_empty_values = true;
  ShowSuggestions(element, options);
}

void AutofillAgent::DataListOptionsChanged(const WebInputElement& element) {
  if (!is_popup_possibly_visible_ || !element.Focused())
    return;

  OnProvisionallySaveForm(WebFormElement(), element,
                          ElementChangeSource::TEXTFIELD_CHANGED);
}

void AutofillAgent::UserGestureObserved() {
  password_autofill_agent_->UserGestureObserved();
}

void AutofillAgent::DoAcceptDataListSuggestion(
    const base::string16& suggested_value) {
  if (element_.IsNull())
    return;

  WebInputElement* input_element = ToWebInputElement(&element_);
  DCHECK(input_element);
  base::string16 new_value = suggested_value;
  // If this element takes multiple values then replace the last part with
  // the suggestion.
  if (input_element->IsMultiple() && input_element->IsEmailField()) {
    base::string16 value = input_element->EditingValue().Utf16();
    std::vector<base::StringPiece16> parts =
        base::SplitStringPiece(value, base::ASCIIToUTF16(","),
                               base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
    if (parts.size() == 0)
      parts.push_back(base::StringPiece16());

    base::string16 last_part = parts.back().as_string();
    // We want to keep just the leading whitespace.
    for (size_t i = 0; i < last_part.size(); ++i) {
      if (!base::IsUnicodeWhitespace(last_part[i])) {
        last_part = last_part.substr(0, i);
        break;
      }
    }
    last_part.append(suggested_value);
    parts.back() = last_part;

    new_value = base::JoinString(parts, base::ASCIIToUTF16(","));
  }
  DoFillFieldWithValue(new_value, input_element);
}

void AutofillAgent::TriggerRefillIfNeeded(const FormData& form) {
  if (!base::FeatureList::IsEnabled(features::kAutofillDynamicForms))
    return;

  ReplaceElementIfNowInvalid(form);

  FormFieldData field;
  FormData updated_form;
  if (form_util::FindFormAndFieldForFormControlElement(element_, &updated_form,
                                                       &field) &&
      (!element_.IsAutofilled() || !form.DynamicallySameFormAs(updated_form))) {
    base::TimeTicks forms_seen_timestamp = base::TimeTicks::Now();
    WebLocalFrame* frame = render_frame()->GetWebFrame();
    std::vector<FormData> forms;
    forms.push_back(updated_form);
    // Always communicate to browser process for topmost frame.
    if (!forms.empty() || !frame->Parent()) {
      GetAutofillDriver()->FormsSeen(forms, forms_seen_timestamp);
    }
  }
}

// mojom::AutofillAgent:
void AutofillAgent::FillForm(int32_t id, const FormData& form) {
  if (element_.IsNull())
    return;

  if (id != autofill_query_id_ && id != kNoQueryId)
    return;

  was_last_action_fill_ = true;

  if (base::FeatureList::IsEnabled(features::kAutofillDynamicForms))
    ReplaceElementIfNowInvalid(form);

  query_node_autofill_state_ = element_.GetAutofillState();
  form_util::FillForm(form, element_);
  if (!element_.Form().IsNull())
    UpdateLastInteractedForm(element_.Form());

  GetAutofillDriver()->DidFillAutofillFormData(form, base::TimeTicks::Now());

  TriggerRefillIfNeeded(form);
}

void AutofillAgent::PreviewForm(int32_t id, const FormData& form) {
  if (element_.IsNull())
    return;

  if (id != autofill_query_id_)
    return;

  query_node_autofill_state_ = element_.GetAutofillState();
  form_util::PreviewForm(form, element_);

  GetAutofillDriver()->DidPreviewAutofillFormData();
}

void AutofillAgent::FieldTypePredictionsAvailable(
    const std::vector<FormDataPredictions>& forms) {
  bool attach_predictions_to_dom =
      base::FeatureList::IsEnabled(features::kAutofillShowTypePredictions);
  for (const auto& form : forms) {
    form_cache_.ShowPredictions(form, attach_predictions_to_dom);
  }
}

void AutofillAgent::ClearSection() {
  if (element_.IsNull())
    return;

  form_cache_.ClearSectionWithElement(element_);
}

void AutofillAgent::ClearPreviewedForm() {
  // TODO(crbug.com/816533): It is very rare, but it looks like the |element_|
  // can be null if a provisional load was committed immediately prior to
  // clearing the previewed form.
  if (element_.IsNull())
    return;

  if (password_autofill_agent_->DidClearAutofillSelection(element_))
    return;

  form_util::ClearPreviewedFormWithElement(element_,
                                           query_node_autofill_state_);
}

void AutofillAgent::FillFieldWithValue(const base::string16& value) {
  if (element_.IsNull())
    return;

  WebInputElement* input_element = ToWebInputElement(&element_);
  if (input_element) {
    DoFillFieldWithValue(value, input_element);
    input_element->SetAutofillState(WebAutofillState::kAutofilled);
  }
}

void AutofillAgent::PreviewFieldWithValue(const base::string16& value) {
  if (element_.IsNull())
    return;

  WebInputElement* input_element = ToWebInputElement(&element_);
  if (input_element)
    DoPreviewFieldWithValue(value, input_element);
}

void AutofillAgent::AcceptDataListSuggestion(const base::string16& value) {
  DoAcceptDataListSuggestion(value);
}

void AutofillAgent::FillPasswordSuggestion(const base::string16& username,
                                           const base::string16& password) {
  if (element_.IsNull())
    return;

  bool handled =
      password_autofill_agent_->FillSuggestion(element_, username, password);
  DCHECK(handled);
}

void AutofillAgent::PreviewPasswordSuggestion(const base::string16& username,
                                              const base::string16& password) {
  if (element_.IsNull())
    return;

  bool handled = password_autofill_agent_->PreviewSuggestion(
      element_, blink::WebString::FromUTF16(username),
      blink::WebString::FromUTF16(password));
  DCHECK(handled);
}

void AutofillAgent::ShowInitialPasswordAccountSuggestions(
    const PasswordFormFillData& form_data) {
  std::vector<blink::WebInputElement> elements;
  std::unique_ptr<RendererSavePasswordProgressLogger> logger;
  if (password_autofill_agent_->logging_state_active()) {
    logger.reset(new RendererSavePasswordProgressLogger(
        GetPasswordManagerDriver().get()));
    logger->LogMessage(SavePasswordProgressLogger::
                           STRING_ON_SHOW_INITIAL_PASSWORD_ACCOUNT_SUGGESTIONS);
  }
  password_autofill_agent_->GetFillableElementFromFormData(
      form_data, logger.get(), &elements);

  // If wait_for_username is true, we don't want to initially show form options
  // until the user types in a valid username.
  if (form_data.wait_for_username)
    return;

  ShowSuggestionsOptions options;
  options.autofill_on_empty_values = true;
  options.show_full_suggestion_list = true;
  for (auto element : elements)
    ShowSuggestions(element, options);
}

bool AutofillAgent::CollectFormlessElements(FormData* output) {
  if (render_frame() == nullptr || render_frame()->GetWebFrame() == nullptr)
    return false;

  WebDocument document = render_frame()->GetWebFrame()->GetDocument();

  // Build up the FormData from the unowned elements. This logic mostly
  // mirrors the construction of the synthetic form in form_cache.cc, but
  // happens at submit-time so we can capture the modifications the user
  // has made, and doesn't depend on form_cache's internal state.
  std::vector<WebElement> fieldsets;
  std::vector<WebFormControlElement> control_elements =
      form_util::GetUnownedAutofillableFormFieldElements(document.All(),
                                                         &fieldsets);

  if (control_elements.size() > form_util::kMaxParseableFields)
    return false;

  const form_util::ExtractMask extract_mask =
      static_cast<form_util::ExtractMask>(form_util::EXTRACT_VALUE |
                                          form_util::EXTRACT_OPTIONS);

  return form_util::UnownedCheckoutFormElementsAndFieldSetsToFormData(
      fieldsets, control_elements, nullptr, document, extract_mask, output,
      nullptr);
}

void AutofillAgent::ShowSuggestions(const WebFormControlElement& element,
                                    const ShowSuggestionsOptions& options) {
  if (!element.IsEnabled() || element.IsReadOnly())
    return;
  if (!element.SuggestedValue().IsEmpty())
    return;

  const WebInputElement* input_element = ToWebInputElement(&element);
  if (input_element) {
    if (!input_element->IsTextField())
      return;
    if (!input_element->SuggestedValue().IsEmpty())
      return;
  } else {
    DCHECK(form_util::IsTextAreaElement(element));
    if (!element.ToConst<WebFormControlElement>().SuggestedValue().IsEmpty())
      return;
  }

  // Don't attempt to autofill with values that are too large or if filling
  // criteria are not met.
  WebString value = element.EditingValue();
  if (value.length() > kMaxDataLength ||
      (!options.autofill_on_empty_values && value.IsEmpty()) ||
      (options.requires_caret_at_end &&
       (element.SelectionStart() != element.SelectionEnd() ||
        element.SelectionEnd() != static_cast<int>(value.length())))) {
    // Any popup currently showing is obsolete.
    HidePopup();
    return;
  }

  element_ = element;
  if (form_util::IsAutofillableInputElement(input_element) &&
      password_autofill_agent_->ShowSuggestions(
          *input_element, options.show_full_suggestion_list,
          is_generation_popup_possibly_visible_)) {
    is_popup_possibly_visible_ = true;
    return;
  }

  if (is_generation_popup_possibly_visible_)
    return;

  if (options.show_password_suggestions_only)
    return;

  // Password field elements should only have suggestions shown by the password
  // autofill agent.
  if (input_element && input_element->IsPasswordFieldForAutofill() &&
      !query_password_suggestion_) {
    return;
  }

  QueryAutofillSuggestions(element, options.autoselect_first_suggestion);
}

void AutofillAgent::SetQueryPasswordSuggestion(bool query) {
  query_password_suggestion_ = query;
}

void AutofillAgent::SetSecureContextRequired(bool required) {
  is_secure_context_required_ = required;
}

void AutofillAgent::SetFocusRequiresScroll(bool require) {
  focus_requires_scroll_ = require;
}

void AutofillAgent::QueryAutofillSuggestions(
    const WebFormControlElement& element,
    bool autoselect_first_suggestion) {
  if (!element.GetDocument().GetFrame())
    return;

  DCHECK(ToWebInputElement(&element) || form_util::IsTextAreaElement(element));

  static int query_counter = 0;
  autofill_query_id_ = query_counter++;

  FormData form;
  FormFieldData field;
  if (!form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                        &field)) {
    // If we didn't find the cached form, at least let autocomplete have a shot
    // at providing suggestions.
    WebFormControlElementToFormField(element, nullptr, form_util::EXTRACT_VALUE,
                                     &field);
  }

  if (is_secure_context_required_ &&
      !(element.GetDocument().IsSecureContext())) {
    LOG(WARNING) << "Autofill suggestions are disabled because the document "
                    "isn't a secure context.";
    return;
  }

  std::vector<base::string16> data_list_values;
  std::vector<base::string16> data_list_labels;
  const WebInputElement* input_element = ToWebInputElement(&element);
  if (input_element) {
    // Find the datalist values and send them to the browser process.
    GetDataListSuggestions(*input_element,
                           &data_list_values,
                           &data_list_labels);
    TrimStringVectorForIPC(&data_list_values);
    TrimStringVectorForIPC(&data_list_labels);
  }

  is_popup_possibly_visible_ = true;

  GetAutofillDriver()->SetDataList(data_list_values, data_list_labels);
  GetAutofillDriver()->QueryFormFieldAutofill(
      autofill_query_id_, form, field,
      render_frame()->GetRenderView()->ElementBoundsInWindow(element_),
      autoselect_first_suggestion);
}

void AutofillAgent::DoFillFieldWithValue(const base::string16& value,
                                         WebInputElement* node) {
  form_tracker_.set_ignore_control_changes(true);
  node->SetAutofillValue(blink::WebString::FromUTF16(value));
  password_autofill_agent_->UpdateStateForTextChange(*node);
  form_tracker_.set_ignore_control_changes(false);
}

void AutofillAgent::DoPreviewFieldWithValue(const base::string16& value,
                                            WebInputElement* node) {
  query_node_autofill_state_ = element_.GetAutofillState();
  node->SetSuggestedValue(blink::WebString::FromUTF16(value));
  node->SetAutofillState(WebAutofillState::kPreviewed);
  form_util::PreviewSuggestion(node->SuggestedValue().Utf16(),
                               node->Value().Utf16(), node);
}

void AutofillAgent::ProcessForms() {
  // Record timestamp of when the forms are first seen. This is used to
  // measure the overhead of the Autofill feature.
  base::TimeTicks forms_seen_timestamp = base::TimeTicks::Now();

  WebLocalFrame* frame = render_frame()->GetWebFrame();
  std::vector<FormData> forms = form_cache_.ExtractNewForms();

  // Always communicate to browser process for topmost frame.
  if (!forms.empty() || !frame->Parent()) {
    GetAutofillDriver()->FormsSeen(forms, forms_seen_timestamp);
  }
}

void AutofillAgent::HidePopup() {
  if (!is_popup_possibly_visible_)
    return;
  is_popup_possibly_visible_ = false;
  is_generation_popup_possibly_visible_ = false;

  GetAutofillDriver()->HidePopup();
}

bool AutofillAgent::IsUserGesture() const {
  return WebUserGestureIndicator::IsProcessingUserGesture(
      render_frame()->GetWebFrame());
}

void AutofillAgent::DidAssociateFormControlsDynamically() {
  // If the control flow is here than the document was at least loaded. The
  // whole page doesn't have to be loaded.
  ProcessForms();
  password_autofill_agent_->OnDynamicFormsSeen();
  if (password_generation_agent_)
    password_generation_agent_->OnDynamicFormsSeen();
}

void AutofillAgent::DidCompleteFocusChangeInFrame() {
  WebDocument doc = render_frame()->GetWebFrame()->GetDocument();
  WebElement focused_element;
  if (!doc.IsNull())
    focused_element = doc.FocusedElement();
  // PasswordGenerationAgent needs to know about focus changes, even if there is
  // no focused element.
  if (password_generation_agent_ &&
      password_generation_agent_->FocusedNodeHasChanged(focused_element)) {
    is_generation_popup_possibly_visible_ = true;
    is_popup_possibly_visible_ = true;
  }
  if (!focused_element.IsNull() && password_autofill_agent_)
    password_autofill_agent_->FocusedNodeHasChanged(focused_element);

  if (!IsKeyboardAccessoryEnabled() && focus_requires_scroll_)
    HandleFocusChangeComplete();
}

void AutofillAgent::DidReceiveLeftMouseDownOrGestureTapInNode(
    const WebNode& node) {
  DCHECK(!node.IsNull());
  focused_node_was_last_clicked_ = node.Focused();

  if (IsKeyboardAccessoryEnabled() || !focus_requires_scroll_)
    HandleFocusChangeComplete();
}

void AutofillAgent::SelectControlDidChange(
    const WebFormControlElement& element) {
  form_tracker_.SelectControlDidChange(element);
}

void AutofillAgent::SelectFieldOptionsChanged(
    const blink::WebFormControlElement& element) {
  if (!was_last_action_fill_ || element_.IsNull())
    return;

  // Since a change of a select options often come in batches, use a timer
  // to wait for other changes. Stop the timer if it was already running. It
  // will be started again for this change.
  if (on_select_update_timer_.IsRunning())
    on_select_update_timer_.AbandonAndStop();

  // Start the timer to notify the driver that the select field was updated
  // after the options have finished changing,
  on_select_update_timer_.Start(
      FROM_HERE,
      base::TimeDelta::FromMilliseconds(kWaitTimeForSelectOptionsChangesMs),
      base::BindRepeating(&AutofillAgent::SelectWasUpdated,
                          weak_ptr_factory_.GetWeakPtr(), element));
}

void AutofillAgent::SelectWasUpdated(
    const blink::WebFormControlElement& element) {
  // Look for the form and field associated with the select element. If they are
  // found, notify the driver that the the form was modified dynamically.
  FormData form;
  FormFieldData field;
  if (form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                       &field) &&
      !field.option_values.empty()) {
    GetAutofillDriver()->SelectFieldOptionsDidChange(form);
  }
}

void AutofillAgent::FormControlElementClicked(
    const WebFormControlElement& element,
    bool was_focused) {
  last_clicked_form_control_element_for_testing_ = element;
  last_clicked_form_control_element_was_focused_for_testing_ = was_focused;
  was_last_action_fill_ = false;

  const WebInputElement* input_element = ToWebInputElement(&element);
  if (!input_element && !form_util::IsTextAreaElement(element))
    return;

  ShowSuggestionsOptions options;
  options.autofill_on_empty_values = true;
  // Show full suggestions when clicking on an already-focused form field.
  options.show_full_suggestion_list = element.IsAutofilled() || was_focused;

  if (!IsSingleClickEnabled()) {
    // On  the initial click (not focused yet), only show password suggestions.
    options.show_password_suggestions_only = !was_focused;
  }
  ShowSuggestions(element, options);
}

void AutofillAgent::HandleFocusChangeComplete() {
  WebElement focused_element =
      render_frame()->GetWebFrame()->GetDocument().FocusedElement();

  if (focused_node_was_last_clicked_ && !focused_element.IsNull() &&
      focused_element.IsFormControlElement() &&
      (form_util::IsTextInput(blink::ToWebInputElement(&focused_element)) ||
       focused_element.HasHTMLTagName("textarea"))) {
    FormControlElementClicked(focused_element.ToConst<WebFormControlElement>(),
                              was_focused_before_now_);
  }

  was_focused_before_now_ = true;
  focused_node_was_last_clicked_ = false;
}

void AutofillAgent::AjaxSucceeded() {
  form_tracker_.AjaxSucceeded();
}

void AutofillAgent::OnProvisionallySaveForm(
    const WebFormElement& form,
    const WebFormControlElement& element,
    ElementChangeSource source) {
  if (source == ElementChangeSource::WILL_SEND_SUBMIT_EVENT) {
    // Fire the form submission event to avoid missing submission when web site
    // handles the onsubmit event, this also gets the form before Javascript
    // could change it.
    // We don't clear submitted_forms_ because OnFormSubmitted will normally be
    // invoked afterwards and we don't want to fire the same event twice.
    FireHostSubmitEvents(form, /*known_success=*/false,
                         SubmissionSource::FORM_SUBMISSION);
    ResetLastInteractedElements();
    return;
  } else if (source == ElementChangeSource::TEXTFIELD_CHANGED ||
             source == ElementChangeSource::SELECT_CHANGED) {
    // Remember the last form the user interacted with.
    if (!element.Form().IsNull()) {
      UpdateLastInteractedForm(element.Form());
    } else {
      // Remove invisible elements
      for (auto it = formless_elements_user_edited_.begin();
           it != formless_elements_user_edited_.end();) {
        if (form_util::IsWebElementVisible(*it)) {
          it = formless_elements_user_edited_.erase(it);
        } else {
          ++it;
        }
      }
      formless_elements_user_edited_.insert(element);
      provisionally_saved_form_ = std::make_unique<FormData>();
      if (!CollectFormlessElements(provisionally_saved_form_.get())) {
        provisionally_saved_form_.reset();
      } else {
        last_interacted_form_.Reset();
      }
    }

    if (source == ElementChangeSource::TEXTFIELD_CHANGED)
      OnTextFieldDidChange(*ToWebInputElement(&element));
    else {
      FormData form;
      FormFieldData field;
      if (form_util::FindFormAndFieldForFormControlElement(element, &form,
                                                           &field)) {
        GetAutofillDriver()->SelectControlDidChange(
            form, field,
            render_frame()->GetRenderView()->ElementBoundsInWindow(element));
      }
    }
  }
}

void AutofillAgent::OnProbablyFormSubmitted() {
  FormData form_data;
  if (GetSubmittedForm(&form_data)) {
    FireHostSubmitEvents(form_data, /*known_success=*/false,
                         SubmissionSource::PROBABLY_FORM_SUBMITTED);
  }
  ResetLastInteractedElements();
  OnFormNoLongerSubmittable();
}

void AutofillAgent::OnFormSubmitted(const WebFormElement& form) {
  // Fire the submission event here because WILL_SEND_SUBMIT_EVENT is skipped
  // if javascript calls submit() directly.
  FireHostSubmitEvents(form, /*known_success=*/false,
                       SubmissionSource::FORM_SUBMISSION);
  ResetLastInteractedElements();
  OnFormNoLongerSubmittable();
}

void AutofillAgent::OnInferredFormSubmission(SubmissionSource source) {
  // Only handle iframe for FRAME_DETACHED or main frame for
  // SAME_DOCUMENT_NAVIGATION.
  if ((source == SubmissionSource::FRAME_DETACHED &&
       !render_frame()->GetWebFrame()->Parent()) ||
      (source == SubmissionSource::SAME_DOCUMENT_NAVIGATION &&
       render_frame()->GetWebFrame()->Parent())) {
    ResetLastInteractedElements();
    OnFormNoLongerSubmittable();
    return;
  }

  if (source == SubmissionSource::FRAME_DETACHED) {
    // Should not access the frame because it is now detached. Instead, use
    // |provisionally_saved_form_|.
    if (provisionally_saved_form_)
      FireHostSubmitEvents(*provisionally_saved_form_, /*known_success=*/true,
                           source);
  } else {
    FormData form_data;
    if (GetSubmittedForm(&form_data))
      FireHostSubmitEvents(form_data, /*known_success=*/true, source);
  }
  ResetLastInteractedElements();
  OnFormNoLongerSubmittable();
}

void AutofillAgent::AddFormObserver(Observer* observer) {
  form_tracker_.AddObserver(observer);
}

void AutofillAgent::RemoveFormObserver(Observer* observer) {
  form_tracker_.RemoveObserver(observer);
}

bool AutofillAgent::GetSubmittedForm(FormData* form) {
  if (!last_interacted_form_.IsNull()) {
    if (form_util::ExtractFormData(last_interacted_form_, form)) {
      return true;
    } else if (provisionally_saved_form_) {
      *form = *provisionally_saved_form_;
      return true;
    }
  } else if (formless_elements_user_edited_.size() != 0 &&
             !form_util::IsSomeControlElementVisible(
                 formless_elements_user_edited_)) {
    // we check if all the elements the user has interacted with are gone,
    // to decide if submission has occurred, and use the
    // provisionally_saved_form_ saved in OnProvisionallySaveForm() if fail to
    // construct form.
    if (CollectFormlessElements(form)) {
      return true;
    } else if (provisionally_saved_form_) {
      *form = *provisionally_saved_form_;
      return true;
    }
  }
  return false;
}

void AutofillAgent::ResetLastInteractedElements() {
  last_interacted_form_.Reset();
  last_clicked_form_control_element_for_testing_.Reset();
  formless_elements_user_edited_.clear();
  provisionally_saved_form_.reset();
}

void AutofillAgent::UpdateLastInteractedForm(blink::WebFormElement form) {
  last_interacted_form_ = form;
  provisionally_saved_form_ = std::make_unique<FormData>();
  if (!form_util::ExtractFormData(last_interacted_form_,
                                  provisionally_saved_form_.get())) {
    provisionally_saved_form_.reset();
  }
}

void AutofillAgent::OnFormNoLongerSubmittable() {
  submitted_forms_.clear();
}

bool AutofillAgent::FindTheUniqueNewVersionOfOldElement(
    WebVector<WebFormControlElement>& elements,
    bool& element_found,
    const WebString& original_element_section,
    const WebFormControlElement& original_element) {
  for (const WebFormControlElement& current_element : elements) {
    if (current_element.IsFocusable() &&
        original_element.NameForAutofill() ==
            current_element.NameForAutofill()) {
      if (!element_found) {
        element_ = current_element;
        element_found = true;
      } else if (current_element.AutofillSection() ==
                     element_.AutofillSection() ||
                 (current_element.AutofillSection() !=
                      original_element_section &&
                  element_.AutofillSection() != original_element_section)) {
        // If there are two elements that share the same name with the element_,
        // and the section can't tell them apart, we can't decide between the
        // two.
        element_ = original_element;
        return false;
      } else if (current_element.AutofillSection() ==
                 original_element_section) {
        // If the current element has the right section, update the element_.
        element_ = current_element;
      }
    }
  }
  return true;
}

void AutofillAgent::ReplaceElementIfNowInvalid(const FormData& original_form) {
  // If the document is invalid, bail out.
  if (element_.GetDocument().IsNull())
    return;

  WebVector<WebFormElement> forms;
  WebVector<WebFormControlElement> elements;

  if (original_form.name.empty()) {
    // If the form has no name, check all the forms.
    bool element_found = false;
    element_.GetDocument().Forms(forms);
    for (const WebFormElement& form : forms) {
      form.GetFormControlElements(elements);
      // If finding a unique element is impossible, return.
      if (!FindTheUniqueNewVersionOfOldElement(
              elements, element_found, element_.AutofillSection(), element_))
        return;
    }
    // If the element is not found, we should still check for unowned elements.
    if (element_found)
      return;
  }

  if (!element_.Form().IsNull()) {
    // If |element_|'s parent form has no elements, |element_| is now invalid
    // and should be updated.
    WebVector<WebFormControlElement> form_elements;
    element_.Form().GetFormControlElements(form_elements);
    if (!form_elements.empty())
      return;
  }

  WebFormElement form_element;
  if (!original_form.name.empty()) {
    // Try to find the new version of the form.
    element_.GetDocument().Forms(forms);
    for (const WebFormElement& form : forms) {
      if (original_form.name == form.GetName().Utf16() ||
          original_form.name == form.GetAttribute("id").Utf16()) {
        form_element = form;
        break;
      }
    }
  }

  if (form_element.IsNull()) {
    // Could not find the new version of the form, get all the unowned elements.
    std::vector<WebElement> fieldsets;
    elements = form_util::GetUnownedAutofillableFormFieldElements(
        element_.GetDocument().All(), &fieldsets);
    bool element_found = false;
    FindTheUniqueNewVersionOfOldElement(elements, element_found,
                                        element_.AutofillSection(), element_);
    return;
  }
  // This is the case for owned fields that belong to the right named form.
  // Get all the elements of the new version of the form.
  form_element.GetFormControlElements(elements);
  // Try to find the new version of the last interacted element.
  for (const WebFormControlElement& element : elements) {
    if (element_.NameForAutofill() == element.NameForAutofill()) {
      element_ = element;
      return;
    }
  }
}

const mojom::AutofillDriverAssociatedPtr& AutofillAgent::GetAutofillDriver() {
  if (!autofill_driver_) {
    render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
        mojo::MakeRequest(&autofill_driver_));
  }

  return autofill_driver_;
}

const mojom::PasswordManagerDriverAssociatedPtr&
AutofillAgent::GetPasswordManagerDriver() {
  DCHECK(password_autofill_agent_);
  return password_autofill_agent_->GetPasswordManagerDriver();
}

}  // namespace autofill