[Android] Allow custom ActionMode creation via ContentViewClient

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"
 #include "base/metrics/histogram_macros.h"
 
@@ skipping 212 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;
 }
 
+gfx::RectF TouchSelectionController::GetRectBetweenBounds() const {
+  // Short-circuit for efficiency.
+  if (!is_insertion_active_ && !is_selection_active_)
+    return gfx::RectF();
+
+  if (start_.visible() && !end_.visible())
+    return gfx::BoundingRect(start_.edge_top(), start_.edge_bottom());
+
+  if (end_.visible() && !start_.visible())
+    return gfx::BoundingRect(end_.edge_top(), end_.edge_bottom());
+
+  // If both handles are visible, or both are invisible, use the entire rect.
+  return RectFBetweenSelectionBounds(start_, end_);

[mfomitchev, 2015/04/14 15:02:33]

Can't we also have a case when non are visible (but selection is active)? E.g.
if the selection was scrolled off the screen.

[jdduke (slow), 2015/04/14 15:19:30]

For sure, but I think the controller should be somewhat agnostic to the View
bounds. That is, don't you want the handles to display even if the selection
endpoint are both offscreen? There are also cases where the selection may be
onscreen but the handles themselves are occluded, in which case I think we still
may want the full selection region. We can then let the client do the right
thing with respect to either clipping the selection rect or dropping the rect if
it exceeds the viewport.

+}
+
+gfx::RectF TouchSelectionController::GetRectBetweenBoundsIncludingHandles()

[mfomitchev, 2015/04/14 15:02:33]

Having a method returning MaxHandleImageSize/MaxHandleVisibleSize would give us
more flexibility, since we'd be able to position the menu between the two bounds
if they are far enough. This is what the Aura implementation does (see
https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/touchui/t...).
The downside is that this logic becomes more complicated when you introduce
inverted/flipped handles, but IMHO this is the complexity we have to deal with.
Always positioning the menu below the handles even when there is plenty of space
in between looks pretty weird on a desktop. Take a look:
https://drive.google.com/open?id=0B2LVVIKSxUVYS0lqYkJEWDFNYWc&authuser=0. I
suspect it will look weird on a tablet as well.

[jdduke (slow), 2015/04/14 15:19:30]

Well, we may simply have to differ between platforms here. The Android API
doesn't offer this distinction; we only provide it one bounding rect. I'd
generalize this method to support Aura's approach, but that might be premature.

+    const {
+  gfx::RectF rect = GetRectBetweenBounds();
+  if (rect.IsEmpty())
+    return rect;
+
+  if (is_insertion_active_) {
+    rect.Union(insertion_handle_->GetVisibleBounds());
+  } else if (is_selection_active_) {
+    rect.Union(start_selection_handle_->GetVisibleBounds());
+    rect.Union(end_selection_handle_->GetVisibleBounds());
+  }
+
+  return rect;
+}
+
+const gfx::PointF& TouchSelectionController::GetStartPosition() const {
+  return start_.edge_bottom();
+}
+
+const gfx::PointF& TouchSelectionController::GetEndPosition() const {
+  return end_.edge_bottom();
+}
+
 void TouchSelectionController::OnHandleDragBegin(const TouchHandle& handle) {
   if (&handle == insertion_handle_.get()) {
-    client_->OnSelectionEvent(INSERTION_DRAG_STARTED, handle.position());
+    client_->OnSelectionEvent(INSERTION_DRAG_STARTED);
     return;
   }
 
   gfx::PointF base, extent;
   if (&handle == start_selection_handle_.get()) {
     base = end_selection_handle_->position() + GetEndLineOffset();
     extent = start_selection_handle_->position() + GetStartLineOffset();
   } else {
     base = start_selection_handle_->position() + GetStartLineOffset();
     extent = end_selection_handle_->position() + GetEndLineOffset();
   }
   selection_handle_dragged_ = true;
 
   // When moving the handle we want to move only the extent point. Before doing
   // so we must make sure that the base point is set correctly.
   client_->SelectBetweenCoordinates(base, extent);
-
-  client_->OnSelectionEvent(SELECTION_DRAG_STARTED, handle.position());
+  client_->OnSelectionEvent(SELECTION_DRAG_STARTED);
 }
 
 void TouchSelectionController::OnHandleDragUpdate(const TouchHandle& handle,
                                                   const gfx::PointF& position) {
   // As the position corresponds to the bottom left point of the selection
   // bound, offset it by half the corresponding line height.
   gfx::Vector2dF line_offset = &handle == start_selection_handle_.get()
                                    ? GetStartLineOffset()
                                    : 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())
-    client_->OnSelectionEvent(INSERTION_DRAG_STOPPED, handle.position());
+    client_->OnSelectionEvent(INSERTION_DRAG_STOPPED);
   else
