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

ui/touch_selection/touch_selection_controller.cc

 // Copyright 2014 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 "ui/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 
 namespace ui {
@@ skipping 12 matching lines @@
   }
   NOTREACHED() << "Invalid selection bound type: " << type;
   return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
 }
 
 }  // namespace
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     base::TimeDelta tap_timeout,
-    float tap_slop)
+    float tap_slop,
+    bool show_on_tap_for_empty_editable)
     : client_(client),
       tap_timeout_(tap_timeout),
       tap_slop_(tap_slop),
+      show_on_tap_for_empty_editable_(show_on_tap_for_empty_editable),
       response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
       start_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       end_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       is_insertion_active_(false),
       activate_insertion_automatically_(false),
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false) {
   DCHECK(client_);
-  HideAndDisallowShowingAutomatically();
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
-void TouchSelectionController::OnSelectionBoundsChanged(
+void TouchSelectionController::OnSelectionBoundsUpdated(
     const SelectionBound& start,
     const SelectionBound& end) {
   if (start == start_ && end_ == end)
     return;
 
   start_ = start;
   end_ = end;
   start_orientation_ = ToTouchHandleOrientation(start_.type());
   end_orientation_ = ToTouchHandleOrientation(end_.type());
 
@@ skipping 141 matching lines @@
 
   if (is_selection_active_) {
     bool needs_animate = start_selection_handle_->Animate(frame_time);
     needs_animate |= end_selection_handle_->Animate(frame_time);
     return needs_animate;
   }
 
   return false;
 }
 
+void TouchSelectionController::TryActivateSelection() {

[jdduke (slow), 2015/01/28 16:35:32]

How exactly does this differ from |AllowShowingFromCurrentSelection|? Can we
merge the two in some fashion?

[mohsen, 2015/02/22 23:23:09]

Oh, I missed |AllowShowingFromCurrentSelection()| completely. It does exactly
what I want. Removed this one.

+  if (GetStartPosition() != GetEndPosition()) {
+    SelectionBound start = start_;
+    SelectionBound end = end_;
+    ShowSelectionHandlesAutomatically();
+    OnSelectionBoundsUpdated(start, end);
+  }
+}
+
 void TouchSelectionController::OnHandleDragBegin(const TouchHandle& handle) {
   if (&handle == insertion_handle_.get()) {
     client_->OnSelectionEvent(INSERTION_DRAG_STARTED, handle.position());
     return;
   }
 
   gfx::PointF base, extent;
   if (&handle == start_selection_handle_.get()) {
     base = end_selection_handle_->position() + GetEndLineOffset();
     extent = start_selection_handle_->position() + GetStartLineOffset();
@@ skipping 18 matching lines @@
                                    : GetEndLineOffset();
   gfx::PointF line_position = position + line_offset;
   if (&handle == insertion_handle_.get()) {
     client_->MoveCaret(line_position);
   } else {
     client_->MoveRangeSelectionExtent(line_position);
   }
 }
 
 void TouchSelectionController::OnHandleDragEnd(const TouchHandle& handle) {
-  if (&handle != insertion_handle_.get())
+  if (&handle == insertion_handle_.get())
+    client_->OnSelectionEvent(INSERTION_DRAG_STOPPED, handle.position());
+  else
     client_->OnSelectionEvent(SELECTION_DRAG_STOPPED, handle.position());
 }
 
 void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) {
   if (insertion_handle_ && &handle == insertion_handle_.get())
     client_->OnSelectionEvent(INSERTION_TAPPED, handle.position());
 }
 
 void TouchSelectionController::SetNeedsAnimate() {
   client_->SetNeedsAnimate();
@@ skipping 21 matching lines @@
 void TouchSelectionController::ShowSelectionHandlesAutomatically() {
   if (activate_selection_automatically_)
     return;
   activate_selection_automatically_ = true;
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::OnInsertionChanged() {
   DeactivateSelection();
 
-  if (response_pending_input_event_ == TAP && selection_empty_) {
+  if (response_pending_input_event_ == TAP && selection_empty_ &&
+      !show_on_tap_for_empty_editable_) {
     HideAndDisallowShowingAutomatically();
     return;
   }
 
   if (!activate_insertion_automatically_)
     return;
 
   const bool was_active = is_insertion_active_;
   const gfx::PointF position = GetStartPosition();
   if (!is_insertion_active_)
     ActivateInsertion();
   else
     client_->OnSelectionEvent(INSERTION_MOVED, position);
 
   insertion_handle_->SetVisible(GetStartVisible(),
                                 GetAnimationStyle(was_active));
   insertion_handle_->SetPosition(position);
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
-  if (!activate_selection_automatically_)
+  if (!activate_selection_automatically_) // XXX: needed?
     return;
 
   const bool was_active = is_selection_active_;
   ActivateSelection();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(was_active);
   start_selection_handle_->SetVisible(GetStartVisible(), animation);
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
 
   start_selection_handle_->SetPosition(GetStartPosition());
@@ skipping 94 matching lines @@
 }
 
 TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
     bool was_active) const {
   return was_active && client_->SupportsAnimation()
              ? TouchHandle::ANIMATION_SMOOTH
              : TouchHandle::ANIMATION_NONE;
 }
 
 }  // namespace ui