[reland, refactor] - Move textInputInfo() and textInputType() from WebWidget to WebInputMethodContr…

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 643 matching lines @@
     message->set_routing_id(routing_id_);
 
   return RenderThread::Get()->Send(message);
 }
 
 void RenderWidget::SendOrCrash(IPC::Message* message) {
   bool result = Send(message);
   CHECK(closing_ || result) << "Failed to send message";
 }
 
+bool RenderWidget::ShouldHandleImeEvents() const {
+  return GetWebWidget()->isWebFrameWidget() && has_focus_;
+}
+
 void RenderWidget::SetWindowRectSynchronously(
     const gfx::Rect& new_window_rect) {
   ResizeParams params;
   params.screen_info = screen_info_;
   params.new_size = new_window_rect.size();
   params.physical_backing_size =
       gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_);
   params.visible_viewport_size = new_window_rect.size();
   params.is_fullscreen_granted = is_fullscreen_granted_;
   params.display_mode = display_mode_;
@@ skipping 353 matching lines @@
       ime_event_guard_->set_show_ime(true);
     }
     return;
   }
 
   ui::TextInputType new_type = GetTextInputType();
   if (IsDateTimeInput(new_type))
     return;  // Not considered as a text input field in WebKit/Chromium.
 
   blink::WebTextInputInfo new_info;
-  if (GetWebWidget())
-    new_info = GetWebWidget()->textInputInfo();
+  if (auto* controller = GetInputMethodController())
+    new_info = controller->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 ||
       change_source == ChangeSource::FROM_IME ||
       text_input_type_ != new_type || text_input_mode_ != new_mode ||
@@ skipping 448 matching lines @@
       window_screen_rect_ = rect;
       view_screen_rect_ = rect;
   }
 }
 
 void RenderWidget::OnImeSetComposition(
     const base::string16& text,
     const std::vector<WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
     int selection_start, int selection_end) {
+  if (!ShouldHandleImeEvents())
+    return;
+
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     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()));
@@ skipping 11 matching lines @@
     // 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 */);
 }
 
 void RenderWidget::OnImeCommitText(const base::string16& text,
                                    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
   if (replacement_range.IsValid()) {
     GetWebWidget()->applyReplacementRange(
         WebRange(replacement_range.start(), replacement_range.length()));
   }
 
   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 (!ShouldHandleImeEvents())
+    return;
+
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
         keep_selection);
     return;
   }
 #endif
 
   if (!GetWebWidget())
     return;
@@ skipping 151 matching lines @@
 #if !defined(OS_ANDROID)
   FocusChangeComplete();
 #endif
 }
 
 ui::TextInputType RenderWidget::GetTextInputType() {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_)
     return focused_pepper_plugin_->text_input_type();
 #endif
-  if (GetWebWidget())
-    return ConvertWebTextInputType(GetWebWidget()->textInputType());
+  if (auto* controller = GetInputMethodController())
+    return ConvertWebTextInputType(controller->textInputType());
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
 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");
   gfx::Range range;
   std::vector<gfx::Rect> character_bounds;
@@ skipping 360 matching lines @@
 void RenderWidget::didHandleGestureEvent(
     const WebGestureEvent& event,
     bool event_cancelled) {
 #if defined(OS_ANDROID) || defined(USE_AURA)
   if (event_cancelled)
     return;
   if (event.type == WebInputEvent::GestureTap) {
     UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
   } else if (event.type == WebInputEvent::GestureLongPress) {
     DCHECK(GetWebWidget());
-    if (GetWebWidget()->textInputInfo().value.isEmpty())
+    blink::WebInputMethodController* controller = GetInputMethodController();

[wjmaclean, 2017/01/05 21:24:57]

Why do you explicitly declare the type here, but use auto* in earlier places in
the file? I personally think this is clearer, as the reader doesn't need to look
up the type returned by GetInputMethodController(), but in either case it would
be good to be consistent.

[EhsanK, 2017/01/05 21:46:43]

This format goes back to this CL:
https://codereview.chromium.org/2333813002/ (Please see comments by creis@ and
dglazkov@). 

In short, using auto* makes it more concise. But creis@ pointed out that it is
better to use the exact type instead and only use the auto* when inside
conditionals. I could change all to auto* of course if everybody is OK with it.

[Charlie Reis, 2017/01/05 22:25:03]

Yeah, auto wasn't buying much here in terms of space, and it was more useful to
know the type (as noted
inhttps://codereview.chromium.org/2333813002/diff/490001/content/renderer/render_widget.cc#newcode1401).
 

I'm ok either way with the other uses of auto-- I tend to like having the
explicit type, but I can see how they save space.

+    if (!controller || controller->textInputInfo().value.isEmpty())
       UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
     else
       UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
   }
 // TODO(ananta): Piggyback off existing IPCs to communicate this information,
 // crbug/420130.
 #if defined(OS_WIN)
   if (event.type != blink::WebGestureEvent::GestureTap)
     return;
 
   // TODO(estade): hit test the event against focused node to make sure
   // the tap actually hit the focused node.
-  blink::WebTextInputType text_input_type = GetWebWidget()->textInputType();
+  blink::WebInputMethodController* controller = GetInputMethodController();
+  blink::WebTextInputType text_input_type =
+      controller ? controller->textInputType() : blink::WebTextInputTypeNone;
 
   Send(new ViewHostMsg_FocusedNodeTouched(
       routing_id_, text_input_type != blink::WebTextInputTypeNone));
 #endif
 #endif
 }
 
 void RenderWidget::didOverscroll(
     const blink::WebFloatSize& overscrollDelta,
     const blink::WebFloatSize& accumulatedOverscroll,
@@ skipping 117 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