Update touch selection notification names, add ESTABLISHED.

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 62 matching lines @@
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const SelectionBound& start,
     const SelectionBound& end) {
   if (!force_next_update_ && start == start_ && end_ == end)
     return;
 
+  // Notify if selection bounds have just been established or dissolved.
+  if (start.type() != SelectionBound::EMPTY &&
+      start_.type() == SelectionBound::EMPTY) {
+    client_->OnSelectionEvent(SELECTION_ESTABLISHED);
+  } else if (start.type() == SelectionBound::EMPTY &&
+             start_.type() != SelectionBound::EMPTY) {
+    client_->OnSelectionEvent(SELECTION_DISSOLVED);
+  }
+
   start_ = start;
   end_ = end;
   start_orientation_ = ToTouchHandleOrientation(start_.type());
   end_orientation_ = ToTouchHandleOrientation(end_.type());
   force_next_update_ = false;
 
   if (!activate_selection_automatically_ &&
       !activate_insertion_automatically_) {
     DCHECK_EQ(INACTIVE, active_status_);
     DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
@@ skipping 196 matching lines @@
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
   return end_.edge_bottom();
 }
 
 void TouchSelectionController::OnDragBegin(
     const TouchSelectionDraggable& draggable,
     const gfx::PointF& drag_position) {
   if (&draggable == insertion_handle_.get()) {
     DCHECK_EQ(active_status_, INSERTION_ACTIVE);
-    client_->OnSelectionEvent(INSERTION_DRAG_STARTED);
+    client_->OnSelectionEvent(INSERTION_HANDLE_DRAG_STARTED);
     anchor_drag_to_selection_start_ = true;
     return;
   }
 
   DCHECK_EQ(active_status_, SELECTION_ACTIVE);
 
   if (&draggable == start_selection_handle_.get()) {
     anchor_drag_to_selection_start_ = true;
   } else if (&draggable == end_selection_handle_.get()) {
     anchor_drag_to_selection_start_ = false;
   } else {
     DCHECK_EQ(&draggable, &longpress_drag_selector_);
     anchor_drag_to_selection_start_ =
         (drag_position - GetStartPosition()).LengthSquared() <
         (drag_position - GetEndPosition()).LengthSquared();
   }
 
   gfx::PointF base = GetStartPosition() + GetStartLineOffset();
   gfx::PointF extent = GetEndPosition() + GetEndLineOffset();
   if (anchor_drag_to_selection_start_)
     std::swap(base, extent);
 
   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);
+  client_->OnSelectionEvent(SELECTION_HANDLE_DRAG_STARTED);
 }
 
 void TouchSelectionController::OnDragUpdate(
     const TouchSelectionDraggable& draggable,
     const gfx::PointF& drag_position) {
   // As the position corresponds to the bottom left point of the selection
   // bound, offset it to some reasonable point on the current line of text.
   gfx::Vector2dF line_offset = anchor_drag_to_selection_start_
                                    ? GetStartLineOffset()
                                    : GetEndLineOffset();
   gfx::PointF line_position = drag_position + line_offset;
   if (&draggable == insertion_handle_.get())
     client_->MoveCaret(line_position);
   else
     client_->MoveRangeSelectionExtent(line_position);
 }
 
 void TouchSelectionController::OnDragEnd(
     const TouchSelectionDraggable& draggable) {
   if (&draggable == insertion_handle_.get())
-    client_->OnSelectionEvent(INSERTION_DRAG_STOPPED);
+    client_->OnSelectionEvent(INSERTION_HANDLE_DRAG_STOPPED);
   else
-    client_->OnSelectionEvent(SELECTION_DRAG_STOPPED);
+    client_->OnSelectionEvent(SELECTION_HANDLE_DRAG_STOPPED);
 }
 
 bool TouchSelectionController::IsWithinTapSlop(
     const gfx::Vector2dF& delta) const {
   return delta.LengthSquared() <
          (static_cast<double>(config_.tap_slop) * config_.tap_slop);
 }
 
 void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) {
   if (insertion_handle_ && &handle == insertion_handle_.get())
-    client_->OnSelectionEvent(INSERTION_TAPPED);
+    client_->OnSelectionEvent(INSERTION_HANDLE_TAPPED);
 }
 
 void TouchSelectionController::SetNeedsAnimate() {
   client_->SetNeedsAnimate();
 }
 
 scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() {
   return client_->CreateDrawable();
 }
 
