Enable touch based selection and editing for webpages behind a flag.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 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/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 614 matching lines @@
       popup_child_host_view_(NULL),
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       has_composition_text_(false),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
       can_lock_compositor_(YES),
       paint_observer_(NULL),
-      accessible_parent_(NULL) {
+      accessible_parent_(NULL),
+      touch_editing_client_(NULL) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
 #if defined(OS_WIN)
   transient_observer_.reset(new TransientWindowObserver(this));
 #endif
@@ skipping 268 matching lines @@
   // Make sure we have a FocusClient before attempting to Focus(). In some
   // situations we may not yet be in a valid Window hierarchy (such as reloading
   // after out of memory discarded the tab).
   aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
   if (client)
     window_->Focus();
 }
 
 void RenderWidgetHostViewAura::Blur() {
   window_->Blur();
+  if (touch_editing_client_)

[sky, 2013/04/12 16:09:52]

Isn't this handled on 2518?

[varunjain, 2013/04/12 17:35:19]

Done.

+    touch_editing_client_->EndTouchEditing();
 }
 
 bool RenderWidgetHostViewAura::HasFocus() const {
   return window_->HasFocus();
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
   return current_surface_ || current_dib_ || !!host_->GetBackingStore(false);
 }
 
@@ skipping 48 matching lines @@
 }
 
 void RenderWidgetHostViewAura::TextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
   if (text_input_type_ != params.type ||
       can_compose_inline_ != params.can_compose_inline) {
     text_input_type_ = params.type;
     can_compose_inline_ = params.can_compose_inline;
     if (GetInputMethod())
       GetInputMethod()->OnTextInputTypeChanged(this);
+    if (touch_editing_client_)
+      touch_editing_client_->OnTextInputTypeChanged(text_input_type_);
   }
 }
 
 void RenderWidgetHostViewAura::ImeCancelComposition() {
   if (GetInputMethod())
     GetInputMethod()->CancelComposition(this);
   has_composition_text_ = false;
 }
 
 void RenderWidgetHostViewAura::ImeCompositionRangeChanged(
@@ skipping 95 matching lines @@
     const ViewHostMsg_SelectionBounds_Params& params) {
   if (selection_anchor_rect_ == params.anchor_rect &&
       selection_focus_rect_ == params.focus_rect)
     return;
 
   selection_anchor_rect_ = params.anchor_rect;
   selection_focus_rect_ = params.focus_rect;
 
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
+
+  if (touch_editing_client_) {
+    touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,

[sky, 2013/04/12 16:09:52]

TouchEditingClient seems to have a mix of functions that are synchronous (such
as the input event and focus ones) and those that come from the renderer. Is
that going to be problematic?

[varunjain, 2013/04/12 17:35:19]

The input event and ack are used to determine if touch handles need to be shown
or not. The actual position of touch handles is always updated asynchronously
through this OnSelectionOrCursorChanged call. I think the most important thing
to consider here is that when touch handles are visible, are they positioned
correctly and I think this condition is eventually true because of this call.
There is no other place where I update the position of the handles. So the
handles might lag behind but will always sync up.

+        selection_focus_rect_);
+  }
 }
 
 void RenderWidgetHostViewAura::ScrollOffsetChanged() {
   aura::RootWindow* root = window_->GetRootWindow();
   if (!root)
     return;
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root);
   if (cursor_client && !cursor_client->IsCursorVisible())
     cursor_client->DisableMouseEvents();
@@ skipping 584 matching lines @@
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
   return window_->GetToplevelWindow()->GetBoundsInScreen();
 }
 
+void RenderWidgetHostViewAura::GestureEventAck(int gesture_event_type) {
+  if (touch_editing_client_)
+    touch_editing_client_->GestureEventAck(gesture_event_type);
+}
+
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const WebKit::WebTouchEvent& touch_event, InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
   if (!MakeUITouchEventsFromWebTouchEvents(touch_event, &events,
                                            SCREEN_COORDINATES))
     return;
 
   aura::RootWindow* root = window_->GetRootWindow();
   // |root| is NULL during tests.
   if (!root)
