Clean up names and remove unnecessary parameter

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 912 matching lines @@
 void RenderWidget::UpdateVisualState() {
   GetWebWidget()->updateAllLifecyclePhases();
 }
 
 void RenderWidget::WillBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   // The UpdateTextInputState can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
-  UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
+  UpdateTextInputState();
   UpdateSelectionBounds();
 
   for (auto& observer : render_frame_proxies_)
     observer.WillBeginCompositorFrame();
 }
 
 std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
     std::unique_ptr<cc::CopyOutputRequest> request) {
   return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
       routing_id_, std::move(request));
@@ skipping 71 matching lines @@
   }
 }
 
 void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
   // Nothing to do here. RenderWidget created the |input_handler| and will take
   // ownership of it. We just verify here that we don't already have an input
   // handler.
   DCHECK(!input_handler_);
 }
 
-void RenderWidget::UpdateTextInputState(ShowIme show_ime,
-                                        ChangeSource change_source) {
+void RenderWidget::ShowVirtualKeyboard() {

[aelias_OOO_until_Jul13, 2017/01/10 01:49:55]

Could you avoid introducing the capitalized one and just use
showVirtualKeyboard?  I think additional calls to FocusChangeComplete() should
be harmless.

[Changwan Ryu, 2017/01/12 04:53:09]

As we talked offline,
RenderWidget::ShowVirtualKeyboard() implements
RenderWidgetInputHandlerDelegate::ShowVirtualKeyboard() while
RenderWidget::showVirtualKeyboard() implements
WebWidgetClient::showVirtualKeyboard(), so I cannot unify them.

+  UpdateTextInputStateInternal(true, false);
+}
+
+void RenderWidget::UpdateTextInputState() {
+  UpdateTextInputStateInternal(false, false);
+}
+
+void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
+                                                bool reply_to_request) {
   TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
+
   if (ime_event_guard_) {
-    // show_ime should still be effective even if it was set inside the IME
+    DCHECK(!reply_to_request);
+    // show_virtual_keyboard should still be effective even if it was set inside
+    // the IME
     // event guard.
-    if (show_ime == ShowIme::IF_NEEDED) {
-      ime_event_guard_->set_show_ime(true);
-    }
+    if (show_virtual_keyboard)
+      ime_event_guard_->set_show_virtual_keyboard(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 (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 ||
+  if (show_virtual_keyboard || reply_to_request ||
       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(OS_ANDROID) || defined(USE_AURA)
-    params.is_non_ime_change = (change_source == ChangeSource::FROM_NON_IME);
-#endif
+    // TODO(changwan): change instances of show_ime_if_needed to
+    // show_virtual_keyboard.
+    params.show_ime_if_needed = show_virtual_keyboard;
+    params.reply_to_request = reply_to_request;
     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 640 matching lines @@
       ConvertWindowPointToViewport(client_point), screen_point, op);
 }
 
 void RenderWidget::OnDragSourceSystemDragEnded() {
   if (!GetWebWidget())
     return;
 
   static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceSystemDragEnded();
 }
 
-void RenderWidget::showImeIfNeeded() {
-#if defined(OS_ANDROID) || defined(USE_AURA)
-  UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
-#endif
+void RenderWidget::showVirtualKeyboard() {
+  ShowVirtualKeyboard();
 
 // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
 // virtual keyboard.
 #if !defined(OS_ANDROID)
   FocusChangeComplete();
 #endif
 }
 
 ui::TextInputType RenderWidget::GetTextInputType() {
 #if BUILDFLAG(ENABLE_PLUGINS)
@@ skipping 51 matching lines @@
     rect->y *= GetOriginalDeviceScaleFactor();
     rect->width *= GetOriginalDeviceScaleFactor();
     rect->height *= GetOriginalDeviceScaleFactor();
   }
 }
 
 #if defined(OS_ANDROID)
 void RenderWidget::OnRequestTextInputStateUpdate() {
   DCHECK(!ime_event_guard_);
   UpdateSelectionBounds();
-  UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_IME);
+  UpdateTextInputStateInternal(false, true /* reply_to_request */);
 }
 #endif
 
 void RenderWidget::OnRequestCompositionUpdate(bool immediate_request,
                                               bool monitor_request) {
   monitor_composition_info_ = monitor_request;
   if (!immediate_request)
     return;
   UpdateCompositionInfo(true /* immediate request */);
 }
@@ skipping 66 matching lines @@
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
 }
 
 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
-    // so that ReplicaInputConnection can make changes to its Editable model.
-    // Therefore, we want to mark this text state update as 'from IME' only
-    // when all the nested events are all originating from IME.
-    ime_event_guard_->set_from_ime(
-        ime_event_guard_->from_ime() && guard->from_ime());
-#endif
+    DCHECK(!ime_event_guard_->reply_to_request());
     return;
   }
   ime_event_guard_ = nullptr;
 
   // 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.
   UpdateSelectionBounds();
 #if defined(OS_ANDROID)
-  UpdateTextInputState(
-      guard->show_ime() ? ShowIme::IF_NEEDED : ShowIme::HIDE_IME,
-      guard->from_ime() ? ChangeSource::FROM_IME : ChangeSource::FROM_NON_IME);
+  if (guard->show_virtual_keyboard())
+    ShowVirtualKeyboard();
+  else
+    UpdateTextInputState();
 #endif
 }
 
 void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     // TODO(kinaba) http://crbug.com/101101
     // Current Pepper IME API does not handle selection bounds. So we simply
     // use the caret position as an empty range for now. It will be updated
     // after Pepper API equips features related to surrounding text retrieval.
@@ skipping 193 matching lines @@
 }
 #endif
 
 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);
+    ShowVirtualKeyboard();
   } else if (event.type == WebInputEvent::GestureLongPress) {
     DCHECK(GetWebWidget());
     blink::WebInputMethodController* controller = GetInputMethodController();
     if (!controller || controller->textInputInfo().value.isEmpty())
-      UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
+      UpdateTextInputState();
     else
-      UpdateTextInputState(ShowIme::IF_NEEDED, ChangeSource::FROM_NON_IME);
+      ShowVirtualKeyboard();
   }
 // 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::WebInputMethodController* controller = GetInputMethodController();
@@ skipping 129 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