@@ skipping 56 matching lines @@
 
   if (!activate_insertion_automatically_)
     return;
 
   const bool activated = ActivateInsertionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
   insertion_handle_->SetVisible(GetStartVisible(), animation);
   insertion_handle_->SetPosition(GetStartPosition());
 
-  client_->OnSelectionEvent(activated ? INSERTION_SHOWN : INSERTION_MOVED);
+  client_->OnSelectionEvent(activated ? INSERTION_HANDLE_SHOWN
+                                      : INSERTION_HANDLE_MOVED);
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
   if (!activate_selection_automatically_)
     return;
 
   const bool activated = ActivateSelectionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
   start_selection_handle_->SetVisible(GetStartVisible(), animation);
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
   start_selection_handle_->SetPosition(GetStartPosition());
   end_selection_handle_->SetPosition(GetEndPosition());
 
-  client_->OnSelectionEvent(activated ? SELECTION_SHOWN : SELECTION_MOVED);
+  client_->OnSelectionEvent(activated ? SELECTION_HANDLES_SHOWN
+                                      : SELECTION_HANDLES_MOVED);
 }
 
 bool TouchSelectionController::ActivateInsertionIfNecessary() {
   DCHECK_NE(SELECTION_ACTIVE, active_status_);
 
   if (!insertion_handle_) {
     insertion_handle_.reset(
         new TouchHandle(this, TouchHandleOrientation::CENTER));
   }
 
   if (active_status_ == INACTIVE) {
     active_status_ = INSERTION_ACTIVE;
     insertion_handle_->SetEnabled(true);
     return true;
   }
   return false;
 }
 
 void TouchSelectionController::DeactivateInsertion() {
   if (active_status_ != INSERTION_ACTIVE)
     return;
   DCHECK(insertion_handle_);
   active_status_ = INACTIVE;
   insertion_handle_->SetEnabled(false);
-  client_->OnSelectionEvent(INSERTION_CLEARED);
+  client_->OnSelectionEvent(INSERTION_HANDLE_CLEARED);
 }
 
 bool TouchSelectionController::ActivateSelectionIfNecessary() {
   DCHECK_NE(INSERTION_ACTIVE, active_status_);
 
   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_);
   }
 
   if (!end_selection_handle_) {
     end_selection_handle_.reset(new TouchHandle(this, end_orientation_));
   } else {
     end_selection_handle_->SetEnabled(true);
     end_selection_handle_->SetOrientation(end_orientation_);
   }
 
   // As a long press received while a selection is already active may trigger
   // an entirely new selection, notify the client but avoid sending an
-  // intervening SELECTION_CLEARED update to avoid unnecessary state changes.
+  // intervening SELECTION_HANDLES_CLEARED update to avoid unnecessary state
+  // changes.
   if (active_status_ == INACTIVE ||
       response_pending_input_event_ == LONG_PRESS) {
     if (active_status_ == SELECTION_ACTIVE) {
       // The active selection session finishes with the start of the new one.
       LogSelectionEnd();
     }
     active_status_ = SELECTION_ACTIVE;
     selection_handle_dragged_ = false;
     selection_start_time_ = base::TimeTicks::Now();
     response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
     longpress_drag_selector_.OnSelectionActivated();
     return true;
   }
   return false;
 }
 
 void TouchSelectionController::DeactivateSelection() {
   if (active_status_ != SELECTION_ACTIVE)
     return;
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
   LogSelectionEnd();
   longpress_drag_selector_.OnSelectionDeactivated();
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   active_status_ = INACTIVE;
-  client_->OnSelectionEvent(SELECTION_CLEARED);
+  client_->OnSelectionEvent(SELECTION_HANDLES_CLEARED);
 }
 
 void TouchSelectionController::ForceNextUpdateIfInactive() {
   // Only force the update if the reported selection is non-empty but still
   // considered "inactive", i.e., it wasn't preceded by a user gesture or
   // the handles have since been explicitly hidden.
   if (active_status_ == INACTIVE &&
       start_.type() != SelectionBound::EMPTY &&
       end_.type() != SelectionBound::EMPTY) {
     force_next_update_ = true;
@@ skipping 48 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