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 10 matching lines @@
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
+#include "grit/ui_strings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/tooltip_client.h"
@@ skipping 900 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_selection_controller_.get())
+    touch_selection_controller_->SelectionChanged();
+}
+
+void RenderWidgetHostViewAura::TouchEditingHandlesVisibilityChanged(
+    bool visible) {
+  if (visible && !touch_selection_controller_.get()) {
+    touch_selection_controller_.reset(
+        ui::TouchSelectionController::create(this));
+  }
+  if (!visible)
+    touch_selection_controller_.reset();
+
+  if (touch_selection_controller_.get())
+    touch_selection_controller_->SelectionChanged();
 }
 
 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 681 matching lines @@
   return gfx::Size();
 }
 
 void RenderWidgetHostViewAura::OnBoundsChanged(const gfx::Rect& old_bounds,
                                                const gfx::Rect& new_bounds) {
   // We care about this only in fullscreen mode, where there is no
   // WebContentsViewAura. We are sized via SetSize() or SetBounds() by
   // WebContentsViewAura in other cases.
   if (is_fullscreen_)
     SetSize(new_bounds.size());
+
+  if (touch_selection_controller_.get())
+    touch_selection_controller_->SelectionChanged();
 }
 
 gfx::NativeCursor RenderWidgetHostViewAura::GetCursor(const gfx::Point& point) {
   if (mouse_locked_)
     return ui::kCursorNone;
   return current_cursor_.GetNativeCursor();
 }
 
 int RenderWidgetHostViewAura::GetNonClientComponent(
     const gfx::Point& point) const {
@@ skipping 480 matching lines @@
 
   DCHECK(!shared_surface_handle_.is_null());
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->DestroySharedSurfaceHandle(shared_surface_handle_);
   shared_surface_handle_ = factory->CreateSharedSurfaceHandle();
   host_->CompositingSurfaceUpdated();
   host_->ScheduleComposite();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHostViewAura, ui::TouchEditable implementation:
+
+void RenderWidgetHostViewAura::SelectRect(const gfx::Point& start,
+                                          const gfx::Point& end) {
+  // Since we draw selection handles in WebKit, we should never get here.
+  NOTREACHED();
+}
+
+void RenderWidgetHostViewAura::GetSelectionEndPoints(gfx::Rect* p1,
+                                                     gfx::Rect* p2) {
+  *p1 = selection_anchor_rect_;
+  *p2 = selection_focus_rect_;
+}
+
+gfx::Rect RenderWidgetHostViewAura::GetBounds() {
+  gfx::Rect bounds = GetViewBounds();
+  // We are supposed to return bounds in local coordinates, but GetViewBounds()
+  // gives bounds in screen space. So we convert.

[piman, 2013/02/22 02:43:04]

Can't we just return window_->bounds() ?

[varunjain, 2013/02/28 20:28:19]

Done.

+  gfx::Point origin = bounds.origin();
+  ConvertPointFromScreen(&origin);
+  bounds.set_origin(origin);
+  return bounds;
+}
+
+gfx::NativeView RenderWidgetHostViewAura::GetNativeView() {
+  return window_->GetRootWindow();

[piman, 2013/02/22 02:43:04]

There is already a GetNativeView() in this class. How does this even compile?
Also why are we returning the root window?

[varunjain, 2013/02/28 20:28:19]

Done.

+}
+
+void RenderWidgetHostViewAura::ConvertPointToScreen(gfx::Point* point) {
+  aura::client::ScreenPositionClient* screen_position_client =
+      aura::client::GetScreenPositionClient(window_->GetRootWindow());
+  if (screen_position_client)
+    screen_position_client->ConvertPointToScreen(window_, point);
+}
+
+void RenderWidgetHostViewAura::ConvertPointFromScreen(gfx::Point* point) {
+  aura::client::ScreenPositionClient* screen_position_client =
+      aura::client::GetScreenPositionClient(window_->GetRootWindow());
+  if (screen_position_client)
+    screen_position_client->ConvertPointFromScreen(window_, point);
+}
+
+bool RenderWidgetHostViewAura::DrawsHandles() {
+  return true;
+}
+
+void RenderWidgetHostViewAura::OpenContextMenu(const gfx::Point anchor) {
+  WebKit::WebMouseEvent mouse_event;
+  mouse_event.button = WebKit::WebMouseEvent::ButtonRight;
+  mouse_event.type = WebKit::WebInputEvent::MouseDown;
+  gfx::Point local_anchor = anchor;
+  ConvertPointFromScreen(&local_anchor);
+
+  mouse_event.windowX = mouse_event.x = local_anchor.x();
+  mouse_event.windowY = mouse_event.y = local_anchor.y();
+  mouse_event.globalX = anchor.x();
+  mouse_event.globalY = anchor.y();
+  host_->ForwardMouseEvent(mouse_event);

[piman, 2013/02/22 02:43:04]

This doesn't look reasonable - what are we trying to do?
Sending a right mouse click seems like the worst way to open a context menu.
Between the DOM hooking events, the possibility that a plugin (or other things)
is underneath, and the possibility that the page moved/changed, this looks ripe
for bugs/abuse/clickjacking opportunities.

[varunjain, 2013/02/28 20:28:19]

Removed. I have added proper API to webkit.

+  touch_selection_controller_.reset();
+}
+
+bool RenderWidgetHostViewAura::IsCommandIdChecked(int command_id) const {
+  NOTREACHED();
+  return false;
+}
+
+bool RenderWidgetHostViewAura::IsCommandIdEnabled(int command_id) const {
+  bool editable = text_input_type_ != ui::TEXT_INPUT_TYPE_NONE;
+  bool has_selection = !selection_range_.is_empty();
+  string16 result;

[piman, 2013/02/22 02:43:04]

nit: move to IDS_APP_PASTE case (add brackets there).

[varunjain, 2013/02/28 20:28:19]

Done.

+  switch (command_id) {
+    case IDS_APP_CUT:

[piman, 2013/02/22 02:43:04]

nit: rather than importing UI symbols here, it seems like it would be
advantageous to declare an enum somewhere...

[varunjain, 2013/02/28 20:28:19]

What would be the advantage? the enum will have to be declared somewhere in ui/
anyways because this interface is defined in ui/base.

+      return editable && has_selection;
+    case IDS_APP_COPY:
+      return has_selection;
+    case IDS_APP_PASTE:
+      ui::Clipboard::GetForCurrentThread()->ReadText(
+          ui::Clipboard::BUFFER_STANDARD, &result);
+      return editable && !result.empty();
+    case IDS_APP_DELETE:
+      return editable && has_selection;
+    case IDS_APP_SELECT_ALL:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool RenderWidgetHostViewAura::GetAcceleratorForCommandId(
+    int command_id,
+    ui::Accelerator* accelerator) {
+  return false;
+}
+
+void RenderWidgetHostViewAura::ExecuteCommand(int command_id) {
+  switch (command_id) {
+    case IDS_APP_CUT:
+      host_->Cut();
+      break;
+    case IDS_APP_COPY:
+      host_->Copy();
+      break;
+    case IDS_APP_PASTE:
+      host_->Paste();
+      break;
+    case IDS_APP_DELETE:
+      host_->Delete();
+      break;
+    case IDS_APP_SELECT_ALL:
+      host_->SelectAll();
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  touch_selection_controller_.reset();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
   if (paint_observer_)
     paint_observer_->OnViewDestroyed();
   if (!shared_surface_handle_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     factory->DestroySharedSurfaceHandle(shared_surface_handle_);
     factory->RemoveObserver(this);
   }
@@ skipping 196 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content