OverscrollController consumes scroll updates only during gesture-nav.

content/browser/web_contents/web_contents_view_aura_browsertest.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/web_contents/web_contents_view_aura.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/frame_host/navigation_entry_screenshot_manager.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
+#include "content/common/input/synthetic_web_input_event_builders.h"
+#include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event_processor.h"
+#include "ui/events/event_switches.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 
+namespace {
+
+void GiveItSomeTime() {
+  base::RunLoop run_loop;
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      run_loop.QuitClosure(),
+      base::TimeDelta::FromMillisecondsD(0.001));
+  run_loop.Run();
+}
+
+}  //namespace
+
+
 namespace content {
 
 // This class keeps track of the RenderViewHost whose screenshot was captured.
 class ScreenshotTracker : public NavigationEntryScreenshotManager {
  public:
   explicit ScreenshotTracker(NavigationControllerImpl* controller)
       : NavigationEntryScreenshotManager(controller),
         screenshot_taken_for_(NULL),
         waiting_for_screenshots_(0) {
   }
@@ skipping 72 matching lines @@
     if (should_quit_loop_)
       base::MessageLoop::current()->Quit();
   }
 
   bool navigated_;
   bool should_quit_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationWatcher);
 };
 
+class InputEventMessageFilterWaitsForAcks : public BrowserMessageFilter {
+ public:
+  InputEventMessageFilterWaitsForAcks()
+      : BrowserMessageFilter(InputMsgStart),
+        type_(blink::WebInputEvent::Undefined),
+        state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {}
+
+  void WaitForAck(blink::WebInputEvent::Type type) {
+    base::RunLoop run_loop;
+    base::AutoReset<base::Closure> reset_quit(&quit_, run_loop.QuitClosure());
+    base::AutoReset<blink::WebInputEvent::Type> reset_type(&type_, type);
+    run_loop.Run();
+  }
+
+  InputEventAckState last_ack_state() const { return state_; }
+
+ protected:
+  virtual ~InputEventMessageFilterWaitsForAcks() {}
+
+ private:
+  void ReceivedEventAck(blink::WebInputEvent::Type type,
+                        InputEventAckState state) {
+    if (type_ == type) {
+      state_ = state;
+      quit_.Run();
+    }
+  }
+
+  // BrowserMessageFilter:
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) {
+      InputHostMsg_HandleInputEvent_ACK::Param params;
+      InputHostMsg_HandleInputEvent_ACK::Read(&message, &params);
+      blink::WebInputEvent::Type type = params.a.type;
+      InputEventAckState ack = params.a.state;
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+          base::Bind(&InputEventMessageFilterWaitsForAcks::ReceivedEventAck,
+                     this, type, ack));
+    }
+    return false;
+  }
+
+  base::Closure quit_;
+  blink::WebInputEvent::Type type_;
+  InputEventAckState state_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputEventMessageFilterWaitsForAcks);
+};
+
 class WebContentsViewAuraTest : public ContentBrowserTest {
  public:
   WebContentsViewAuraTest()
       : screenshot_manager_(NULL) {
   }
 
   // Executes the javascript synchronously and makes sure the returned value is
   // freed properly.
   void ExecuteSyncJSFunction(RenderFrameHost* rfh, const std::string& jscript) {
     scoped_ptr<base::Value> value =
         content::ExecuteScriptAndGetValue(rfh, jscript);
   }
 
   // Starts the test server and navigates to the given url. Sets a large enough
   // size to the root window.  Returns after the navigation to the url is
   // complete.
   void StartTestWithPage(const std::string& url) {
     ASSERT_TRUE(test_server()->Start());
     GURL test_url(test_server()->GetURL(url));
     NavigateToURL(shell(), test_url);
 
     WebContentsImpl* web_contents =
         static_cast<WebContentsImpl*>(shell()->web_contents());
     NavigationControllerImpl* controller = &web_contents->GetController();
 
     screenshot_manager_ = new ScreenshotTracker(controller);
     controller->SetScreenshotManager(screenshot_manager_);
   }
 
+  virtual void SetUpCommandLine(CommandLine* cmd) OVERRIDE {
+    cmd->AppendSwitchASCII(switches::kTouchEvents,
+                           switches::kTouchEventsEnabled);
+  }
+
   void TestOverscrollNavigation(bool touch_handler) {
     ASSERT_NO_FATAL_FAILURE(
         StartTestWithPage("files/overscroll_navigation.html"));
     WebContentsImpl* web_contents =
         static_cast<WebContentsImpl*>(shell()->web_contents());
     NavigationController& controller = web_contents->GetController();
     RenderFrameHost* main_frame = web_contents->GetMainFrame();
 
     EXPECT_FALSE(controller.CanGoBack());
     EXPECT_FALSE(controller.CanGoForward());
@@ skipping 80 matching lines @@
         static_cast<WebContentsImpl*>(shell()->web_contents());
     RenderFrameHost* main_frame = web_contents->GetMainFrame();
     int index = -1;
     scoped_ptr<base::Value> value;
     value = content::ExecuteScriptAndGetValue(main_frame, "get_current()");
     if (!value->GetAsInteger(&index))
       index = -1;
     return index;
   }
 
+  int ExecuteScriptAndExtractInt(const std::string& script) {
+    int value = 0;
+    EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
+        shell()->web_contents(),
+        "domAutomationController.send(" + script + ")",
+        &value));
+    return value;
+  }
+
+  RenderViewHost* GetRenderViewHost() const {
+    RenderViewHost* const rvh = shell()->web_contents()->GetRenderViewHost();
+    CHECK(rvh);
+    return rvh;
+  }
+
+  RenderWidgetHostImpl* GetRenderWidgetHost() const {
+    RenderWidgetHostImpl* const rwh =
+        RenderWidgetHostImpl::From(shell()
+                                       ->web_contents()
+                                       ->GetRenderWidgetHostView()
+                                       ->GetRenderWidgetHost());
+    CHECK(rwh);
+    return rwh;
+  }
+
+  RenderWidgetHostViewBase* GetRenderWidgetHostView() const {
+    return static_cast<RenderWidgetHostViewBase*>(
+        GetRenderViewHost()->GetView());
+  }
+
+  InputEventMessageFilterWaitsForAcks* filter() {
+    return filter_.get();
+  }
+
+  void WaitAFrame() {
+    uint32 frame = GetRenderWidgetHostView()->RendererFrameNumber();
+    while (!GetRenderWidgetHost()->ScheduleComposite())
+      GiveItSomeTime();
+    while (GetRenderWidgetHostView()->RendererFrameNumber() == frame)
+      GiveItSomeTime();
+  }
+
  protected:
   ScreenshotTracker* screenshot_manager() { return screenshot_manager_; }
   void set_min_screenshot_interval(int interval_ms) {
     screenshot_manager_->SetScreenshotInterval(interval_ms);
   }
 
