[Android] Show autofill popup after animation.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 116 matching lines @@
       password_generation_agent_(password_generation_agent),
       autofill_query_id_(0),
       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),
       ignore_text_changes_(false),
       is_popup_possibly_visible_(false),
       main_frame_processed_(false),
+      clicked_form_control_element_was_focused_(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() {}
 
@@ skipping 63 matching lines @@
                                    EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
                                &form_data,
                                NULL)) {
     Send(new AutofillHostMsg_FormSubmitted(routing_id(), form_data,
                                            base::TimeTicks::Now()));
   }
 }
 
 void AutofillAgent::FocusedNodeChanged(const WebNode& node) {
   HidePopup();
+  changed_focused_node_ = node;
 
-  if (password_generation_agent_ &&
-      password_generation_agent_->FocusedNodeHasChanged(node)) {
-    is_popup_possibly_visible_ = true;
-    return;
-  }
+#if !defined(OS_ANDROID)
+  OnAnimationCompleted();
+#endif
+}
 
-  if (node.isNull() || !node.isElementNode())
-    return;
-
-  WebElement web_element = node.toConst<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::WillAnimatePageScale(bool will_animate) {
+  if (!will_animate)
+    OnAnimationCompleted();
 }
 
 void AutofillAgent::OrientationChangeEvent() {
   HidePopup();
 }
 
 void AutofillAgent::Resized() {
+#if !defined(OS_ANDROID)

[aelias_OOO_until_Jul13, 2014/11/22 03:38:11]

Why?  Shouldn't we hide on resize on Android, if we hide on scroll?  I assume
this is fixing a problem you've observed; please explain and maybe we can come
up with a cleaner fix.

[please use gerrit instead, 2014/11/24 20:22:31]

This is to fix the autofill popup momentarily showing and then hiding when
switching between input fields.

When you switch between input fields, the popup shows up immediately, because
there is no animation. However, the software keyboard then resizes itself to
show/hide personalized suggestions [1]. These personalized suggestions show up
for the username field, but not for the password field, for example. The
keyboard resize causes the render to resize as well. The resize of the renderer
then causes the autofill popup to hide itself immediately after it showed up.

[1] http://www.pcmag.com/article2/0,2817,2455227,00.asp

[aelias_OOO_until_Jul13, 2014/11/25 01:26:34]

OK, then should we not hide on resize on all platforms, if it's safe to do so?

[please use gerrit instead, 2014/12/15 18:39:55]

I solved the issue slightly differently that does not require ignoring resize.
Switching between input fields now waits for resize or a timeout before showing
the popup.

[aelias_OOO_until_Jul13, 2014/12/15 21:59:14]

Hmm, I don't like the new timeout stuff in ContentViewCore either, sorry.

Going back to first principles on this, I think the underlying reason to hide on
resize is that if the page contents size changes due to the resize (particularly
due to horizontal resizes on desktop), then the form field is likely to move
around.  Whereas with Android keyboard that's rarely an issue because the resize
is purely vertical.  But, even for vertical resizes, there are corner cases like
fixed-position where the form field does move around.

So, I'd suggest that when a resize and its corresponding layout happens, check
to see if the form field node has moved or changed size, and only if so then
hide the autofill popup.

[please use gerrit instead, 2014/12/16 02:17:08]

I like the first-principles approach and have cooked up something promising
here. (Will be sharing later.) There is one interesting affect of not having the
timeout when switching between fields: Some webpages run javascript which
changes input element position on focus change. This is such a cornercase that
I'm not worried about it, though. This can be resolved when a "real" fix for
comes along. (I assume the real fix will the in-compositor implementation of
autofill popups, but that's way down the road.)

[aelias_OOO_until_Jul13, 2014/12/16 02:35:52]

Assuming that Javascript usually will do that change synchronously, maybe the
immediate answer to that one is to wait until the event processing completes
before showing autofill.

   HidePopup();
+#endif
 }
 
 void AutofillAgent::DidChangeScrollOffset(WebLocalFrame*) {
   HidePopup();
 }
 
+void AutofillAgent::DidCompletePageScaleAnimation() {
+  OnAnimationCompleted();
+}
+
 void AutofillAgent::didRequestAutocomplete(
     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(form.document().url());
   content::SSLStatus ssl_status =
       render_view()->GetSSLStatusOfFrame(form.document().frame());
   bool is_safe = url.SchemeIs(url::kHttpsScheme) &&
@@ skipping 43 matching lines @@
   ignore_text_changes_ = ignore;
 }
 
 void AutofillAgent::FormControlElementClicked(
     const WebFormControlElement& element,
     bool was_focused) {
   const WebInputElement* input_element = toWebInputElement(&element);
   if (!input_element && !IsTextAreaElement(element))
     return;
 
-  bool show_full_suggestion_list = element.isAutofilled() || was_focused;
-  bool show_password_suggestions_only = !was_focused;
+  clicked_form_control_element_ = element;
+  clicked_form_control_element_was_focused_ = was_focused;
 
-  // TODO(gcasto): Remove after crbug.com/430318 has been fixed.
-  bool show_suggestions = true;
-#if defined(OS_ANDROID)
-  show_suggestions = was_focused;
+#if !defined(OS_ANDROID)
+  OnAnimationCompleted();
 #endif
-
-  if (show_suggestions) {
-    ShowSuggestions(element,
-                    true,
-                    false,
-                    true,
-                    false,
-                    show_full_suggestion_list,
-                    show_password_suggestions_only);
-  }
 }
 
 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 WebFormControlElement& element) {
   if (ignore_text_changes_)
@@ skipping 124 matching lines @@
 
 void AutofillAgent::OnPreviewForm(int query_id, const FormData& form) {
   if (!render_view()->GetWebView() || query_id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
   PreviewForm(form, element_);
   Send(new AutofillHostMsg_DidPreviewAutofillFormData(routing_id()));
 }
 
+void AutofillAgent::OnAnimationCompleted() {
+  if (!clicked_form_control_element_.isNull()) {
+    OnAnimationCompletedAfterFormControlElementClicked(
+        clicked_form_control_element_,
+        clicked_form_control_element_was_focused_);
+    clicked_form_control_element_.reset();
+  }
+
+  if (!changed_focused_node_.isNull()) {
+    OnAnimationCompletedAfterFocusedNodeChanged(changed_focused_node_);
+    changed_focused_node_.reset();
+  }
+}
+
+void AutofillAgent::OnAnimationCompletedAfterFormControlElementClicked(
+    const blink::WebFormControlElement& element,
+    bool was_focused) {
+  bool show_full_suggestion_list = element.isAutofilled() || was_focused;
+  bool show_password_suggestions_only = !was_focused;
+  ShowSuggestions(element,
+                  true,
+                  false,
+                  true,
+                  false,
+                  show_full_suggestion_list,
+                  show_password_suggestions_only);
+}
+
+void AutofillAgent::OnAnimationCompletedAfterFocusedNodeChanged(
+    const blink::WebNode& node) {
+  if (password_generation_agent_ &&
+      password_generation_agent_->FocusedNodeHasChanged(node)) {
+    is_popup_possibly_visible_ = true;
+    return;
+  }
+
+  if (!node.isElementNode())
+    return;
+
+  WebElement web_element = changed_focused_node_.toConst<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::OnClearForm() {
   form_cache_.ClearFormWithElement(element_);
 }
 
 void AutofillAgent::OnClearPreviewedForm() {
   if (!element_.isNull()) {
     if (password_autofill_agent_->DidClearAutofillSelection(element_))
       return;
 
     ClearPreviewedFormWithElement(element_, was_query_node_autofilled_);
@@ skipping 254 matching lines @@
       ProcessForms(*frame);
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       if (password_generation_agent_)
         password_generation_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill