Reland: Implement Aura side of unified touch text selection for contents

content/browser/renderer_host/render_widget_host_view_aura.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_view_aura.h"
 
 #include <set>
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
@@ skipping 12 matching lines @@
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/compositor_resize_lock_aura.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_aura.h"
+#include "content/browser/renderer_host/input/touch_selection_controller_client_aura.h"
+#include "content/browser/renderer_host/input/ui_touch_selection_helper.h"
 #include "content/browser/renderer_host/input/web_input_event_util.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 21 matching lines @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/touch_selection/touch_selection_controller.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/scoped_tooltip_disabler.h"
 #include "ui/wm/public/tooltip_client.h"
 #include "ui/wm/public/transient_window_client.h"
 #include "ui/wm/public/window_types.h"
 
 #if defined(OS_WIN)
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/legacy_render_widget_host_win.h"
@@ skipping 193 matching lines @@
     int changed_touch_id) {
   if (event->type == blink::WebInputEvent::TouchMove ||
       event->type == blink::WebInputEvent::TouchCancel) {
     for (size_t i = 0; i < event->touchesLength; ++i) {
       if (event->touches[i].id != changed_touch_id)
         event->touches[i].state = blink::WebTouchPoint::StateStationary;
     }
   }
 }
 
+class ScopedMotionEventAuraCleanup {
+ public:
+  ScopedMotionEventAuraCleanup(ui::MotionEventAura* motion_event,
+                               const ui::TouchEvent& event);
+  virtual ~ScopedMotionEventAuraCleanup();
+
+ private:
+  ui::MotionEventAura* motion_event_;
+  const ui::TouchEvent& event_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedMotionEventAuraCleanup);

[jdduke (slow), 2015/07/08 22:19:43]

This looks good, but let's add it in a separate patch, ideally it would live
in/around MotionEventAura and we'd use it wherever necessary.

[mohsen, 2015/07/08 22:45:14]

Yeah, if that would useful in other places, then we can add it separately as you
suggested. Removed.

+};
+
+ScopedMotionEventAuraCleanup::ScopedMotionEventAuraCleanup(
+    ui::MotionEventAura* mouse_event,

[jdduke (slow), 2015/07/08 22:19:43]

motion_event

[mohsen, 2015/07/08 22:45:14]

Acknowledged.

+    const ui::TouchEvent& event)
+    : motion_event_(mouse_event), event_(event) {
+}
+
+ScopedMotionEventAuraCleanup::~ScopedMotionEventAuraCleanup() {
+  motion_event_->CleanupRemovedTouchPoints(event_);
+}
+
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit
     : public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
     DCHECK(rwhva_);
@@ skipping 151 matching lines @@
       last_swapped_software_frame_scale_factor_(1.f),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       cursor_visibility_state_in_renderer_(UNKNOWN),
 #if defined(OS_WIN)
       legacy_render_widget_host_HWND_(NULL),
       legacy_window_destroyed_(false),
       showing_context_menu_(false),
 #endif
       has_snapped_to_boundary_(false),
-      touch_editing_client_(NULL),
       is_guest_view_hack_(is_guest_view_hack),
       begin_frame_observer_proxy_(this),
       weak_ptr_factory_(this) {
   if (!is_guest_view_hack_)
     host_->SetView(this);
 
   window_observer_.reset(new WindowObserver(this));
 
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   window_->set_layer_owner_delegate(delegated_frame_host_.get());
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
 
   bool overscroll_enabled = base::CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kOverscrollHistoryNavigation) != "0";
   SetOverscrollControllerEnabled(overscroll_enabled);
+
+  selection_controller_client_.reset(
+      new TouchSelectionControllerClientAura(this));
+
+  ui::TouchSelectionController::Config tsc_config;
+  tsc_config.tap_timeout = base::TimeDelta::FromMilliseconds(
+      ui::GestureConfiguration::GetInstance()->show_press_delay_in_ms());
+  tsc_config.tap_slop = ui::GestureConfiguration::GetInstance()
+                            ->max_touch_move_in_pixels_for_click();
+  tsc_config.show_on_tap_for_empty_editable = true;
+  tsc_config.enable_longpress_drag_selection = false;
+  selection_controller_.reset(new ui::TouchSelectionController(
+      selection_controller_client_.get(), tsc_config));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 bool RenderWidgetHostViewAura::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewAura, message)
     // TODO(kevers): Move to RenderWidgetHostViewImpl and consolidate IPC
@@ skipping 465 matching lines @@
   if (text_input_type_ != type ||
       text_input_mode_ != input_mode ||
       can_compose_inline_ != can_compose_inline ||
       text_input_flags_ != flags) {
     text_input_type_ = type;
     text_input_mode_ = input_mode;
     can_compose_inline_ = can_compose_inline;
     text_input_flags_ = flags;
     if (GetInputMethod())
       GetInputMethod()->OnTextInputTypeChanged(this);
-    if (touch_editing_client_)
-      touch_editing_client_->OnTextInputTypeChanged(text_input_type_);
   }
 }
 
 void RenderWidgetHostViewAura::OnTextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
   text_input_flags_ = params.flags;
   if (params.show_ime_if_needed && params.type != ui::TEXT_INPUT_TYPE_NONE) {
     if (GetInputMethod())
       GetInputMethod()->ShowImeIfNeeded();
   }
@@ skipping 96 matching lines @@
     }
   }
 
   if (anchor_bound == selection_anchor_ && focus_bound == selection_focus_)
     return;
 
   selection_anchor_ = anchor_bound;
   selection_focus_ = focus_bound;
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
-
-  if (touch_editing_client_) {
-    touch_editing_client_->OnSelectionOrCursorChanged(
-        anchor_bound, focus_bound);
-  }
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     ReadbackRequestCallback& callback,
     const SkColorType preferred_color_type) {
   delegated_frame_host_->CopyFromCompositingSurface(
       src_subrect, dst_size, callback, preferred_color_type);
 }
@@ skipping 69 matching lines @@
     scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("content", "RenderWidgetHostViewAura::OnSwapCompositorFrame");
 
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
   if (frame->delegated_frame_data) {
     delegated_frame_host_->SwapDelegatedFrame(
         output_surface_id,
         frame->delegated_frame_data.Pass(),
         frame->metadata.device_scale_factor,
         frame->metadata.latency_info);
+    SelectionUpdated(frame->metadata.selection.is_editable,
+                     frame->metadata.selection.is_empty_text_form_control,
+                     ConvertSelectionBound(frame->metadata.selection.start),
+                     ConvertSelectionBound(frame->metadata.selection.end));
     return;
   }
 
   if (frame->software_frame_data) {
     DLOG(ERROR) << "Unable to use software frame in aura";
     bad_message::ReceivedBadMessage(host_->GetProcess(),
                                     bad_message::RWHVA_SHARED_MEMORY);
     return;
   }
 }
 
 void RenderWidgetHostViewAura::DidStopFlinging() {
-  if (touch_editing_client_)
-    touch_editing_client_->DidStopFlinging();
+  selection_controller_client_->OnSelectionScrollCompleted();
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetParentForWindowlessPlugin()
     const {
   if (legacy_render_widget_host_HWND_) {
@@ skipping 59 matching lines @@
     InputEventAckState ack_result) {
   if (overscroll_controller_) {
     overscroll_controller_->ReceivedEventACK(
         event, (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result));
   }
 }
 
 void RenderWidgetHostViewAura::GestureEventAck(
     const blink::WebGestureEvent& event,
     InputEventAckState ack_result) {
-  if (touch_editing_client_)
-    touch_editing_client_->GestureEventAck(event.type);
-
   if (overscroll_controller_) {
     overscroll_controller_->ReceivedEventACK(
         event, (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result));
   }
 }
 
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch,
     InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
@@ skipping 381 matching lines @@
     return gfx::Rect(origin.x(),
                      origin.y(),
                      end.x() - origin.x(),
                      end.y() - origin.y());
   }
 
   return rect;
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetCaretBounds() const {
-  gfx::Rect rect =
-      ui::RectBetweenSelectionBounds(selection_anchor_, selection_focus_);
-  return ConvertRectToScreen(rect);
+  return ConvertRectToScreen(
+      ui::RectBetweenSelectionBounds(selection_anchor_, selection_focus_));
 }
 
 bool RenderWidgetHostViewAura::GetCompositionCharacterBounds(
     uint32 index,
     gfx::Rect* rect) const {
   DCHECK(rect);
   if (index >= composition_character_bounds_.size())
     return false;
   *rect = ConvertRectToScreen(composition_character_bounds_[index]);
   return true;
@@ skipping 166 matching lines @@
     const gfx::Point& location) {
   return true;
 }
 
 bool RenderWidgetHostViewAura::CanFocus() {
   return popup_type_ == blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewAura::OnCaptureLost() {
   host_->LostCapture();
-  if (touch_editing_client_)
-    touch_editing_client_->EndTouchEditing(false);
 }
 
 void RenderWidgetHostViewAura::OnPaint(const ui::PaintContext& context) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAura::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   if (!host_ || !window_->GetRootWindow())
     return;
@@ skipping 62 matching lines @@
 }
 
 void RenderWidgetHostViewAura::GetHitTestMask(gfx::Path* mask) const {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::EventHandler implementation:
 
 void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnKeyEvent");
-  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
-    return;
 
   if (popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab()) {
     popup_child_host_view_->OnKeyEvent(event);
     if (event->handled())
       return;
   }
 
   // We need to handle the Escape key for Pepper Flash.
   if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
     // Focus the window we were created from.
@@ skipping 26 matching lines @@
     // We don't have to communicate with an input method here.
     NativeWebKeyboardEvent webkit_event(*event);
     ForwardKeyboardEvent(webkit_event);
   }
   event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnMouseEvent");
 
-  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
-    return;
-
   if (mouse_locked_) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(window_->GetRootWindow());
     DCHECK(!cursor_client || !cursor_client->IsCursorVisible());
 
     if (event->type() == ui::ET_MOUSEWHEEL) {
       blink::WebMouseWheelEvent mouse_wheel_event =
           MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent&>(*event));
       if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
         host_->ForwardWheelEvent(mouse_wheel_event);
@@ skipping 143 matching lines @@
     event->ConvertLocationToTarget(window_, window_->parent());
     window_->parent()->delegate()->OnMouseEvent(event);
   }
 
   if (!IsXButtonUpEvent(event))
     event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnScrollEvent");
-  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
-    return;
 
   if (event->type() == ui::ET_SCROLL) {
 #if !defined(OS_WIN)
     // TODO(ananta)
     // Investigate if this is true for Windows 8 Metro ASH as well.
     if (event->finger_count() != 2)
       return;
 #endif
     blink::WebGestureEvent gesture_event =
         MakeWebGestureEventFlingCancel();
     host_->ForwardGestureEvent(gesture_event);
     blink::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(*event);
     host_->ForwardWheelEvent(mouse_wheel_event);
     RecordAction(base::UserMetricsAction("TrackpadScroll"));
   } else if (event->type() == ui::ET_SCROLL_FLING_START ||
              event->type() == ui::ET_SCROLL_FLING_CANCEL) {
     blink::WebGestureEvent gesture_event = MakeWebGestureEvent(*event);
     host_->ForwardGestureEvent(gesture_event);
     if (event->type() == ui::ET_SCROLL_FLING_START)
       RecordAction(base::UserMetricsAction("TrackpadScrollFling"));
   }
 
   event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnTouchEvent");
-  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
-    return;
+
+  bool had_no_pointer = !pointer_state_.GetPointerCount();
 
   // Update the touch event first.
   if (!pointer_state_.OnTouch(*event)) {
     event->StopPropagation();
     return;
   }
 
-  blink::WebTouchEvent touch_event = ui::CreateWebTouchEventFromMotionEvent(
-      pointer_state_, event->may_cause_scrolling());
-  pointer_state_.CleanupRemovedTouchPoints(*event);
+  blink::WebTouchEvent touch_event;
+
+  {
+    ScopedMotionEventAuraCleanup motion_event_cleanup(&pointer_state_, *event);
+    if (selection_controller_->WillHandleTouchEvent(pointer_state_)) {
+      event->SetHandled();
+      return;
+    }
+    touch_event = ui::CreateWebTouchEventFromMotionEvent(
+        pointer_state_, event->may_cause_scrolling());
+  }
+
+  if (had_no_pointer)
+    selection_controller_client_->OnTouchDown();
+  if (!pointer_state_.GetPointerCount())
+    selection_controller_client_->OnTouchUp();
 
   // It is important to always mark events as being handled asynchronously when
   // they are forwarded. This ensures that the current event does not get
   // processed by the gesture recognizer before events currently awaiting
   // dispatch in the touch queue.
   event->DisableSynchronousHandling();
 
   // Set unchanged touch point to StateStationary for touchmove and
   // touchcancel to make sure only send one ack per WebTouchEvent.
   MarkUnchangedTouchPointsAsStationary(&touch_event, event->touch_id());
   host_->ForwardTouchEventWithLatencyInfo(touch_event, *event->latency());
 }
 
 void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnGestureEvent");
+
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !pinch_zoom_enabled_) {
     event->SetHandled();
     return;
   }
 
-  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+  HandleGestureForTouchSelection(event);
+  if (event->handled())
     return;
 
   // Confirm existing composition text on TAP gesture, to make sure the input
   // caret won't be moved with an ongoing composition text.
   if (event->type() == ui::ET_GESTURE_TAP)
     FinishImeCompositionSession();
 
   blink::WebGestureEvent gesture = MakeWebGestureEvent(*event);
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
@@ skipping 76 matching lines @@
         host_->GetRootBrowserAccessibilityManager();
     if (manager)
       manager->OnWindowFocused();
   } else if (window_ == lost_focus) {
     host_->SetActive(false);
     host_->Blur();
 
     DetachFromInputMethod();
     host_->SetInputMethodActive(false);
 
-    if (touch_editing_client_)
-      touch_editing_client_->EndTouchEditing(false);
+    selection_controller_->HideAndDisallowShowingAutomatically();
 
     if (overscroll_controller_)
       overscroll_controller_->Cancel();
 
     BrowserAccessibilityManager* manager =
         host_->GetRootBrowserAccessibilityManager();
     if (manager)
       manager->OnWindowBlurred();
 
     // If we lose the focus while fullscreen, close the window; Pepper Flash
@@ skipping 36 matching lines @@
   TRACE_EVENT1("ui", "RenderWidgetHostViewAura::OnHostMoved",
                "new_origin", new_origin.ToString());
 
   UpdateScreenInfo(window_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
-  if (touch_editing_client_)
-    touch_editing_client_->OnViewDestroyed();
-
+  selection_controller_.reset();
+  selection_controller_client_.reset();
   delegated_frame_host_.reset();
   window_observer_.reset();
   if (window_->GetHost())
     window_->GetHost()->RemoveObserver(this);
   UnlockMouse();
   if (popup_parent_host_view_) {
     DCHECK(popup_parent_host_view_->popup_child_host_view_ == NULL ||
            popup_parent_host_view_->popup_child_host_view_ == this);
     popup_parent_host_view_->popup_child_host_view_ = NULL;
   }
@@ skipping 164 matching lines @@
 }
 
 void RenderWidgetHostViewAura::InternalSetBounds(const gfx::Rect& rect) {
   SnapToPhysicalPixelBoundary();
   // Don't recursively call SetBounds if this bounds update is the result of
   // a Window::SetBoundsInternal call.
   if (!in_bounds_changed_)
     window_->SetBounds(rect);
   host_->WasResized();
   delegated_frame_host_->WasResized();
-  if (touch_editing_client_) {
-    touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_,
-                                                      selection_focus_);
-  }
 #if defined(OS_WIN)
   // Create the legacy dummy window which corresponds to the bounds of the
   // webcontents. This will be passed as the container window for windowless
   // plugins.
   // Plugins like Flash assume the container window which is returned via the
   // NPNVnetscapeWindow property corresponds to the bounds of the webpage.
   // This is not true in Aura where we have only HWND which is the main Aura
   // window. If we return this window to plugins like Flash then it causes the
   // coordinate translations done by these plugins to break.
   // Additonally the legacy dummy window is needed for accessibility and for
@@ skipping 122 matching lines @@
     NativeWebKeyboardEvent copy_event(event);
     copy_event.match_edit_command = true;
     host_->ForwardKeyboardEvent(copy_event);
     return;
   }
 #endif
 
   host_->ForwardKeyboardEvent(event);
 }
 
+void RenderWidgetHostViewAura::SelectionUpdated(bool is_editable,
+                                                bool is_empty_text_form_control,
+                                                const ui::SelectionBound& start,
+                                                const ui::SelectionBound& end) {
+  selection_controller_->OnSelectionEditable(is_editable);
+  selection_controller_->OnSelectionEmpty(is_empty_text_form_control);
+  selection_controller_->OnSelectionBoundsChanged(start, end);
+}
+
+void RenderWidgetHostViewAura::HandleGestureForTouchSelection(
+    ui::GestureEvent* event) {
+  switch (event->type()) {
+    case ui::ET_GESTURE_LONG_PRESS:
+      if (selection_controller_->WillHandleLongPressEvent(
+              base::TimeTicks() + event->time_stamp(), event->location())) {
+        event->SetHandled();
+      }
+      break;
+    case ui::ET_GESTURE_TAP:
+      if (selection_controller_->WillHandleTapEvent(event->location()))
+        event->SetHandled();
+      break;
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+      selection_controller_client_->OnSelectionScrollStarted();
+      break;
+    case ui::ET_GESTURE_SCROLL_END:
+      selection_controller_client_->OnSelectionScrollCompleted();
+      break;
+    default:
+      break;
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Layer* RenderWidgetHostViewAura::DelegatedFrameHostGetLayer() const {
   return window_->layer();
 }
 
 bool RenderWidgetHostViewAura::DelegatedFrameHostIsVisible() const {
   return !host_->is_hidden();
 }
@@ skipping 66 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content