[Android] Show autofill popup after animation.

content/renderer/render_view_impl.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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 1485 matching lines @@
 }
 
 void RenderViewImpl::OnScrollFocusedEditableNodeIntoRect(
     const gfx::Rect& rect) {
   if (has_scrolled_focused_editable_node_into_rect_ &&
       rect == rect_for_scrolled_focused_editable_node_) {
     return;
   }
 
   blink::WebElement element = GetFocusedElement();
+  bool will_animate = false;
   if (!element.isNull() && IsEditableNode(element)) {
     rect_for_scrolled_focused_editable_node_ = rect;
     has_scrolled_focused_editable_node_into_rect_ = true;
-    webview()->scrollFocusedNodeIntoRect(rect);
+    will_animate = webview()->scrollFocusedNodeIntoRect(rect);
   }
+
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_,

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

It's brittle to tie the autofill showing up at all to an optional
scroll-into-view action that might be suppressed before we ever get here.  And
it also leads you to adding "#if !defined(OS_ANDROID)" in
AutofillAgent::FocusedNodeChanged, which is something we prefer to avoid.

Please make autofill observer notified based on a mandatory event that happens
on every form field focus instead (might need to introduce something like
ViewMsg_FocusChangeComplete for that).  And store will_animate_ in a member
variable that defaults to false in this method.

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

FocusChangeComplete event is a good idea. On Android this can be invoked either
from here or from DidCompletePageScaleAnimation. I am working on figuring out
where to issue this event on desktop platforms. Let me know if you have
suggestions.

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

To be clear, what I'm suggesting is that we should have the sequence with
guaranteed ordering:
1. Focus
2. ScrollIntoView (optional)
3. FocusComplete
4. DidCompletePageScaleAnimation (optional)

The first three events are very close to each other in time.  On ScrollIntoView,
we would set a flag if a page scale animation was issued, and on FocusComplete,
we would either show autofill immediately if that flag is false, or wait until
DidCompletePageScaleAnimation if true.  This means we wouldn't need any
platform-specific logic aside from not triggering the page scale animation.

I don't know the focus code well enough to offer a very specific suggestion of
how it should be added, although I think it would probably be in the browser
process, who sends messages to trigger the first two -- we could send another
message right after that.

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

The step #2 (FocusComplete) is not necessary, because there's already an event
that happens at the very end: OnHandledGestureEvent/OnHandledClickEvent/etc.
Also, we don't have all of the required information on whether
DidCompletePageScaleAnimation will happen at the end of the focus event in
renderer, because browser makes some decisions as well. The solution is for the
browser to let the renderer know whether it will initiate the page scale
animation or not. See
https://docs.google.com/document/d/1-5bhgEYhjHeJaPBYZZTLA0goc13epj1r_7bU-zFRP...
for a diagram.

+                    WillAnimatePageScale(will_animate));
 }
 
 void RenderViewImpl::OnSetEditCommandsForNextKeyEvent(
     const EditCommands& edit_commands) {
   edit_commands_ = edit_commands;
 }
 
 void RenderViewImpl::OnSetHistoryLengthAndPrune(int history_length,
                                                 int32 minimum_page_id) {
   DCHECK_GE(history_length, 0);
@@ skipping 2320 matching lines @@
 }
 
 void RenderViewImpl::InstrumentWillComposite() {
   if (!webview())
     return;
   if (!webview()->devToolsAgent())
     return;
   webview()->devToolsAgent()->willComposite();
 }
 
+void RenderViewImpl::DidCompletePageScaleAnimation() {
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_,
+                    DidCompletePageScaleAnimation());
+}
+
 void RenderViewImpl::SetScreenMetricsEmulationParameters(
     float device_scale_factor,
     const gfx::Point& root_layer_offset,
     float root_layer_scale) {
   if (webview() && compositor()) {
     webview()->setCompositorDeviceScaleFactorOverride(device_scale_factor);
     webview()->setRootLayerTransform(
         blink::WebSize(root_layer_offset.x(), root_layer_offset.y()),
         root_layer_scale);
   }
@@ skipping 365 matching lines @@
     std::vector<gfx::Size> sizes;
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content