[WIP] Add support for Android SuggestionSpans when editing text

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 <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 68 matching lines @@
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
 #include "third_party/WebKit/public/web/WebFrameWidget.h"
 #include "third_party/WebKit/public/web/WebInputMethodController.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
+#include "third_party/WebKit/public/web/WebTextSuggestionController.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 1486 matching lines @@
           WebVector<WebCompositionUnderline>(underlines),
           replacement_range.IsValid()
               ? WebRange(replacement_range.start(), replacement_range.length())
               : WebRange(),
           selection_start, selection_end)) {
     // If we failed to set the composition text, then we need to let the browser
     // process to cancel the input method's ongoing composition session, to make
     // sure we are in a consistent state.
     Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
-  UpdateCompositionInfo(false /* not an immediate request */);
+  updateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeCommitText(
     const base::string16& text,
     const std::vector<WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
     int relative_cursor_pos) {
   if (!ShouldHandleImeEvents())
     return;
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeCommitText(
         text, replacement_range, relative_cursor_pos);
     return;
   }
 #endif
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (auto* controller = GetInputMethodController()) {
     controller->commitText(
         WebString::fromUTF16(text),
         WebVector<WebCompositionUnderline>(underlines),
         replacement_range.IsValid()
             ? WebRange(replacement_range.start(), replacement_range.length())
             : WebRange(),
         relative_cursor_pos);
   }
   input_handler_->set_handling_input_event(false);
-  UpdateCompositionInfo(false /* not an immediate request */);
+  updateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
   if (!ShouldHandleImeEvents())
     return;
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
         keep_selection);
     return;
   }
 #endif
 
   if (!GetWebWidget())
     return;
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (auto* controller = GetInputMethodController()) {
     controller->finishComposingText(
         keep_selection ? WebInputMethodController::KeepSelection
                        : WebInputMethodController::DoNotKeepSelection);
   }
   input_handler_->set_handling_input_event(false);
-  UpdateCompositionInfo(false /* not an immediate request */);
+  updateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnDeviceScaleFactorChanged() {
   if (!compositor_)
     return;
   if (IsUseZoomForDSFEnabled())
     compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor());
   else
     compositor_->setDeviceScaleFactor(device_scale_factor_);
 }
@@ skipping 149 matching lines @@
 ui::TextInputType RenderWidget::GetTextInputType() {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return focused_pepper_plugin_->text_input_type();
 #endif
   if (auto* controller = GetInputMethodController())
     return ConvertWebTextInputType(controller->textInputType());
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
-void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
+void RenderWidget::updateCompositionInfo(bool immediate_request) {
   if (!monitor_composition_info_ && !immediate_request)
     return;  // Do not calculate composition info if not requested.
 
-  TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
+  TRACE_EVENT0("renderer", "RenderWidget::updateCompositionInfo");
   gfx::Range range;
   std::vector<gfx::Rect> character_bounds;
 
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
     // Composition information is only available on editable node.
     range = gfx::Range::InvalidRange();
   } else {
     GetCompositionRange(&range);
     GetCompositionCharacterBounds(&character_bounds);
   }
@@ skipping 37 matching lines @@
   UpdateSelectionBounds();
   UpdateTextInputStateInternal(false, true /* reply_to_request */);
 }
 #endif
 
 void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
                                                bool monitor_updates) {
   monitor_composition_info_ = monitor_updates;
   if (!immediate_request)
     return;
-  UpdateCompositionInfo(true /* immediate request */);
+  updateCompositionInfo(true /* immediate request */);
 }
 
 void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
   OnDeviceScaleFactorChanged();
   physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
 }
@@ skipping 116 matching lines @@
         selection_focus_rect_ != params.focus_rect) {
       selection_anchor_rect_ = params.anchor_rect;
       selection_focus_rect_ = params.focus_rect;
       GetWebWidget()->selectionTextDirection(params.focus_dir,
                                              params.anchor_dir);
       params.is_anchor_first = GetWebWidget()->isSelectionAnchorFirst();
       Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
     }
   }
 
-  UpdateCompositionInfo(false /* not an immediate request */);
+  updateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
   WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
   convertViewportToWindow(&new_size_in_window);
   if (size_.width() != new_size_in_window.width ||
       size_.height() != new_size_in_window.height) {
     size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
 
     if (resizing_mode_selector_->is_synchronous_mode()) {
@@ skipping 286 matching lines @@
     // browser side (https://crbug.com/669219).
     // If there is no WebFrameWidget, then there will be no
     // InputMethodControllers for a WebLocalFrame.
     return nullptr;
   }
   return static_cast<blink::WebFrameWidget*>(GetWebWidget())
       ->getActiveWebInputMethodController();
 }
 
 }  // namespace content