[Android] Enable composited selection updates

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 260 matching lines @@
       is_showing_(!widget_host->is_hidden()),
       content_view_core_(NULL),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       overscroll_effect_enabled_(
           !base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableOverscrollEdgeEffect)),
       gesture_provider_(CreateGestureProviderConfig(), this),
       gesture_text_selector_(this),
-      touch_scrolling_(false),
-      potentially_active_fling_count_(0),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
   host_->SetView(this);
   SetContentViewCore(content_view_core);
@@ skipping 177 matching lines @@
   // We don't have plugin windows on Android. Do nothing. Note: this is called
   // from RenderWidgetHost::OnUpdateRect which is itself invoked while
   // processing the corresponding message from Renderer.
 }
 
 void RenderWidgetHostViewAndroid::Focus() {
   host_->Focus();
   host_->SetInputMethodActive(true);
   if (overscroll_effect_)
     overscroll_effect_->Enable();
+  if (selection_controller_)
+    selection_controller_->SetTemporarilyHidden(false);
 }
 
 void RenderWidgetHostViewAndroid::Blur() {
   host_->SetInputMethodActive(false);
   host_->Blur();
   if (overscroll_effect_)
     overscroll_effect_->Disable();
+  if (selection_controller_)
+    selection_controller_->SetTemporarilyHidden(true);
 }
 
 bool RenderWidgetHostViewAndroid::HasFocus() const {
   if (!content_view_core_)
     return false;  // ContentViewCore not created yet.
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
@@ skipping 231 matching lines @@
 
 void RenderWidgetHostViewAndroid::ResetGestureDetection() {
   const ui::MotionEvent* current_down_event =
       gesture_provider_.GetCurrentDownEvent();
   if (!current_down_event)
     return;
 
   scoped_ptr<ui::MotionEvent> cancel_event = current_down_event->Cancel();
   DCHECK(cancel_event);
   OnTouchEvent(*cancel_event);
-
-  touch_scrolling_ = false;
-  potentially_active_fling_count_ = 0;
-  OnContentScrollingChange();
 }
 
 void RenderWidgetHostViewAndroid::SetDoubleTapSupportEnabled(bool enabled) {
   gesture_provider_.SetDoubleTapSupportForPlatformEnabled(enabled);
 }
 
 void RenderWidgetHostViewAndroid::SetMultiTouchZoomSupportEnabled(
     bool enabled) {
   gesture_provider_.SetMultiTouchZoomSupportEnabled(enabled);
 }
@@ skipping 53 matching lines @@
     return;
   }
 
   std::string utf8_selection = base::UTF16ToUTF8(text.substr(pos, n));
 
   content_view_core_->OnSelectionChanged(utf8_selection);
 }
 
 void RenderWidgetHostViewAndroid::SelectionBoundsChanged(
     const ViewHostMsg_SelectionBounds_Params& params) {
-  if (!selection_controller_)
-    return;
-
-  gfx::RectF start_rect(params.anchor_rect);
-  gfx::RectF end_rect(params.focus_rect);
-  if (params.is_anchor_first)
-    std::swap(start_rect, end_rect);
-
-  cc::ViewportSelectionBound start_bound, end_bound;
-  start_bound.visible = true;
-  end_bound.visible = true;
-  start_bound.edge_top = start_rect.origin();
-  start_bound.edge_bottom = start_rect.bottom_left();
-  end_bound.edge_top = end_rect.origin();
-  end_bound.edge_bottom = end_rect.bottom_left();
-
-  if (params.anchor_rect == params.focus_rect) {
-    if (params.anchor_rect.x() || params.anchor_rect.y())
-      start_bound.type = end_bound.type = cc::SELECTION_BOUND_CENTER;
-  } else {
-    start_bound.type = params.anchor_dir == blink::WebTextDirectionRightToLeft
-                           ? cc::SELECTION_BOUND_LEFT
-                           : cc::SELECTION_BOUND_RIGHT;
-    end_bound.type = params.focus_dir == blink::WebTextDirectionRightToLeft
-                         ? cc::SELECTION_BOUND_RIGHT
-                         : cc::SELECTION_BOUND_LEFT;
-  }
-
-  selection_controller_->OnSelectionBoundsChanged(start_bound, end_bound);
+  NOTREACHED() << "Selection bounds should be routed through the compositor.";
 }
 
 void RenderWidgetHostViewAndroid::SetBackgroundOpaque(bool opaque) {
   RenderWidgetHostViewBase::SetBackgroundOpaque(opaque);
   host_->SetBackgroundOpaque(opaque);
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
@@ skipping 377 matching lines @@
   // web design, so text will be legible without zooming). Also disable
   // double tap and pinch for pages that prevent zooming in or out.
   bool has_mobile_viewport = HasMobileViewport(frame_metadata);
   bool has_fixed_page_scale = HasFixedPageScale(frame_metadata);
   gesture_provider_.SetDoubleTapSupportForPageEnabled(
       !has_fixed_page_scale && !has_mobile_viewport);
 
   if (!content_view_core_)
     return;
 
+  DCHECK(selection_controller_);
+  selection_controller_->OnSelectionBoundsChanged(
+      frame_metadata.selection_start, frame_metadata.selection_end);
+
   // All offsets and sizes are in CSS pixels.
   content_view_core_->UpdateFrameInfo(
       frame_metadata.root_scroll_offset,
       frame_metadata.page_scale_factor,
       gfx::Vector2dF(frame_metadata.min_page_scale_factor,
                      frame_metadata.max_page_scale_factor),
       frame_metadata.root_layer_size,
       frame_metadata.scrollable_viewport_size,
       frame_metadata.location_bar_offset,
       frame_metadata.location_bar_content_translation);
@@ skipping 101 matching lines @@
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate =
       overscroll_effect_ ? overscroll_effect_->Animate(frame_time) : false;
   if (selection_controller_)
     needs_animate |= selection_controller_->Animate(frame_time);
   return needs_animate;
 }
 