@@ skipping 321 matching lines @@
     const gfx::Point& location) {
   return true;
 }
 
 bool RenderWidgetHostViewAura::CanFocus() {
   return popup_type_ == WebKit::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewAura::OnCaptureLost() {
   host_->LostCapture();
+  if (touch_editing_client_)
+    touch_editing_client_->EndTouchEditing();

[sky, 2013/04/12 16:09:52]

Does the client need to differentiate between a cancel like this and a normal
end?

[varunjain, 2013/04/12 17:35:19]

The effect of cancel or end is the same, ie, hide the handles. So we do not need
to differentiate.

 }
 
 void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
   bool is_compositing_active = host_->is_accelerated_compositing_active();
   bool has_backing_store = !!host_->GetBackingStore(false);
   if (is_compositing_active && current_dib_) {
     const gfx::Size window_size = window_->bounds().size();
     const gfx::Size& frame_size = last_swapped_surface_size_;
 
     SkBitmap bitmap;
@@ skipping 99 matching lines @@
   return scoped_refptr<ui::Texture>(
       factory->CreateOwnedTexture(
           current_surface_->size(), current_device_scale_factor_, texture_id));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::EventHandler implementation:
 
 void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnKeyEvent");
+  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+    return;
+
   if (popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab()) {
     popup_child_host_view_->OnKeyEvent(event);
     if (event->handled())
       return;
   }
 
   // We need to handle the Escape key for Pepper Flash.
   if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
     // Focus the window we were created from.
     if (host_tracker_.get() && !host_tracker_->windows().empty()) {
@@ skipping 29 matching lines @@
       NativeWebKeyboardEvent webkit_event(event);
       host_->ForwardKeyboardEvent(webkit_event);
     }
   }
   event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnMouseEvent");
 
+  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+    return;
+
   if (mouse_locked_) {
     // Hide the cursor if someone else has shown it.
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(window_->GetRootWindow());
     if (cursor_client && cursor_client->IsCursorVisible())
       cursor_client->DisableMouseEvents();
 
     WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event);
     gfx::Point center(gfx::Rect(window_->bounds().size()).CenterPoint());
 
@@ skipping 80 matching lines @@
   // TODO(pkotwicz): Find a better way of doing this.
   if (window_->parent()->delegate() && !(event->flags() & ui::EF_FROM_TOUCH))
     window_->parent()->delegate()->OnMouseEvent(event);
 
   if (!IsXButtonUpEvent(event))
     event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnScrollEvent");
+  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+    return;
+
   if (event->type() == ui::ET_SCROLL) {
     if (event->finger_count() != 2)
       return;
     WebKit::WebGestureEvent gesture_event =
         MakeWebGestureEventFlingCancel();
     host_->ForwardGestureEvent(gesture_event);
     WebKit::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(static_cast<ui::ScrollEvent*>(event));
     host_->ForwardWheelEvent(mouse_wheel_event);
     RecordAction(UserMetricsAction("TrackpadScroll"));
   } else if (event->type() == ui::ET_SCROLL_FLING_START ||
       event->type() == ui::ET_SCROLL_FLING_CANCEL) {
     WebKit::WebGestureEvent gesture_event =
         MakeWebGestureEvent(static_cast<ui::ScrollEvent*>(event));
     host_->ForwardGestureEvent(gesture_event);
     if (event->type() == ui::ET_SCROLL_FLING_START)
       RecordAction(UserMetricsAction("TrackpadScrollFling"));
   }
 
   event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnTouchEvent");
+  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+    return;
+
   // Update the touch event first.
   WebKit::WebTouchPoint* point = UpdateWebTouchEventFromUIEvent(*event,
                                                                 &touch_event_);
 
   // Forward the touch event only if a touch point was updated, and there's a
   // touch-event handler in the page, and no other touch-event is in the queue.
   // It is important to always consume the event if there is a touch-event
   // handler in the page, or some touch-event is already in the queue, even if
   // no point has been updated, to make sure that this event does not get
   // processed by the gesture recognizer before the events in the queue.
@@ skipping 10 matching lines @@
 void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnGestureEvent");
   // Pinch gestures are currently disabled by default. See crbug.com/128477.
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !ShouldSendPinchGesture()) {
     event->SetHandled();
     return;
   }
 
+  if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
+    return;
+
   RenderViewHostDelegate* delegate = NULL;
   if (popup_type_ == WebKit::WebPopupTypeNone && !is_fullscreen_)
     delegate = RenderViewHost::From(host_)->GetDelegate();
 
   if (delegate && event->type() == ui::ET_GESTURE_BEGIN &&
       event->details().touch_points() == 1) {
     delegate->HandleGestureBegin();
   }
 
   WebKit::WebGestureEvent gesture = MakeWebGestureEvent(event);
@@ skipping 91 matching lines @@
 
     DetachFromInputMethod();
     host_->SetInputMethodActive(false);
 
     // If we lose the focus while fullscreen, close the window; Pepper Flash
     // won't do it for us (unlike NPAPI Flash).
     if (is_fullscreen_ && !in_shutdown_) {
       in_shutdown_ = true;
       host_->Shutdown();
     }
+    if (touch_editing_client_)
+      touch_editing_client_->EndTouchEditing();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::RootWindowObserver implementation:
 
 void RenderWidgetHostViewAura::OnRootWindowMoved(const aura::RootWindow* root,
                                                  const gfx::Point& new_origin) {
   UpdateScreenInfo(window_);
 }
@@ skipping 118 matching lines @@
   host_->CompositingSurfaceUpdated();
   host_->ScheduleComposite();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
   if (paint_observer_)
     paint_observer_->OnViewDestroyed();
+  if (touch_editing_client_)
+    touch_editing_client_->OnViewDestroyed();
   if (!shared_surface_handle_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     factory->DestroySharedSurfaceHandle(shared_surface_handle_);
     factory->RemoveObserver(this);
   }
   window_observer_.reset();
 #if defined(OS_WIN)
   transient_observer_.reset();
 #endif
   if (window_->GetRootWindow())
@@ skipping 192 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content