Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(613)

Unified Diff: content/browser/renderer_host/input/touch_selection_controller.cc

Issue 754963007: Revert of Move TouchSelectionController from content to ui (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: content/browser/renderer_host/input/touch_selection_controller.cc
diff --git a/content/browser/renderer_host/input/touch_selection_controller.cc b/content/browser/renderer_host/input/touch_selection_controller.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bc913fde56e0bf997dfe5412ef147fce17e4e757
--- /dev/null
+++ b/content/browser/renderer_host/input/touch_selection_controller.cc
@@ -0,0 +1,435 @@
+// 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 "content/browser/renderer_host/input/touch_selection_controller.h"
+
+#include "base/auto_reset.h"
+#include "base/logging.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace content {
+namespace {
+
+TouchHandleOrientation ToTouchHandleOrientation(cc::SelectionBoundType type) {
+ switch (type) {
+ case cc::SELECTION_BOUND_LEFT:
+ return TOUCH_HANDLE_LEFT;
+ case cc::SELECTION_BOUND_RIGHT:
+ return TOUCH_HANDLE_RIGHT;
+ case cc::SELECTION_BOUND_CENTER:
+ return TOUCH_HANDLE_CENTER;
+ case cc::SELECTION_BOUND_EMPTY:
+ return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+ }
+ NOTREACHED() << "Invalid selection bound type: " << type;
+ return TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+}
+
+} // namespace
+
+TouchSelectionController::TouchSelectionController(
+ TouchSelectionControllerClient* client,
+ base::TimeDelta tap_timeout,
+ float tap_slop)
+ : client_(client),
+ tap_timeout_(tap_timeout),
+ tap_slop_(tap_slop),
+ 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(
+ const cc::ViewportSelectionBound& start,
+ const cc::ViewportSelectionBound& end) {
+ if (start == start_ && end_ == end)
+ return;
+
+ start_ = start;
+ end_ = end;
+ start_orientation_ = ToTouchHandleOrientation(start_.type);
+ end_orientation_ = ToTouchHandleOrientation(end_.type);
+
+ if (!activate_selection_automatically_ &&
+ !activate_insertion_automatically_) {
+ DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
+ return;
+ }
+
+ // Ensure that |response_pending_input_event_| is cleared after the method
+ // completes, while also making its current value available for the duration
+ // of the call.
+ InputEventType causal_input_event = response_pending_input_event_;
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
+ base::AutoReset<InputEventType> auto_reset_response_pending_input_event(
+ &response_pending_input_event_, causal_input_event);
+
+ const bool is_selection_dragging =
+ is_selection_active_ && (start_selection_handle_->is_dragging() ||
+ end_selection_handle_->is_dragging());
+
+ // It's possible that the bounds temporarily overlap while a selection handle
+ // is being dragged, incorrectly reporting a CENTER orientation.
+ // TODO(jdduke): This safeguard is racy, as it's possible the delayed response
+ // from handle positioning occurs *after* the handle dragging has ceased.
+ // Instead, prevent selection -> insertion transitions without an intervening
+ // action or selection clearing of some sort, crbug.com/392696.
+ if (is_selection_dragging) {
+ if (start_orientation_ == TOUCH_HANDLE_CENTER)
+ start_orientation_ = start_selection_handle_->orientation();
+ if (end_orientation_ == TOUCH_HANDLE_CENTER)
+ end_orientation_ = end_selection_handle_->orientation();
+ }
+
+ if (GetStartPosition() != GetEndPosition() ||
+ (is_selection_dragging &&
+ start_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED &&
+ end_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED)) {
+ OnSelectionChanged();
+ return;
+ }
+
+ if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_) {
+ OnInsertionChanged();
+ return;
+ }
+
+ HideAndDisallowShowingAutomatically();
+}
+
+bool TouchSelectionController::WillHandleTouchEvent(
+ const ui::MotionEvent& event) {
+ if (is_insertion_active_) {
+ DCHECK(insertion_handle_);
+ return insertion_handle_->WillHandleTouchEvent(event);
+ }
+
+ if (is_selection_active_) {
+ DCHECK(start_selection_handle_);
+ DCHECK(end_selection_handle_);
+ if (start_selection_handle_->is_dragging())
+ return start_selection_handle_->WillHandleTouchEvent(event);
+
+ if (end_selection_handle_->is_dragging())
+ return end_selection_handle_->WillHandleTouchEvent(event);
+
+ const gfx::PointF event_pos(event.GetX(), event.GetY());
+ if ((event_pos - GetStartPosition()).LengthSquared() <=
+ (event_pos - GetEndPosition()).LengthSquared())
+ return start_selection_handle_->WillHandleTouchEvent(event);
+ else
+ return end_selection_handle_->WillHandleTouchEvent(event);
+ }
+
+ return false;
+}
+
+void TouchSelectionController::OnLongPressEvent() {
+ response_pending_input_event_ = LONG_PRESS;
+ ShowSelectionHandlesAutomatically();
+ ShowInsertionHandleAutomatically();
+ ResetCachedValuesIfInactive();
+}
+
+void TouchSelectionController::AllowShowingFromCurrentSelection() {
+ if (is_selection_active_ || is_insertion_active_)
+ return;
+
+ activate_selection_automatically_ = true;
+ activate_insertion_automatically_ = true;
+ if (GetStartPosition() != GetEndPosition())
+ OnSelectionChanged();
+ else if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_)
+ OnInsertionChanged();
+}
+
+void TouchSelectionController::OnTapEvent() {
+ response_pending_input_event_ = TAP;
+ ShowInsertionHandleAutomatically();
+ if (selection_empty_)
+ DeactivateInsertion();
+ ResetCachedValuesIfInactive();
+}
+
+void TouchSelectionController::HideAndDisallowShowingAutomatically() {
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
+ DeactivateInsertion();
+ DeactivateSelection();
+ activate_insertion_automatically_ = false;
+ activate_selection_automatically_ = false;
+}
+
+void TouchSelectionController::SetTemporarilyHidden(bool hidden) {
+ if (temporarily_hidden_ == hidden)
+ return;
+ temporarily_hidden_ = hidden;
+
+ TouchHandle::AnimationStyle animation_style = GetAnimationStyle(true);
+ if (is_selection_active_) {
+ start_selection_handle_->SetVisible(GetStartVisible(), animation_style);
+ end_selection_handle_->SetVisible(GetEndVisible(), animation_style);
+ }
+ if (is_insertion_active_)
+ insertion_handle_->SetVisible(GetStartVisible(), animation_style);
+}
+
+void TouchSelectionController::OnSelectionEditable(bool editable) {
+ if (selection_editable_ == editable)
+ return;
+ selection_editable_ = editable;
+ ResetCachedValuesIfInactive();
+ if (!selection_editable_)
+ DeactivateInsertion();
+}
+
+void TouchSelectionController::OnSelectionEmpty(bool empty) {
+ if (selection_empty_ == empty)
+ return;
+ selection_empty_ = empty;
+ ResetCachedValuesIfInactive();
+}
+
+bool TouchSelectionController::Animate(base::TimeTicks frame_time) {
+ if (is_insertion_active_)
+ return insertion_handle_->Animate(frame_time);
+
+ 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::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();
+ } else {
+ base = start_selection_handle_->position() + GetStartLineOffset();
+ extent = end_selection_handle_->position() + GetEndLineOffset();
+ }
+
+ // 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());
+}
+
+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 == end_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(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();
+}
+
+scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() {
+ return client_->CreateDrawable();
+}
+
+base::TimeDelta TouchSelectionController::GetTapTimeout() const {
+ return tap_timeout_;
+}
+
+float TouchSelectionController::GetTapSlop() const {
+ return tap_slop_;
+}
+
+void TouchSelectionController::ShowInsertionHandleAutomatically() {
+ if (activate_insertion_automatically_)
+ return;
+ activate_insertion_automatically_ = true;
+ ResetCachedValuesIfInactive();
+}
+
+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_) {
+ 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_)
+ 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());
+ end_selection_handle_->SetPosition(GetEndPosition());
+}
+
+void TouchSelectionController::ActivateInsertion() {
+ DCHECK(!is_selection_active_);
+
+ if (!insertion_handle_)
+ insertion_handle_.reset(new TouchHandle(this, TOUCH_HANDLE_CENTER));
+
+ if (!is_insertion_active_) {
+ is_insertion_active_ = true;
+ insertion_handle_->SetEnabled(true);
+ client_->OnSelectionEvent(INSERTION_SHOWN, GetStartPosition());
+ }
+}
+
+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());
+}
+
+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_);
+ }
+
+ 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.
+ if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
+ is_selection_active_ = true;
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
+ client_->OnSelectionEvent(SELECTION_SHOWN, GetStartPosition());
+ }
+}
+
+void TouchSelectionController::DeactivateSelection() {
+ if (!is_selection_active_)
+ return;
+ DCHECK(start_selection_handle_);
+ DCHECK(end_selection_handle_);
+ start_selection_handle_->SetEnabled(false);
+ end_selection_handle_->SetEnabled(false);
+ is_selection_active_ = false;
+ client_->OnSelectionEvent(SELECTION_CLEARED, gfx::PointF());
+}
+
+void TouchSelectionController::ResetCachedValuesIfInactive() {
+ if (is_selection_active_ || is_insertion_active_)
+ return;
+ start_ = cc::ViewportSelectionBound();
+ end_ = cc::ViewportSelectionBound();
+ start_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+ end_orientation_ = TOUCH_HANDLE_ORIENTATION_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 gfx::ScaleVector2d(start_.edge_top - start_.edge_bottom, 0.5f);
+}
+
+gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
+ return gfx::ScaleVector2d(end_.edge_top - end_.edge_bottom, 0.5f);
+}
+
+bool TouchSelectionController::GetStartVisible() const {
+ return start_.visible && !temporarily_hidden_;
+}
+
+bool TouchSelectionController::GetEndVisible() const {
+ return end_.visible && !temporarily_hidden_;
+}
+
+TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
+ bool was_active) const {
+ return was_active && client_->SupportsAnimation()
+ ? TouchHandle::ANIMATION_SMOOTH
+ : TouchHandle::ANIMATION_NONE;
+}
+
+} // namespace content

Powered by Google App Engine
This is Rietveld 408576698