-    client_->OnSelectionEvent(SELECTION_DRAG_STOPPED, handle.position());
+    client_->OnSelectionEvent(SELECTION_DRAG_STOPPED);
 }
 
 void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) {
   if (insertion_handle_ && &handle == insertion_handle_.get())
-    client_->OnSelectionEvent(INSERTION_TAPPED, handle.position());
+    client_->OnSelectionEvent(INSERTION_TAPPED);
 }
 
 void TouchSelectionController::SetNeedsAnimate() {
   client_->SetNeedsAnimate();
 }
 
 scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() {
   return client_->CreateDrawable();
 }
 
@@ skipping 29 matching lines @@
   }
 
   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);
+    client_->OnSelectionEvent(INSERTION_MOVED);
 
   insertion_handle_->SetVisible(GetStartVisible(),
                                 GetAnimationStyle(was_active));
   insertion_handle_->SetPosition(position);
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
   if (!activate_selection_automatically_)
     return;
 
   const bool was_active = is_selection_active_;
-  ActivateSelection();
+  if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS)
+    ActivateSelection();
+  else
+    client_->OnSelectionEvent(SELECTION_MOVED);
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(was_active);
   start_selection_handle_->SetVisible(GetStartVisible(), animation);
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
 
   start_selection_handle_->SetPosition(GetStartPosition());
   end_selection_handle_->SetPosition(GetEndPosition());
 }
 
 void TouchSelectionController::ActivateInsertion() {
   DCHECK(!is_selection_active_);
 
   if (!insertion_handle_)
     insertion_handle_.reset(
         new TouchHandle(this, TouchHandleOrientation::CENTER));
 
   if (!is_insertion_active_) {
     is_insertion_active_ = true;
     insertion_handle_->SetEnabled(true);
-    client_->OnSelectionEvent(INSERTION_SHOWN, GetStartPosition());
+    client_->OnSelectionEvent(INSERTION_SHOWN);
   }
 }
 
 void TouchSelectionController::DeactivateInsertion() {
   if (!is_insertion_active_)
     return;
   DCHECK(insertion_handle_);
   is_insertion_active_ = false;
   insertion_handle_->SetEnabled(false);
-  client_->OnSelectionEvent(INSERTION_CLEARED, gfx::PointF());
+  client_->OnSelectionEvent(INSERTION_CLEARED);
 }
 
 void TouchSelectionController::ActivateSelection() {
   DCHECK(!is_insertion_active_);
 
   if (!start_selection_handle_) {
     start_selection_handle_.reset(new TouchHandle(this, start_orientation_));
   } else {
     start_selection_handle_->SetEnabled(true);
     start_selection_handle_->SetOrientation(start_orientation_);
@@ skipping 11 matching lines @@
   // intervening SELECTION_CLEARED update to avoid unnecessary state changes.
   if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
     if (is_selection_active_) {
       // The active selection session finishes with the start of the new one.
       LogSelectionEnd();
     }
     is_selection_active_ = true;
     selection_handle_dragged_ = false;
     selection_start_time_ = base::TimeTicks::Now();
     response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
-    client_->OnSelectionEvent(SELECTION_SHOWN, GetStartPosition());
+    client_->OnSelectionEvent(SELECTION_SHOWN);
   }
 }
 
 void TouchSelectionController::DeactivateSelection() {
   if (!is_selection_active_)
     return;
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
   LogSelectionEnd();
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   is_selection_active_ = false;
-  client_->OnSelectionEvent(SELECTION_CLEARED, gfx::PointF());
+  client_->OnSelectionEvent(SELECTION_CLEARED);
 }
 
 void TouchSelectionController::ResetCachedValuesIfInactive() {
   if (is_selection_active_ || is_insertion_active_)
     return;
   start_ = SelectionBound();
   end_ = SelectionBound();
   start_orientation_ = TouchHandleOrientation::UNDEFINED;
   end_orientation_ = TouchHandleOrientation::UNDEFINED;
 }
 
-const gfx::PointF& TouchSelectionController::GetStartPosition() const {
-  return start_.edge_bottom();
-}
-
-const gfx::PointF& TouchSelectionController::GetEndPosition() const {
-  return end_.edge_bottom();
-}
-
 gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const {
   return ComputeLineOffsetFromBottom(start_);
 }
 
 gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
   return ComputeLineOffsetFromBottom(end_);
 }
 
 bool TouchSelectionController::GetStartVisible() const {
   return start_.visible() && !temporarily_hidden_;
@@ skipping 19 matching lines @@
     base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchSelection.WasDraggedDuration",
                                duration,
                                base::TimeDelta::FromMilliseconds(500),
                                base::TimeDelta::FromSeconds(60),
                                60);
   }
 }
 
 }  // namespace ui