Chromium plumbing to use the selection root bounds.

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
@@ skipping 1481 matching lines @@
 
   // Check for whether we need to track swap buffers. We need to do that after
   // layout() because it may have switched us to accelerated compositing.
   if (is_accelerated_compositing_active_)
     using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputType();
+  UpdateSelectionRootBounds();
   UpdateSelectionBounds();
 
   // Suppress painting if nothing is dirty.  This has to be done after updating
   // animations running layout as these may generate further invalidations.
   if (!paint_aggregator_.HasPendingUpdate()) {
     TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
     InstrumentDidCancelFrame();
     return;
   }
 
@@ skipping 366 matching lines @@
 
   DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputType();
 #if defined(OS_ANDROID)
   UpdateTextInputState(false, true);
 #endif
+  UpdateSelectionRootBounds();
   UpdateSelectionBounds();
 }
 
 void RenderWidget::didBecomeReadyForAdditionalInput() {
   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
   FlushPendingInputEventAck();
 }
 
 void RenderWidget::DidCommitCompositorFrame() {
   FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
@@ skipping 482 matching lines @@
   DCHECK(!handling_ime_event_);
   handling_ime_event_ = true;
 }
 
 void RenderWidget::FinishHandlingImeEvent() {
   DCHECK(handling_ime_event_);
   handling_ime_event_ = false;
   // While handling an ime event, text input state and selection bounds updates
   // are ignored. These must explicitly be updated once finished handling the
   // ime event.
+  UpdateSelectionRootBounds();

[timvolodine, 2014/03/05 19:50:46]

Should this be android-only? Not sure if the selection issue applies to
platforms other than Android.

[mlamouri (slow - plz ping), 2014/03/10 15:56:45]

I was considering making it Android only but I then decided to keep it as
::UpdateSelectionBounds. I do not know what are the consumers of
::UpdateSelectionBounds so maybe that analogy was a bad idea? Also, it's not
clear to me how sending those IPC could have a bad performance impact. I would
love to hear more about this.

   UpdateSelectionBounds();
 #if defined(OS_ANDROID)
   UpdateTextInputState(false, false);
 #endif
 }
 
 void RenderWidget::UpdateTextInputType() {
   // On Windows, not only an IME but also an on-screen keyboard relies on the
   // latest TextInputType to optimize its layout and functionality. Thus
   // |input_method_is_active_| is no longer an appropriate condition to suppress
@@ skipping 99 matching lines @@
     selection_focus_rect_ = params.focus_rect;
     webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
     params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
     Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
   }
 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
   UpdateCompositionInfo(false);
 #endif
 }
 
+void RenderWidget::GetSelectionRootBounds(gfx::Rect* bounds) {
+  WebRect bounds_webrect;
+  webwidget_->selectionRootBounds(bounds_webrect);
+  *bounds = bounds_webrect;
+}
+
+void RenderWidget::UpdateSelectionRootBounds() {

[timvolodine, 2014/03/05 19:50:46]

I think we need a better name for "UpdateSelectionRootBounds" and the
corresponding IPC. The actual use cases are bounds for clipping
insertion/selection handles. So something like UpdateVisibleBoundsForIMEHandles
seems more appropriate. wdyt?

[mlamouri (slow - plz ping), 2014/03/10 15:56:45]

I would prefer to have the name reflecting what the function actually do and it
sends selection root bounds to the browser process. I would prefer to consider
the fact that this is used by Chrome Android to know whether the selection
handlers are visible as a detail and some other consumers could use it for other
things.

+  if (!webwidget_ || handling_ime_event_) {
+    return;
+  }
+
+  gfx::Rect bounds;
+  GetSelectionRootBounds(&bounds);
+  if (selection_root_rect_ != bounds) {
+    selection_root_rect_ = bounds;
+    Send(new ViewHostMsg_SelectionRootBoundsChanged(routing_id_, bounds));
+  }
+}
+
 // Check blink::WebTextInputType and ui::TextInputType is kept in sync.
 COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
                int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
 COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
                int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
 COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
                int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
 COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
                int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
 COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
@@ skipping 265 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content