-void RenderWidgetHostViewAndroid::OnContentScrollingChange() {
-  if (selection_controller_)
-    selection_controller_->SetTemporarilyHidden(IsContentScrolling());
-}
-
-bool RenderWidgetHostViewAndroid::IsContentScrolling() const {
-  return touch_scrolling_ || potentially_active_fling_count_ > 0;
-}
-
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
@@ skipping 46 matching lines @@
 void RenderWidgetHostViewAndroid::GestureEventAck(
     const blink::WebGestureEvent& event,
     InputEventAckState ack_result) {
   // The overscroll effect requires an explicit release signal that may not be
   // sent from the renderer compositor.
   if (event.type == blink::WebInputEvent::GestureScrollEnd ||
       event.type == blink::WebInputEvent::GestureFlingStart) {
     DidOverscroll(DidOverscrollParams());
   }
 
-  switch (event.type) {
-    case blink::WebInputEvent::GestureScrollBegin:
-      touch_scrolling_ = true;
-      potentially_active_fling_count_ = 0;
-      OnContentScrollingChange();
-      break;
-    case blink::WebInputEvent::GestureScrollEnd:
-      touch_scrolling_ = false;
-      OnContentScrollingChange();
-      break;
-    case blink::WebInputEvent::GestureFlingStart:
-      touch_scrolling_ = false;
-      if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-        ++potentially_active_fling_count_;
-      OnContentScrollingChange();
-      break;
-    default:
-      break;
-  }
-
   if (content_view_core_)
     content_view_core_->OnGestureEventAck(event, ack_result);
 }
 
 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
   if (selection_controller_) {
     switch (input_event.type) {
       case blink::WebInputEvent::GestureLongPress:
         selection_controller_->OnLongPressEvent();
@@ skipping 141 matching lines @@
           gfx::ScaleVector2d(params.current_fling_velocity,
                              device_scale_factor),
           gfx::ScaleVector2d(
               params.causal_event_viewport_point.OffsetFromOrigin(),
               device_scale_factor))) {
     SetNeedsAnimate();
   }
 }
 
 void RenderWidgetHostViewAndroid::DidStopFlinging() {
-  if (potentially_active_fling_count_) {
-    --potentially_active_fling_count_;
-    OnContentScrollingChange();
-  }
-
   if (content_view_core_)
     content_view_core_->DidStopFlinging();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RemoveLayers();
   StopObservingRootWindow();
 
   bool resize = false;
@@ skipping 234 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content