// 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 "base/bind.h" #include "base/command_line.h" #include "base/message_loop/message_loop.h" #include "base/strings/string_split.h" #include "base/strings/string_util.h" #include "base/strings/utf_string_conversions.h" #include "base/time/time.h" #include "components/autofill/content/common/autofill_messages.h" #include "components/autofill/content/renderer/form_autofill_util.h" #include "components/autofill/content/renderer/page_click_tracker.h" #include "components/autofill/content/renderer/password_autofill_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_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/web_element_descriptor.h" #include "content/public/common/content_switches.h" #include "content/public/common/ssl_status.h" #include "content/public/common/url_constants.h" #include "content/public/renderer/render_view.h" #include "grit/component_strings.h" #include "net/cert/cert_status_flags.h" #include "third_party/WebKit/public/platform/WebRect.h" #include "third_party/WebKit/public/platform/WebURLRequest.h" #include "third_party/WebKit/public/web/WebDataSource.h" #include "third_party/WebKit/public/web/WebDocument.h" #include "third_party/WebKit/public/web/WebFormControlElement.h" #include "third_party/WebKit/public/web/WebFormElement.h" #include "third_party/WebKit/public/web/WebFrame.h" #include "third_party/WebKit/public/web/WebInputEvent.h" #include "third_party/WebKit/public/web/WebNode.h" #include "third_party/WebKit/public/web/WebNodeCollection.h" #include "third_party/WebKit/public/web/WebOptionElement.h" #include "third_party/WebKit/public/web/WebView.h" #include "ui/base/l10n/l10n_util.h" #include "ui/events/keycodes/keyboard_codes.h" using blink::WebAutofillClient; using blink::WebFormControlElement; using blink::WebFormElement; using blink::WebFrame; using blink::WebInputElement; using blink::WebKeyboardEvent; using blink::WebNode; using blink::WebNodeCollection; using blink::WebOptionElement; using blink::WebString; namespace { // The size above which we stop triggering autofill for an input text field // (so to avoid sending long strings through IPC). const size_t kMaximumTextSizeForAutofill = 1000; // The maximum number of data list elements to send to the browser process // via IPC (to prevent long IPC messages). const size_t kMaximumDataListSizeForAutofill = 30; // Gets all the data list values (with corresponding label) for the given // element. void GetDataListSuggestions(const blink::WebInputElement& element, bool ignore_current_value, std::vector<base::string16>* values, std::vector<base::string16>* labels) { WebNodeCollection options = element.dataListOptions(); if (options.isNull()) return; base::string16 prefix; if (!ignore_current_value) { prefix = element.editingValue(); if (element.isMultiple() && element.formControlType() == WebString::fromUTF8("email")) { std::vector<base::string16> parts; base::SplitStringDontTrim(prefix, ',', &parts); if (parts.size() > 0) TrimWhitespace(parts[parts.size() - 1], TRIM_LEADING, &prefix); } } for (WebOptionElement option = options.firstItem().to<WebOptionElement>(); !option.isNull(); option = options.nextItem().to<WebOptionElement>()) { if (!StartsWith(option.value(), prefix, false) || option.value() == prefix || !element.isValidValue(option.value())) continue; values->push_back(option.value()); if (option.value() != option.label()) labels->push_back(option.label()); 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() > kMaximumDataListSizeForAutofill) strings->resize(kMaximumDataListSizeForAutofill); // Limit the size of the strings in the vector. for (size_t i = 0; i < strings->size(); ++i) { if ((*strings)[i].length() > kMaximumTextSizeForAutofill) (*strings)[i].resize(kMaximumTextSizeForAutofill); } } gfx::RectF GetScaledBoundingBox(float scale, WebInputElement* element) { gfx::Rect bounding_box(element->boundsInViewportSpace()); return gfx::RectF(bounding_box.x() * scale, bounding_box.y() * scale, bounding_box.width() * scale, bounding_box.height() * scale); } } // namespace namespace autofill { AutofillAgent::AutofillAgent(content::RenderView* render_view, PasswordAutofillAgent* password_autofill_agent) : content::RenderViewObserver(render_view), password_autofill_agent_(password_autofill_agent), autofill_query_id_(0), autofill_action_(AUTOFILL_NONE), web_view_(render_view->GetWebView()), display_warning_if_disabled_(false), was_query_node_autofilled_(false), has_shown_autofill_popup_for_current_edit_(false), did_set_node_text_(false), has_new_forms_for_browser_(false), ignore_text_changes_(false), weak_ptr_factory_(this) { render_view->GetWebView()->setAutofillClient(this); // The PageClickTracker is a RenderViewObserver, and hence will be freed when // the RenderView is destroyed. new PageClickTracker(render_view, this); } AutofillAgent::~AutofillAgent() {} bool AutofillAgent::OnMessageReceived(const IPC::Message& message) { bool handled = true; IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message) IPC_MESSAGE_HANDLER(AutofillMsg_FormDataFilled, OnFormDataFilled) IPC_MESSAGE_HANDLER(AutofillMsg_FieldTypePredictionsAvailable, OnFieldTypePredictionsAvailable) IPC_MESSAGE_HANDLER(AutofillMsg_SetAutofillActionFill, OnSetAutofillActionFill) IPC_MESSAGE_HANDLER(AutofillMsg_ClearForm, OnClearForm) IPC_MESSAGE_HANDLER(AutofillMsg_SetAutofillActionPreview, OnSetAutofillActionPreview) IPC_MESSAGE_HANDLER(AutofillMsg_ClearPreviewedForm, OnClearPreviewedForm) IPC_MESSAGE_HANDLER(AutofillMsg_SetNodeText, OnSetNodeText) IPC_MESSAGE_HANDLER(AutofillMsg_AcceptDataListSuggestion, OnAcceptDataListSuggestion) IPC_MESSAGE_HANDLER(AutofillMsg_AcceptPasswordAutofillSuggestion, OnAcceptPasswordAutofillSuggestion) IPC_MESSAGE_HANDLER(AutofillMsg_RequestAutocompleteResult, OnRequestAutocompleteResult) IPC_MESSAGE_HANDLER(AutofillMsg_PageShown, OnPageShown) IPC_MESSAGE_UNHANDLED(handled = false) IPC_END_MESSAGE_MAP() return handled; } void AutofillAgent::DidFinishDocumentLoad(WebFrame* frame) { // Record timestamp on document load. This is used to record overhead of // Autofill feature. forms_seen_timestamp_ = base::TimeTicks::Now(); // The document has now been fully loaded. Scan for forms to be sent up to // the browser. std::vector<FormData> forms; bool has_more_forms = false; if (!frame->parent()) { form_elements_.clear(); has_more_forms = form_cache_.ExtractFormsAndFormElements( *frame, kRequiredAutofillFields, &forms, &form_elements_); } else { form_cache_.ExtractForms(*frame, &forms); } autofill::FormsSeenState state = has_more_forms ? autofill::PARTIAL_FORMS_SEEN : autofill::NO_SPECIAL_FORMS_SEEN; // Always communicate to browser process for topmost frame. if (!forms.empty() || !frame->parent()) { Send(new AutofillHostMsg_FormsSeen(routing_id(), forms, forms_seen_timestamp_, state)); } } void AutofillAgent::DidCommitProvisionalLoad(WebFrame* frame, bool is_new_navigation) { in_flight_request_form_.reset(); } void AutofillAgent::FrameDetached(WebFrame* frame) { form_cache_.ResetFrame(*frame); } void AutofillAgent::WillSubmitForm(WebFrame* frame, const WebFormElement& form) { FormData form_data; if (WebFormElementToFormData(form, WebFormControlElement(), REQUIRE_AUTOCOMPLETE, static_cast<ExtractMask>( EXTRACT_VALUE | EXTRACT_OPTION_TEXT), &form_data, NULL)) { Send(new AutofillHostMsg_FormSubmitted(routing_id(), form_data, base::TimeTicks::Now())); } } void AutofillAgent::ZoomLevelChanged() { // Any time the zoom level changes, the page's content moves, so any Autofill // popups should be hidden. This is only needed for the new Autofill UI // because WebKit already knows to hide the old UI when this occurs. HideAutofillUI(); } void AutofillAgent::FocusedNodeChanged(const blink::WebNode& node) { if (node.isNull() || !node.isElementNode()) return; blink::WebElement web_element = node.toConst<blink::WebElement>(); if (!web_element.document().frame()) return; const WebInputElement* element = toWebInputElement(&web_element); if (!element || !element->isEnabled() || element->isReadOnly() || !element->isTextField() || element->isPasswordField()) return; element_ = *element; } void AutofillAgent::OrientationChangeEvent(int orientation) { HideAutofillUI(); } void AutofillAgent::DidChangeScrollOffset(blink::WebFrame*) { HideAutofillUI(); } void AutofillAgent::didRequestAutocomplete(blink::WebFrame* frame, const WebFormElement& form) { // Disallow the dialog over non-https or broken https, except when the // ignore SSL flag is passed. See http://crbug.com/272512. // TODO(palmer): this should be moved to the browser process after frames // get their own processes. GURL url(frame->document().url()); content::SSLStatus ssl_status = render_view()->GetSSLStatusOfFrame(frame); bool is_safe = url.SchemeIs(content::kHttpsScheme) && !net::IsCertStatusError(ssl_status.cert_status); bool allow_unsafe = CommandLine::ForCurrentProcess()->HasSwitch( ::switches::kReduceSecurityForTesting); FormData form_data; if (!in_flight_request_form_.isNull() || (!is_safe && !allow_unsafe) || !WebFormElementToFormData(form, WebFormControlElement(), REQUIRE_AUTOCOMPLETE, EXTRACT_OPTIONS, &form_data, NULL)) { WebFormElement(form).finishRequestAutocomplete( WebFormElement::AutocompleteResultErrorDisabled); return; } // Cancel any pending Autofill requests and hide any currently showing popups. ++autofill_query_id_; HideAutofillUI(); in_flight_request_form_ = form; Send(new AutofillHostMsg_RequestAutocomplete(routing_id(), form_data, url)); } void AutofillAgent::setIgnoreTextChanges(bool ignore) { ignore_text_changes_ = ignore; } void AutofillAgent::InputElementClicked(const WebInputElement& element, bool was_focused, bool is_focused) { if (was_focused) ShowSuggestions(element, true, false, true, false); } void AutofillAgent::InputElementLostFocus() { HideAutofillUI(); } void AutofillAgent::didClearAutofillSelection(const WebNode& node) { if (password_autofill_agent_->DidClearAutofillSelection(node)) return; if (!element_.isNull() && node == element_) { ClearPreviewedFormWithElement(element_, was_query_node_autofilled_); } else { // TODO(isherman): There seem to be rare cases where this code *is* // reachable: see [ http://crbug.com/96321#c6 ]. Ideally we would // understand those cases and fix the code to avoid them. However, so far I // have been unable to reproduce such a case locally. If you hit this // NOTREACHED(), please file a bug against me. NOTREACHED(); } } void AutofillAgent::textFieldDidEndEditing(const WebInputElement& element) { password_autofill_agent_->TextFieldDidEndEditing(element); has_shown_autofill_popup_for_current_edit_ = false; Send(new AutofillHostMsg_DidEndTextFieldEditing(routing_id())); } void AutofillAgent::textFieldDidChange(const WebInputElement& element) { if (ignore_text_changes_) return; if (did_set_node_text_) { did_set_node_text_ = false; return; } // We post a task for doing the Autofill as the caret position is not set // properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976) and // it is needed to trigger autofill. weak_ptr_factory_.InvalidateWeakPtrs(); base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&AutofillAgent::TextFieldDidChangeImpl, weak_ptr_factory_.GetWeakPtr(), element)); } void AutofillAgent::TextFieldDidChangeImpl(const WebInputElement& element) { // If the element isn't focused then the changes don't matter. This check is // required to properly handle IME interactions. if (!element.focused()) return; if (password_autofill_agent_->TextDidChangeInTextField(element)) { element_ = element; return; } ShowSuggestions(element, false, true, false, false); FormData form; FormFieldData field; if (FindFormAndFieldForInputElement(element, &form, &field, REQUIRE_NONE)) { Send(new AutofillHostMsg_TextFieldDidChange(routing_id(), form, field, base::TimeTicks::Now())); } } void AutofillAgent::textFieldDidReceiveKeyDown(const WebInputElement& element, const WebKeyboardEvent& event) { if (password_autofill_agent_->TextFieldHandlingKeyDown(element, event)) { element_ = element; return; } if (event.windowsKeyCode == ui::VKEY_DOWN || event.windowsKeyCode == ui::VKEY_UP) ShowSuggestions(element, true, true, true, false); } void AutofillAgent::openTextDataListChooser(const WebInputElement& element) { ShowSuggestions(element, true, false, false, true); } void AutofillAgent::AcceptDataListSuggestion( const base::string16& suggested_value) { base::string16 new_value = suggested_value; // If this element takes multiple values then replace the last part with // the suggestion. if (element_.isMultiple() && element_.formControlType() == WebString::fromUTF8("email")) { std::vector<base::string16> parts; base::SplitStringDontTrim(element_.editingValue(), ',', &parts); if (parts.size() == 0) parts.push_back(base::string16()); base::string16 last_part = parts.back(); // We want to keep just the leading whitespace. for (size_t i = 0; i < last_part.size(); ++i) { if (!IsWhitespace(last_part[i])) { last_part = last_part.substr(0, i); break; } } last_part.append(suggested_value); parts[parts.size() - 1] = last_part; new_value = JoinString(parts, ','); } SetNodeText(new_value, &element_); } void AutofillAgent::OnFormDataFilled(int query_id, const FormData& form) { if (!render_view()->GetWebView() || query_id != autofill_query_id_) return; was_query_node_autofilled_ = element_.isAutofilled(); switch (autofill_action_) { case AUTOFILL_FILL: FillForm(form, element_); Send(new AutofillHostMsg_DidFillAutofillFormData(routing_id(), base::TimeTicks::Now())); break; case AUTOFILL_PREVIEW: PreviewForm(form, element_); Send(new AutofillHostMsg_DidPreviewAutofillFormData(routing_id())); break; default: NOTREACHED(); } autofill_action_ = AUTOFILL_NONE; } void AutofillAgent::OnFieldTypePredictionsAvailable( const std::vector<FormDataPredictions>& forms) { for (size_t i = 0; i < forms.size(); ++i) { form_cache_.ShowPredictions(forms[i]); } } void AutofillAgent::OnSetAutofillActionFill() { autofill_action_ = AUTOFILL_FILL; } void AutofillAgent::OnClearForm() { form_cache_.ClearFormWithElement(element_); } void AutofillAgent::OnSetAutofillActionPreview() { autofill_action_ = AUTOFILL_PREVIEW; } void AutofillAgent::OnClearPreviewedForm() { didClearAutofillSelection(element_); } void AutofillAgent::OnSetNodeText(const base::string16& value) { SetNodeText(value, &element_); } void AutofillAgent::OnAcceptDataListSuggestion(const base::string16& value) { AcceptDataListSuggestion(value); } void AutofillAgent::OnAcceptPasswordAutofillSuggestion( const base::string16& username) { // We need to make sure this is handled here because the browser process // skipped it handling because it believed it would be handled here. If it // isn't handled here then the browser logic needs to be updated. bool handled = password_autofill_agent_->DidAcceptAutofillSuggestion( element_, username); DCHECK(handled); } void AutofillAgent::OnRequestAutocompleteResult( WebFormElement::AutocompleteResult result, const FormData& form_data) { if (in_flight_request_form_.isNull()) return; if (result == WebFormElement::AutocompleteResultSuccess) { FillFormIncludingNonFocusableElements(form_data, in_flight_request_form_); if (!in_flight_request_form_.checkValidityWithoutDispatchingEvents()) result = WebFormElement::AutocompleteResultErrorInvalid; } in_flight_request_form_.finishRequestAutocomplete(result); in_flight_request_form_.reset(); } void AutofillAgent::OnPageShown() { } void AutofillAgent::ShowSuggestions(const WebInputElement& element, bool autofill_on_empty_values, bool requires_caret_at_end, bool display_warning_if_disabled, bool datalist_only) { if (!element.isEnabled() || element.isReadOnly() || !element.isTextField() || element.isPasswordField()) return; if (!datalist_only && !element.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 (!datalist_only && (value.length() > kMaximumTextSizeForAutofill || (!autofill_on_empty_values && value.isEmpty()) || (requires_caret_at_end && (element.selectionStart() != element.selectionEnd() || element.selectionEnd() != static_cast<int>(value.length()))))) { // Any popup currently showing is obsolete. HideAutofillUI(); return; } element_ = element; if (password_autofill_agent_->ShowSuggestions(element)) return; // If autocomplete is disabled at the field level, ensure that the native // UI won't try to show a warning, since that may conflict with a custom // popup. Note that we cannot use the WebKit method element.autoComplete() // as it does not allow us to distinguish the case where autocomplete is // disabled for *both* the element and for the form. const base::string16 autocomplete_attribute = element.getAttribute("autocomplete"); if (LowerCaseEqualsASCII(autocomplete_attribute, "off")) display_warning_if_disabled = false; QueryAutofillSuggestions(element, display_warning_if_disabled, datalist_only); } void AutofillAgent::QueryAutofillSuggestions(const WebInputElement& element, bool display_warning_if_disabled, bool datalist_only) { if (!element.document().frame()) return; static int query_counter = 0; autofill_query_id_ = query_counter++; display_warning_if_disabled_ = display_warning_if_disabled; // If autocomplete is disabled at the form level, we want to see if there // would have been any suggestions were it enabled, so that we can show a // warning. Otherwise, we want to ignore fields that disable autocomplete, so // that the suggestions list does not include suggestions for these form // fields -- see comment 1 on http://crbug.com/69914 const RequirementsMask requirements = element.autoComplete() ? REQUIRE_AUTOCOMPLETE : REQUIRE_NONE; FormData form; FormFieldData field; if (!FindFormAndFieldForInputElement(element, &form, &field, requirements)) { // If we didn't find the cached form, at least let autocomplete have a shot // at providing suggestions. WebFormControlElementToFormField(element, EXTRACT_VALUE, &field); } if (datalist_only) field.should_autocomplete = false; gfx::RectF bounding_box_scaled = GetScaledBoundingBox(web_view_->pageScaleFactor(), &element_); // Find the datalist values and send them to the browser process. std::vector<base::string16> data_list_values; std::vector<base::string16> data_list_labels; GetDataListSuggestions(element_, datalist_only, &data_list_values, &data_list_labels); TrimStringVectorForIPC(&data_list_values); TrimStringVectorForIPC(&data_list_labels); Send(new AutofillHostMsg_SetDataList(routing_id(), data_list_values, data_list_labels)); Send(new AutofillHostMsg_QueryFormFieldAutofill(routing_id(), autofill_query_id_, form, field, bounding_box_scaled, display_warning_if_disabled)); } void AutofillAgent::FillAutofillFormData(const WebNode& node, int unique_id, AutofillAction action) { DCHECK_GT(unique_id, 0); static int query_counter = 0; autofill_query_id_ = query_counter++; FormData form; FormFieldData field; if (!FindFormAndFieldForInputElement(node.toConst<WebInputElement>(), &form, &field, REQUIRE_AUTOCOMPLETE)) { return; } autofill_action_ = action; Send(new AutofillHostMsg_FillAutofillFormData( routing_id(), autofill_query_id_, form, field, unique_id)); } void AutofillAgent::SetNodeText(const base::string16& value, blink::WebInputElement* node) { did_set_node_text_ = true; base::string16 substring = value; substring = substring.substr(0, node->maxLength()); node->setEditingValue(substring); } void AutofillAgent::HideAutofillUI() { Send(new AutofillHostMsg_HideAutofillUI(routing_id())); } // TODO(isherman): Decide if we want to support non-password autofill with AJAX. void AutofillAgent::didAssociateFormControls( const blink::WebVector<blink::WebNode>& nodes) { for (size_t i = 0; i < nodes.size(); ++i) { blink::WebFrame* frame = nodes[i].document().frame(); // Only monitors dynamic forms created in the top frame. Dynamic forms // inserted in iframes are not captured yet. if (!frame->parent()) { password_autofill_agent_->OnDynamicFormsSeen(frame); return; } } } } // namespace autofill