[Android] Disable the touch ack timeout on mobile sites

content/browser/renderer_host/render_widget_host_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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 83 matching lines @@
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
 const int kPaintMsgTimeoutMS = 50;
 
 typedef std::pair<int32, int32> RenderWidgetHostID;
 typedef base::hash_map<RenderWidgetHostID, RenderWidgetHostImpl*>
     RoutingIDWidgetMap;
 base::LazyInstance<RoutingIDWidgetMap> g_routing_id_widget_map =
     LAZY_INSTANCE_INITIALIZER;
 
+int GetInputRouterViewFlagsFromCompositorFrameMetadata(
+    const cc::CompositorFrameMetadata metadata) {
+  int view_flags = InputRouter::VIEW_FLAGS_NONE;
+
+  if (metadata.min_page_scale_factor == metadata.max_page_scale_factor)
+    view_flags |= InputRouter::FIXED_PAGE_SCALE;
+
+  const float window_width_dip =
+      std::ceil(metadata.page_scale_factor * metadata.viewport_size.width());

[johnme, 2014/01/15 02:15:09]

Can you confirm that metadata.viewport_size.width gives the window width in CSS
pixels (as opposed to the screen width, layout viewport width, or content
width)? For example if you load a width=device-width page in a 200DIP wide
Chrome-powered Android WebView, this should initially report 200 pixels, but if
you then pinch zoom in by 2x it should report 100 pixels, and hence after
multiplying by the page_scale_factor this should evaluate to 200 pixels at both
zoom levels.

[jdduke (slow), 2014/01/15 03:06:49]

I'll double check (under basic testing the |window_width_dip| was invariant
under pinch zoom).  I should note that these are the same values that propagate
to RenderCoordinates via ContentViewCore, so this math should be equivalent to
that in |RenderCoordinates.hasMobileViewport|.

[jdduke (slow), 2014/01/15 21:28:50]

Confirmed.

+  const float content_width_css = metadata.root_layer_size.width();

[johnme, 2014/01/15 02:15:09]

Can you confirm that metadata.root_layer_size.width is the content width (i.e.
it determines how far the page can be scrolled) rather than the layout viewport
width (set by meta viewport, and which determines the width of the initial
containing block, hence the content width of a flexible width page), and that it
is in CSS pixels not DIPs? For example if you load a width=device-width page
that contains a <div style="width:2000px; height:5px">, this should report 2000
pixels, irrespective of zoom level.

[jdduke (slow), 2014/01/15 03:06:49]

Again, I'll double check. The only difference between this (content width) value
and that used in RenderCoordinates is that the latter is max'ed with
|mViewportWidthPix| (converted to DIP) from ContentViewCore.  Would that have a
meaningful effect on the result?  I guess I could max with
|RWHVA::GetViewBounds()| so we're consistent.

[jdduke (slow), 2014/01/15 21:28:50]

Confirmed.

+  if (content_width_css <= window_width_dip)
+    view_flags |= InputRouter::MOBILE_VIEWPORT;
+
+  return view_flags;
+}
+
 // Implements the RenderWidgetHostIterator interface. It keeps a list of
 // RenderWidgetHosts, and makes sure it returns a live RenderWidgetHost at each
 // iteration (or NULL if there isn't any left).
 class RenderWidgetHostIteratorImpl : public RenderWidgetHostIterator {
  public:
   RenderWidgetHostIteratorImpl()
       : current_index_(0) {
   }
 
   virtual ~RenderWidgetHostIteratorImpl() {
@@ skipping 1378 matching lines @@
 
 bool RenderWidgetHostImpl::OnSwapCompositorFrame(
     const IPC::Message& message) {
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   uint32 output_surface_id = param.a;
   param.b.AssignTo(frame.get());
 
-  bool fixed_page_scale =
-      frame->metadata.min_page_scale_factor ==
-          frame->metadata.max_page_scale_factor;
-  int updated_view_flags = fixed_page_scale ? InputRouter::FIXED_PAGE_SCALE
-                                            : InputRouter::VIEW_FLAGS_NONE;
-  input_router_->OnViewUpdated(updated_view_flags);
+  input_router_->OnViewUpdated(
+      GetInputRouterViewFlagsFromCompositorFrameMetadata(frame->metadata));
 
   if (view_) {
     view_->OnSwapCompositorFrame(output_surface_id, frame.Pass());
     view_->DidReceiveRendererFrame();
   } else {
     cc::CompositorFrameAck ack;
     if (frame->gl_frame_data) {
       ack.gl_frame_data = frame->gl_frame_data.Pass();
       ack.gl_frame_data->sync_point = 0;
     } else if (frame->delegated_frame_data) {
@@ skipping 950 matching lines @@
         continue;
       }
       RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
       if (rwhi_set.insert(rwhi).second)
         rwhi->FrameSwapped(latency_info);
     }
   }
 }
 
 }  // namespace content