Remove deprecated ReplicaInputConnection

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 354 matching lines @@
       for_oopif_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       text_input_flags_(0),
       can_compose_inline_(true),
       composition_range_(gfx::Range::InvalidRange()),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.device_scale_factor),
-#if defined(OS_ANDROID)
-      text_field_is_dirty_(false),
-#endif
       monitor_composition_info_(false),
       popup_origin_scale_for_emulation_(0.f),
       frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       has_host_context_menu_location_(false),
       has_focus_(false),
 #if defined(OS_MACOSX)
       text_input_client_observer_(new TextInputClientObserver(this)),
 #endif
       focused_pepper_plugin_(nullptr) {
   DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   device_color_profile_.push_back('0');
-#if defined(OS_ANDROID)
-  text_input_info_history_.push_back(blink::WebTextInputInfo());
-#endif
 
   // In tests there may not be a RenderThreadImpl.
   if (RenderThreadImpl::current()) {
     render_widget_scheduling_state_ = RenderThreadImpl::current()
                                           ->GetRendererScheduler()
                                           ->NewRenderWidgetSchedulingState();
     render_widget_scheduling_state_->SetHidden(is_hidden_);
   }
 }
 
@@ skipping 222 matching lines @@
                         OnRequestCompositionUpdate)
     IPC_MESSAGE_HANDLER(ViewMsg_HandleCompositorProto, OnHandleCompositorProto)
     IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
     IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
     IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
     IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
     IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
     IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
                         OnDragSourceSystemDragEnded)
 #if defined(OS_ANDROID)
-    IPC_MESSAGE_HANDLER(InputMsg_ImeEventAck, OnImeEventAck)
     IPC_MESSAGE_HANDLER(InputMsg_RequestTextInputStateUpdate,
                         OnRequestTextInputStateUpdate)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool RenderWidget::Send(IPC::Message* message) {
   // Don't send any messages after the browser has told us to close, and filter
@@ skipping 393 matching lines @@
   if (GetWebWidget())
     new_info = GetWebWidget()->textInputInfo();
   const ui::TextInputMode new_mode =
       ConvertWebTextInputMode(new_info.inputMode);
 
   bool new_can_compose_inline = CanComposeInline();
 
   // Only sends text input params if they are changed or if the ime should be
   // shown.
   if (show_ime == ShowIme::IF_NEEDED ||
-      (IsUsingImeThread() && change_source == ChangeSource::FROM_IME) ||
-      (text_input_type_ != new_type || text_input_mode_ != new_mode ||
-       text_input_info_ != new_info ||
-       can_compose_inline_ != new_can_compose_inline)
-#if defined(OS_ANDROID)
-      || text_field_is_dirty_
-#endif
-      ) {
+      change_source == ChangeSource::FROM_IME ||
+      text_input_type_ != new_type || text_input_mode_ != new_mode ||
+      text_input_info_ != new_info ||
+      can_compose_inline_ != new_can_compose_inline) {
     TextInputState params;
     params.type = new_type;
     params.mode = new_mode;
     params.flags = new_info.flags;
     params.value = new_info.value.utf8();
     params.selection_start = new_info.selectionStart;
     params.selection_end = new_info.selectionEnd;
     params.composition_start = new_info.compositionStart;
     params.composition_end = new_info.compositionEnd;
     params.can_compose_inline = new_can_compose_inline;
     params.show_ime_if_needed = (show_ime == ShowIme::IF_NEEDED);
-#if defined(USE_AURA)
-    params.is_non_ime_change = true;
-#endif
-#if defined(OS_ANDROID)
-    params.is_non_ime_change =
-        (change_source == ChangeSource::FROM_NON_IME) || text_field_is_dirty_;
-    if (params.is_non_ime_change)
-      OnImeEventSentForAck(new_info);
-    text_field_is_dirty_ = false;
+#if defined(OS_ANDROID) || defined(USE_AURA)
+    params.is_non_ime_change = (change_source == ChangeSource::FROM_NON_IME);
 #endif
     Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
 
     text_input_info_ = new_info;
     text_input_type_ = new_type;
     text_input_mode_ = new_mode;
     can_compose_inline_ = new_can_compose_inline;
     text_input_flags_ = new_info.flags;
   }
 }
@@ skipping 435 matching lines @@
     focused_pepper_plugin_->render_frame()->OnImeSetComposition(
         text, underlines, selection_start, selection_end);
     return;
   }
 #endif
   if (replacement_range.IsValid()) {
     GetWebWidget()->applyReplacementRange(
         WebRange(replacement_range.start(), replacement_range.length()));
   }
 
