[CRD iOS] Injecting scroll events w/ fling animation

remoting/client/ui/gesture_interpreter.cc

 // Copyright 2017 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 "remoting/client/ui/gesture_interpreter.h"
 
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "remoting/client/chromoting_session.h"
 #include "remoting/client/ui/direct_input_strategy.h"
 #include "remoting/client/ui/renderer_proxy.h"
 
 namespace {
 
 const float kOneFingerFlingTimeConstant = 325.f;
+const float kScrollFlingTimeConstant = 120.f;
 
 }  // namespace
 
 namespace remoting {
 GestureInterpreter::GestureInterpreter(RendererProxy* renderer,
                                        ChromotingSession* input_stub)
     : renderer_(renderer),
       input_stub_(input_stub),
       pan_animation_(kOneFingerFlingTimeConstant,
                      base::Bind(&GestureInterpreter::PanWithoutAbortAnimations,
-                                base::Unretained(this))) {
+                                base::Unretained(this))),
+      scroll_animation_(
+          kScrollFlingTimeConstant,
+          base::Bind(&GestureInterpreter::ScrollWithoutAbortAnimations,
+                     base::Unretained(this))) {
   viewport_.RegisterOnTransformationChangedCallback(
       base::Bind(&RendererProxy::SetTransformation,
                  base::Unretained(renderer_)),
       true);
 
   // TODO(yuweih): This should be configurable.
   input_strategy_.reset(new DirectInputStrategy());
   renderer_->SetCursorVisibility(input_strategy_->IsCursorVisible());
   SetCursorPositionOnRenderer();
 }
@@ skipping 43 matching lines @@
                               protocol::MouseEvent_MouseButton_BUTTON_LEFT,
                               is_dragging_mode_);
 }
 
 void GestureInterpreter::OneFingerFling(float velocity_x, float velocity_y) {
   AbortAnimations();
   pan_animation_.SetVelocity(velocity_x, velocity_y);
   pan_animation_.Tick();
 }
 
+void GestureInterpreter::Scroll(float x, float y, float dx, float dy) {
+  AbortAnimations();
+
+  ViewMatrix::Point cursor_position = TrackAndGetPosition(x, y);
+
+  // Inject the cursor position to the host so that scrolling can happen on the
+  // right place.
+  input_stub_->SendMouseEvent(cursor_position.x, cursor_position.y,
+                              protocol::MouseEvent_MouseButton_BUTTON_UNDEFINED,
+                              false);
+
+  ScrollWithoutAbortAnimations(dx, dy);
+}
+
+void GestureInterpreter::ScrollFling(float velocity_x, float velocity_y) {
+  AbortAnimations();
+
+  scroll_animation_.SetVelocity(velocity_x, velocity_y);
+  scroll_animation_.Tick();
+}
+
 void GestureInterpreter::ProcessAnimations() {
   if (pan_animation_.IsAnimationInProgress()) {
     pan_animation_.Tick();
   }
+  if (scroll_animation_.IsAnimationInProgress()) {

[nicholss, 2017/05/16 18:13:10]

Does it hurt to call Tick without checking IsAnimationInProgress externally and
instead check internally to the class? What is the side effect of calling tick
with no animation happening?

[Yuwei, 2017/05/17 05:42:20]

Done.

TBH nope. Just the negligible overhead of opening new stack frame O_o

+    scroll_animation_.Tick();
+  }
 }
 
 void GestureInterpreter::OnSurfaceSizeChanged(int width, int height) {
   viewport_.SetSurfaceSize(width, height);
 }
 
 void GestureInterpreter::OnDesktopSizeChanged(int width, int height) {
   viewport_.SetDesktopSize(width, height);
 }
 
 void GestureInterpreter::PanWithoutAbortAnimations(float translation_x,
                                                    float translation_y) {
   input_strategy_->HandlePan({translation_x, translation_y}, is_dragging_mode_,
                              &viewport_);
   SetCursorPositionOnRenderer();
 }
 
+void GestureInterpreter::ScrollWithoutAbortAnimations(float dx, float dy) {
+  ViewMatrix::Point desktopDelta =
+      input_strategy_->MapScrollVector({dx, dy}, viewport_);
+  input_stub_->SendMouseWheelEvent(desktopDelta.x, desktopDelta.y);
+}
+
 void GestureInterpreter::AbortAnimations() {
   pan_animation_.Abort();
 }
 
 void GestureInterpreter::InjectMouseClick(
     float x,
     float y,
     protocol::MouseEvent_MouseButton button) {
   input_stub_->SendMouseEvent(x, y, button, true);
   input_stub_->SendMouseEvent(x, y, button, false);
@@ skipping 22 matching lines @@
   if (feedback_radius > 0) {
     // TODO(yuweih): The renderer takes diameter as parameter. Consider moving
     // the *2 logic inside the renderer.
     float diameter_on_desktop =
         2.f * feedback_radius / viewport_.GetTransformation().GetScale();
     renderer_->StartInputFeedback(cursor_x, cursor_y, diameter_on_desktop);
   }
 }
 
 }  // namespace remoting