Update touch selection to only modify one selection point at a time.

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 51 matching lines @@
 InputRouterImpl::InputRouterImpl(IPC::Sender* sender,
                                  InputRouterClient* client,
                                  InputAckHandler* ack_handler,
                                  int routing_id,
                                  const Config& config)
     : sender_(sender),
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       select_range_pending_(false),
+      move_range_selection_extent_pending_(false),
       move_caret_pending_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       current_view_flags_(0),
       current_ack_source_(ACK_SOURCE_NONE),
       flush_requested_(false),
       touch_event_queue_(this, config.touch_config),
       gesture_event_queue_(this, this, config.gesture_config) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
   UpdateTouchAckTimeoutEnabled();
 }
 
 InputRouterImpl::~InputRouterImpl() {}
 
 void InputRouterImpl::Flush() {
   flush_requested_ = true;
   SignalFlushedIfNecessary();
 }
 
 bool InputRouterImpl::SendInput(scoped_ptr<IPC::Message> message) {
   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
   switch (message->type()) {
     // Check for types that require an ACK.
     case InputMsg_SelectRange::ID:
       return SendSelectRange(message.Pass());
+    case InputMsg_MoveRangeSelectionExtent::ID:
+      return SendMoveRangeSelectionExtent(message.Pass());
     case InputMsg_MoveCaret::ID:
       return SendMoveCaret(message.Pass());
     case InputMsg_HandleInputEvent::ID:
       NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
       return false;
     default:
       return Send(message.release());
   }
 }
 
@@ skipping 151 matching lines @@
 
   // A fixed page scale or mobile viewport should disable the touch ack timeout.
   UpdateTouchAckTimeoutEnabled();
 }
 
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(InputRouterImpl, message)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_SelectRange_ACK, OnSelectRangeAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_MoveRangeSelectionExtent_ACK,
+                        OnMoveRangeSelectionExtentAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                         OnSetTouchAction)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
@@ skipping 20 matching lines @@
   DCHECK(message->type() == InputMsg_SelectRange::ID);
   if (select_range_pending_) {
     next_selection_range_ = message.Pass();
     return true;
   }
 
   select_range_pending_ = true;
   return Send(message.release());
 }
 
+bool InputRouterImpl::SendMoveRangeSelectionExtent(
+    scoped_ptr<IPC::Message> message) {
+  DCHECK(message->type() == InputMsg_MoveRangeSelectionExtent::ID);

[jdduke (slow), 2014/10/21 16:57:36]

Hmm, so, in theory |SelectRange| and |MoveRangeSelectionExtent| messages could
be interleaved, arriving out-of-order in the render process (e.g., if a
SelectRange is pending and we get a new MoveRangeSelectionExtent message).

The simplest solution is probably: 

1) Keep a unified queue of IPCs for both messages types.
2) If the tail message of the queue is the same type as the new IPC, replace the
tail with the new IPC. Otherwise, enqueue it.
3) When an ack is received, dispatch the head of the queue.

Thoughts? Sorry I didn't think of this sooner, but hopefully it's not too crazy
to implement. Unfortunately, I don't think there's a ScopedDeque in base/ yet.

If that's confusing, feel free to TODO(jdduke) it and I'll implement it in a
follow-up patch.

[christiank, 2014/10/22 12:16:06]

I think you're right. Maybe we could use the queue for caret messages as well?
While there is no dependency between selection and caret messages it would be
possible to remove some code (and the other TODO that I added).

I'll attempt a fix for this using a std::deque. Unfortunately I suspect some
manual memory management will be required.

+  // TODO(jdduke): Factor out common logic between selection and caret-related
+  //               IPC messages.
+  if (move_range_selection_extent_pending_) {
+    next_range_selection_extent_move_ = message.Pass();
+    return true;
+  }
+
+  move_range_selection_extent_pending_ = true;
+  return Send(message.release());
+}
+
 bool InputRouterImpl::SendMoveCaret(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_MoveCaret::ID);
   if (move_caret_pending_) {
     next_move_caret_ = message.Pass();
     return true;
   }
 
   move_caret_pending_ = true;
   return Send(message.release());
 }
@@ skipping 164 matching lines @@
   if (next_move_caret_)
     SendMoveCaret(next_move_caret_.Pass());
 }
 
 void InputRouterImpl::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
     SendSelectRange(next_selection_range_.Pass());
 }
 
+void InputRouterImpl::OnMoveRangeSelectionExtentAck() {
+  move_range_selection_extent_pending_ = false;
+  if (next_range_selection_extent_move_)
+    SendMoveRangeSelectionExtent(next_range_selection_extent_move_.Pass());
+}
+
 void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
   TRACE_EVENT1("input", "InputRouterImpl::OnHasTouchEventHandlers",
                "has_handlers", has_handlers);
 
   // Lack of a touch handler indicates that the page either has no touch-action
   // modifiers or that all its touch-action modifiers are auto. Resetting the
   // touch-action here allows forwarding of subsequent gestures even if the
   // underlying touches never reach the router.
   // TODO(jdduke): Reset touch-action only at the end of a touch sequence to
   // prevent potentially strange mid-sequence behavior, crbug.com/375940.
@@ skipping 167 matching lines @@
   client_->DidFlush();
 }
 
 bool InputRouterImpl::HasPendingEvents() const {
   return !touch_event_queue_.empty() ||
          !gesture_event_queue_.empty() ||
          !key_queue_.empty() ||
          mouse_move_pending_ ||
          mouse_wheel_pending_ ||
          select_range_pending_ ||
+         move_range_selection_extent_pending_ ||
          move_caret_pending_;
 }
 
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent()
     : synthesized_from_pinch(false) {
 }
 
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
     const MouseWheelEventWithLatencyInfo& event,
     bool synthesized_from_pinch)
     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 }
 
 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 }
 
 }  // namespace content