+  void AddInputEventMessageFilter() {
+    filter_ = new InputEventMessageFilterWaitsForAcks();
+    GetRenderWidgetHost()->GetProcess()->AddFilter(filter_);
+  }
+
  private:
   ScreenshotTracker* screenshot_manager_;
+  scoped_refptr<InputEventMessageFilterWaitsForAcks> filter_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsViewAuraTest);
 };
 
 // Flaky on Windows: http://crbug.com/305722
 #if defined(OS_WIN)
 #define MAYBE_OverscrollNavigation DISABLED_OverscrollNavigation
 #else
 #define MAYBE_OverscrollNavigation OverscrollNavigation
 #endif
@@ skipping 463 matching lines @@
 
   RenderWidgetHostViewAura* rwhva =
       static_cast<RenderWidgetHostViewAura*>(
           shell()->web_contents()->GetRenderWidgetHostView());
   rwhva->ResetHasSnappedToBoundary();
   EXPECT_FALSE(rwhva->has_snapped_to_boundary());
   window->AddChild(shell()->web_contents()->GetNativeView());
   EXPECT_TRUE(rwhva->has_snapped_to_boundary());
 }
 
+// Tests that touch moves are not throttled when performing a scroll gesture on
+// a non-scrollable area, except during gesture-nav.
+IN_PROC_BROWSER_TEST_F(WebContentsViewAuraTest,
+                       OverscrollNavigationTouchThrottling) {
+  ASSERT_NO_FATAL_FAILURE(
+      StartTestWithPage("files/overscroll_navigation.html"));
+
+  AddInputEventMessageFilter();
+
+  WebContentsImpl* web_contents =
+      static_cast<WebContentsImpl*>(shell()->web_contents());
+  aura::Window* content = web_contents->GetContentNativeView();
+  gfx::Rect bounds = content->GetBoundsInRootWindow();
+  const int dx = 20;
+
+  ExecuteSyncJSFunction(web_contents->GetMainFrame(),
+                        "install_touchmove_handler()");
+
+  WaitAFrame();
+
+  for (int navigated = 0; navigated <= 1; ++navigated) {
+    if (navigated) {
+      ExecuteSyncJSFunction(web_contents->GetMainFrame(), "navigate_next()");
+      ExecuteSyncJSFunction(web_contents->GetMainFrame(),
+                            "reset_touchmove_count()");
+    }
+    // Send touch press.
+    SyntheticWebTouchEvent touch;
+    touch.PressPoint(bounds.x() + 2, bounds.y() + 10);
+    GetRenderWidgetHost()->ForwardTouchEventWithLatencyInfo(touch,
+                                                            ui::LatencyInfo());
+    filter()->WaitForAck(blink::WebInputEvent::TouchStart);
+    // Assert on the ack, because we'll end up waiting for acks that will never
+    // come if this is not true.
+    ASSERT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, filter()->last_ack_state());
+
+    // Send first touch move, and then a scroll begin.
+    touch.MovePoint(0, bounds.x() + 20 + 1 * dx, bounds.y() + 100);
+    GetRenderWidgetHost()->ForwardTouchEventWithLatencyInfo(touch,
+                                                            ui::LatencyInfo());
+    filter()->WaitForAck(blink::WebInputEvent::TouchMove);
+    ASSERT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, filter()->last_ack_state());
+
+    blink::WebGestureEvent scroll_begin =
+        SyntheticWebGestureEventBuilder::BuildScrollBegin(1, 1);
+    GetRenderWidgetHost()->ForwardGestureEventWithLatencyInfo(
+        scroll_begin, ui::LatencyInfo());
+    // Scroll begin ignores ack disposition, so don't wait for the ack.
+    //    GiveItSomeTime();
+    WaitAFrame();
+
+    // First touchmove already sent, start at 2.
+    for (int i = 2; i <= 10; ++i) {
+      // Send a touch move, followed by a scroll update
+      touch.MovePoint(0, bounds.x() + 20 + i * dx, bounds.y() + 100);
+      GetRenderWidgetHost()->ForwardTouchEventWithLatencyInfo(
+          touch, ui::LatencyInfo());
+      WaitAFrame();
+
+      blink::WebGestureEvent scroll_update =
+          SyntheticWebGestureEventBuilder::BuildScrollUpdate(dx, 5, 0);
+
+      GetRenderWidgetHost()->ForwardGestureEventWithLatencyInfo(
+          scroll_update, ui::LatencyInfo());
+
+      WaitAFrame();
+    }
+
+    touch.ReleasePoint(0);
+    GetRenderWidgetHost()->ForwardTouchEventWithLatencyInfo(touch,
+                                                            ui::LatencyInfo());
+    WaitAFrame();
+
+    blink::WebGestureEvent scroll_end;
+    scroll_end.type = blink::WebInputEvent::GestureScrollEnd;
+    GetRenderWidgetHost()->ForwardGestureEventWithLatencyInfo(
+        scroll_end, ui::LatencyInfo());
+    WaitAFrame();
+
+    if (!navigated)
+      EXPECT_EQ(10, ExecuteScriptAndExtractInt("touchmoveCount"));
+    else
+      EXPECT_GT(10, ExecuteScriptAndExtractInt("touchmoveCount"));
+  }
+}
+
 }  // namespace content