-  if (!ShouldHandleImeEvent())
+  if (!GetWebWidget())
     return;
   ImeEventGuard guard(this);
   blink::WebInputMethodController* controller = GetInputMethodController();
   DCHECK(controller);
   if (!controller ||
       !controller->setComposition(
           text, WebVector<WebCompositionUnderline>(underlines), 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
@@ skipping 11 matching lines @@
     focused_pepper_plugin_->render_frame()->OnImeCommitText(
         text, replacement_range, relative_cursor_pos);
     return;
   }
 #endif
   if (replacement_range.IsValid()) {
     GetWebWidget()->applyReplacementRange(
         WebRange(replacement_range.start(), replacement_range.length()));
   }
 
-  if (!ShouldHandleImeEvent())
+  if (!GetWebWidget())
     return;
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (auto* controller = GetInputMethodController())
     controller->commitText(text, relative_cursor_pos);
   input_handler_->set_handling_input_event(false);
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
         keep_selection);
     return;
   }
 #endif
 
-  if (!ShouldHandleImeEvent())
+  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 */);
@@ skipping 197 matching lines @@
 void RenderWidget::convertWindowToViewport(blink::WebFloatRect* rect) {
   if (IsUseZoomForDSFEnabled()) {
     rect->x *= GetOriginalDeviceScaleFactor();
     rect->y *= GetOriginalDeviceScaleFactor();
     rect->width *= GetOriginalDeviceScaleFactor();
     rect->height *= GetOriginalDeviceScaleFactor();
   }
 }
 
 #if defined(OS_ANDROID)
-void RenderWidget::OnImeEventSentForAck(const blink::WebTextInputInfo& info) {
-  text_input_info_history_.push_back(info);
-}
-
-void RenderWidget::OnImeEventAck() {
-  DCHECK_GE(text_input_info_history_.size(), 1u);
-  text_input_info_history_.pop_front();
-}
-
 void RenderWidget::OnRequestTextInputStateUpdate() {
   DCHECK(!ime_event_guard_);
   UpdateSelectionBounds();
   UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_IME);
 }
 #endif
 
 void RenderWidget::OnRequestCompositionUpdate(bool immediate_request,
                                               bool monitor_request) {
   monitor_composition_info_ = monitor_request;
   if (!immediate_request)
     return;
   UpdateCompositionInfo(true /* immediate request */);
 }
 
-bool RenderWidget::ShouldHandleImeEvent() {
-#if defined(OS_ANDROID)
-  if (!GetWebWidget())
-    return false;
-  if (IsUsingImeThread())
-    return true;
-
-  // We cannot handle IME events if there is any chance that the event we are
-  // receiving here from the browser is based on the state that is different
-  // from our current one as indicated by |text_input_info_|.
-  // The states the browser might be in are:
-  // text_input_info_history_[0] - current state ack'd by browser
-  // text_input_info_history_[1...N] - pending state changes
-  for (size_t i = 0u; i < text_input_info_history_.size() - 1u; ++i) {
-    if (text_input_info_history_[i] != text_input_info_)
-      return false;
-  }
-  return true;
-#else
-  return !!GetWebWidget();
-#endif
-}
-
 void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
   device_scale_factor_ = device_scale_factor;
 
   OnDeviceScaleFactorChanged();
   ScheduleComposite();
 
   physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
@@ skipping 48 matching lines @@
 }
 
 void RenderWidget::set_next_paint_is_resize_ack() {
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
 }
 
 void RenderWidget::set_next_paint_is_repaint_ack() {
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
 }
 
-bool RenderWidget::IsUsingImeThread() {
-#if defined(OS_ANDROID)
-  return base::FeatureList::IsEnabled(features::kImeThread);
-#else
-  return false;
-#endif
-}
-
 void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
   if (!ime_event_guard_)
     ime_event_guard_ = guard;
 }
 
 void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
   if (ime_event_guard_ != guard) {
 #if defined(OS_ANDROID)
     // In case a from-IME event (e.g. touch) ends up in not-from-IME event
     // (e.g. long press gesture), we want to treat it as not-from-IME event
@@ skipping 288 matching lines @@
   // Ignore setTouchAction calls that result from synthetic touch events (eg.
   // when blink is emulating touch with mouse).
   if (input_handler_->handling_event_type() != WebInputEvent::TouchStart)
     return;
 
    content::TouchAction content_touch_action =
        static_cast<content::TouchAction>(web_touch_action);
   Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
 }
 
-void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
-#if defined(OS_ANDROID)
-  if (!IsUsingImeThread())
-    text_field_is_dirty_ = true;
-#endif
-}
-
 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.AddObserver(proxy);
 }
 
 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.RemoveObserver(proxy);
 }
 
 void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
   render_frames_.AddObserver(frame);
@@ skipping 57 matching lines @@
 blink::WebInputMethodController* RenderWidget::GetInputMethodController()
     const {
   // TODO(ekaramad): Remove this CHECK when GetWebWidget() is
   // always a WebFrameWidget.
   CHECK(GetWebWidget()->isWebFrameWidget());
   return static_cast<blink::WebFrameWidget*>(GetWebWidget())
       ->getActiveWebInputMethodController();
 }
 
 }  // namespace content