Introduce WebInputMethodController to blink

third_party/WebKit/Source/web/tests/WebViewTest.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 64 matching lines @@
 #include "public/web/WebCache.h"
 #include "public/web/WebDateTimeChooserCompletion.h"
 #include "public/web/WebDeviceEmulationParams.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebElement.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebFrameClient.h"
 #include "public/web/WebFrameContentDumper.h"
 #include "public/web/WebHitTestResult.h"
 #include "public/web/WebInputEvent.h"
+#include "public/web/WebInputMethodController.h"
 #include "public/web/WebScriptSource.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebTreeScopeType.h"
 #include "public/web/WebViewClient.h"
 #include "public/web/WebWidget.h"
 #include "public/web/WebWidgetClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "web/WebInputMethodControllerImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 #if OS(MACOSX)
 #include "public/web/mac/WebSubstringUtil.h"
 #endif
@@ skipping 126 matching lines @@
 
     void testAutoResize(const WebSize& minAutoResize, const WebSize& maxAutoResize,
                         const std::string& pageWidth, const std::string& pageHeight,
                         int expectedWidth, int expectedHeight,
                         HorizontalScrollbarState expectedHorizontalState, VerticalScrollbarState expectedVerticalState);
 
     void testTextInputType(WebTextInputType expectedType, const std::string& htmlFile);
     void testInputMode(const WebString& expectedInputMode, const std::string& htmlFile);
     bool tapElement(WebInputEvent::Type, Element*);
     bool tapElementById(WebInputEvent::Type, const WebString& id);
+    WebInputMethodController* inputMethodController() const;
 
     std::string m_baseURL;
     FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 static bool hitTestIsContentEditable(WebView* view, int x, int y)
 {
     WebPoint hitPoint(x, y);
     WebHitTestResult hitTestResult = view->hitTestResultAt(hitPoint);
     return hitTestResult.isContentEditable();
@@ skipping 573 matching lines @@
 TEST_F(WebViewTest, FinishComposingTextCursorPositionChange)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
     // Set up a composition that needs to be committed.
     std::string compositionText("hello");
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
 
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(0, info.compositionStart);
     EXPECT_EQ(5, info.compositionEnd);
 
-    webView->finishComposingText(WebWidget::KeepSelection);
+    inputMethodController()->finishComposingText(WebInputMethodController::KeepSelection);
     info = webView->textInputInfo();
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
     info = webView->textInputInfo();
     EXPECT_EQ("helhellolo", std::string(info.value.utf8().data()));
     EXPECT_EQ(6, info.selectionStart);
     EXPECT_EQ(6, info.selectionEnd);
     EXPECT_EQ(3, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
-    webView->finishComposingText(WebWidget::DoNotKeepSelection);
+    inputMethodController()->finishComposingText(WebInputMethodController::DoNotKeepSelection);
     info = webView->textInputInfo();
     EXPECT_EQ(8, info.selectionStart);
     EXPECT_EQ(8, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, SetCompositionForNewCaretPositions)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
-    webView->commitText("hello", 0);
-    webView->commitText("world", -5);
+    inputMethodController()->commitText("hello", 0);
+    inputMethodController()->commitText("world", -5);
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("helloworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
     // Set up a composition that needs to be committed.
     std::string compositionText("ABC");
 
     // Caret is on the left of composing text.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0, 0);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0, 0);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret is on the right of composing text.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(8, info.selectionStart);
     EXPECT_EQ(8, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret is between composing text and left boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -2, -2);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -2, -2);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret is between composing text and right boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 5, 5);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 5, 5);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(10, info.selectionStart);
     EXPECT_EQ(10, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret is on the left boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -5, -5);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -5, -5);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret is on the right boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 8, 8);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 8, 8);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(13, info.selectionStart);
     EXPECT_EQ(13, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret exceeds the left boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -100, -100);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -100, -100);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 
     // Caret exceeds the right boundary.
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 100, 100);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 100, 100);
     info = webView->textInputInfo();
     EXPECT_EQ("helloABCworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(13, info.selectionStart);
     EXPECT_EQ(13, info.selectionEnd);
     EXPECT_EQ(5, info.compositionStart);
     EXPECT_EQ(8, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, SetCompositionWithEmptyText)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
-    webView->commitText("hello", 0);
+    inputMethodController()->commitText("hello", 0);
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
 
-    webView->setComposition(WebString::fromUTF8(""), emptyUnderlines, 0, 0);
+    inputMethodController()->setComposition(WebString::fromUTF8(""), emptyUnderlines, 0, 0);
     info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
-    webView->setComposition(WebString::fromUTF8(""), emptyUnderlines, -2, -2);
+    inputMethodController()->setComposition(WebString::fromUTF8(""), emptyUnderlines, -2, -2);
     info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, CommitTextForNewCaretPositions)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
     // Caret is on the left of composing text.
-    webView->commitText("ab", -2);
+    inputMethodController()->commitText("ab", -2);
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("ab", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Caret is on the right of composing text.
-    webView->commitText("c", 1);
+    inputMethodController()->commitText("c", 1);
     info = webView->textInputInfo();
     EXPECT_EQ("cab", std::string(info.value.utf8().data()));
     EXPECT_EQ(2, info.selectionStart);
     EXPECT_EQ(2, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Caret is on the left boundary.
-    webView->commitText("def", -5);
+    inputMethodController()->commitText("def", -5);
     info = webView->textInputInfo();
     EXPECT_EQ("cadefb", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Caret is on the right boundary.
-    webView->commitText("g", 6);
+    inputMethodController()->commitText("g", 6);
     info = webView->textInputInfo();
     EXPECT_EQ("gcadefb", std::string(info.value.utf8().data()));
     EXPECT_EQ(7, info.selectionStart);
     EXPECT_EQ(7, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Caret exceeds the left boundary.
-    webView->commitText("hi", -100);
+    inputMethodController()->commitText("hi", -100);
     info = webView->textInputInfo();
     EXPECT_EQ("gcadefbhi", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Caret exceeds the right boundary.
-    webView->commitText("jk", 100);
+    inputMethodController()->commitText("jk", 100);
     info = webView->textInputInfo();
     EXPECT_EQ("jkgcadefbhi", std::string(info.value.utf8().data()));
     EXPECT_EQ(11, info.selectionStart);
     EXPECT_EQ(11, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, CommitTextWhileComposing)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
-    webView->setComposition(WebString::fromUTF8("abc"), emptyUnderlines, 0, 0);
+    inputMethodController()->setComposition(WebString::fromUTF8("abc"), emptyUnderlines, 0, 0);
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("abc", std::string(info.value.utf8().data()));
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ(0, info.selectionEnd);
     EXPECT_EQ(0, info.compositionStart);
     EXPECT_EQ(3, info.compositionEnd);
 
     // Deletes ongoing composition, inserts the specified text and moves the
     // caret.
-    webView->commitText("hello", -2);
+    inputMethodController()->commitText("hello", -2);
     info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
-    webView->setComposition(WebString::fromUTF8("abc"), emptyUnderlines, 0, 0);
+    inputMethodController()->setComposition(WebString::fromUTF8("abc"), emptyUnderlines, 0, 0);
     info = webView->textInputInfo();
     EXPECT_EQ("helabclo", std::string(info.value.utf8().data()));
     EXPECT_EQ(3, info.selectionStart);
     EXPECT_EQ(3, info.selectionEnd);
     EXPECT_EQ(3, info.compositionStart);
     EXPECT_EQ(6, info.compositionEnd);
 
     // Deletes ongoing composition and moves the caret.
-    webView->commitText("", 2);
+    inputMethodController()->commitText("", 2);
     info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Inserts the specified text and moves the caret.
-    webView->commitText("world", -5);
+    inputMethodController()->commitText("world", -5);
     info = webView->textInputInfo();
     EXPECT_EQ("helloworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     // Only moves the caret.
-    webView->commitText("", 5);
+    inputMethodController()->commitText("", 5);
     info = webView->textInputInfo();
     EXPECT_EQ("helloworld", std::string(info.value.utf8().data()));
     EXPECT_EQ(10, info.selectionStart);
     EXPECT_EQ(10, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, FinishCompositionDoesNotRevealSelection)
 {
@@ skipping 13 matching lines @@
     Element* element = static_cast<Element*>(webView->mainFrame()->document().getElementById("btn"));
     element->scrollIntoView();
     float offsetHeight = webView->mainFrame()->scrollOffset().height;
     EXPECT_EQ(0, webView->mainFrame()->scrollOffset().width);
     EXPECT_LT(0, offsetHeight);
 
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
 
     // Verify that the input field is not scrolled back into the viewport.
-    webView->finishComposingText(WebWidget::DoNotKeepSelection);
+    inputMethodController()->finishComposingText(WebInputMethodController::DoNotKeepSelection);
     EXPECT_EQ(0, webView->mainFrame()->scrollOffset().width);
     EXPECT_EQ(offsetHeight, webView->mainFrame()->scrollOffset().height);
 }
 
 TEST_F(WebViewTest, InsertNewLinePlacementAfterFinishComposingText)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("text_area_populated.html"));
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "text_area_populated.html");
     webView->setInitialFocus(false);
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
 
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setEditableSelectionOffsets(4, 4);
     frame->setCompositionFromExistingText(8, 12, emptyUnderlines);
 
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
     EXPECT_EQ(4, info.selectionStart);
     EXPECT_EQ(4, info.selectionEnd);
     EXPECT_EQ(8, info.compositionStart);
     EXPECT_EQ(12, info.compositionEnd);
 
-    webView->finishComposingText(WebWidget::KeepSelection);
+    inputMethodController()->finishComposingText(WebInputMethodController::KeepSelection);
     info = webView->textInputInfo();
     EXPECT_EQ(4, info.selectionStart);
     EXPECT_EQ(4, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 
     std::string compositionText("\n");
-    webView->commitText(WebString::fromUTF8(compositionText.c_str()), 0);
+    inputMethodController()->commitText(WebString::fromUTF8(compositionText.c_str()), 0);
     info = webView->textInputInfo();
     EXPECT_EQ(5, info.selectionStart);
     EXPECT_EQ(5, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
     EXPECT_EQ("0123\n456789abcdefghijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
 }
 
 TEST_F(WebViewTest, ExtendSelectionAndDelete)
 {
@@ skipping 39 matching lines @@
 TEST_F(WebViewTest, SetCompositionFromExistingTextInTextArea)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("text_area_populated.html"));
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "text_area_populated.html");
     webView->setInitialFocus(false);
     WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
     underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setEditableSelectionOffsets(27, 27);
     std::string newLineText("\n");
-    webView->commitText(WebString::fromUTF8(newLineText.c_str()), 0);
+    inputMethodController()->commitText(WebString::fromUTF8(newLineText.c_str()), 0);
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("0123456789abcdefghijklmnopq\nrstuvwxyz", std::string(info.value.utf8().data()));
 
     frame->setEditableSelectionOffsets(31, 31);
     frame->setCompositionFromExistingText(30, 34, underlines);
     info = webView->textInputInfo();
     EXPECT_EQ("0123456789abcdefghijklmnopq\nrstuvwxyz", std::string(info.value.utf8().data()));
     EXPECT_EQ(31, info.selectionStart);
     EXPECT_EQ(31, info.selectionEnd);
     EXPECT_EQ(30, info.compositionStart);
     EXPECT_EQ(34, info.compositionEnd);
 
     std::string compositionText("yolo");
-    webView->commitText(WebString::fromUTF8(compositionText.c_str()), 0);
+    inputMethodController()->commitText(WebString::fromUTF8(compositionText.c_str()), 0);
     info = webView->textInputInfo();
     EXPECT_EQ("0123456789abcdefghijklmnopq\nrsyoloxyz", std::string(info.value.utf8().data()));
     EXPECT_EQ(34, info.selectionStart);
     EXPECT_EQ(34, info.selectionEnd);
     EXPECT_EQ(-1, info.compositionStart);
     EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_F(WebViewTest, SetCompositionFromExistingTextInRichText)
 {
@@ skipping 13 matching lines @@
 TEST_F(WebViewTest, SetEditableSelectionOffsetsKeepsComposition)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     webView->setInitialFocus(false);
 
     std::string compositionTextFirst("hello ");
     std::string compositionTextSecond("world");
     WebVector<WebCompositionUnderline> emptyUnderlines;
 
-    webView->commitText(WebString::fromUTF8(compositionTextFirst.c_str()), 0);
-    webView->setComposition(WebString::fromUTF8(compositionTextSecond.c_str()), emptyUnderlines, 5, 5);
+    inputMethodController()->commitText(WebString::fromUTF8(compositionTextFirst.c_str()), 0);
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionTextSecond.c_str()), emptyUnderlines, 5, 5);
 
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ("hello world", std::string(info.value.utf8().data()));
     EXPECT_EQ(11, info.selectionStart);
     EXPECT_EQ(11, info.selectionEnd);
     EXPECT_EQ(6, info.compositionStart);
     EXPECT_EQ(11, info.compositionEnd);
 
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setEditableSelectionOffsets(6, 6);
@@ skipping 421 matching lines @@
     return true;
 }
 
 bool WebViewTest::tapElementById(WebInputEvent::Type type, const WebString& id)
 {
     DCHECK(m_webViewHelper.webView());
     Element* element = static_cast<Element*>(m_webViewHelper.webView()->mainFrame()->document().getElementById(id));
     return tapElement(type, element);
 }
 
+WebInputMethodController* WebViewTest::inputMethodController() const

[lfg, 2016/09/21 16:56:14]

Can you make this function take a frame as an argument? Otherwise it seems like
there's always only a single inputMethodController, which is not true in
general.

[EhsanK, 2016/09/26 20:54:29]

This is supposed to return the controller for the focused frame inside the
widget. In that case I would have to get the focused frame and check the local
root each time, which is the currently implemented code for WebViewFrameWidget.
How about renaming this to something more clear and leaving comments?

[lfg, 2016/09/29 14:16:41]

I don't think I understand this.

Why can't you just return
WebLocalFrameImpl::fromFrame(frame)->frameWidget()->getActiveWebInputMethodController()?

[EhsanK, 2016/11/01 15:46:04]

Removed the method, and now, similar to your suggestion, I am using the
frameWidget() of the corresponding frame to get WebInputMethodController().

+{
+    return m_webViewHelper.webView()->mainFrameImpl()->frameWidget()->getActiveWebInputMethodController();
+}
+
 TEST_F(WebViewTest, DetectContentAroundPosition)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("content_listeners.html"));
 
     ContentDetectorClient client;
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "content_listeners.html", true, 0, &client);
     webView->resize(WebSize(500, 300));
     webView->updateAllLifecyclePhases();
     runPendingTasks();
 
@@ skipping 580 matching lines @@
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "composition_not_cancelled_by_backspace.html");
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setAutofillClient(&client);
     webView->setInitialFocus(false);
 
     // Test both input elements.
     for (int i = 0; i < 2; ++i) {
         // Select composition and do sanity check.
         WebVector<WebCompositionUnderline> emptyUnderlines;
         frame->setEditableSelectionOffsets(6, 6);
-        EXPECT_TRUE(webView->setComposition("fghij", emptyUnderlines, 0, 5));
+        EXPECT_TRUE(inputMethodController()->setComposition("fghij", emptyUnderlines, 0, 5));
         frame->setEditableSelectionOffsets(11, 11);
         verifySelectionAndComposition(webView, 11, 11, 6, 11, "initial case");
 
         // Press Backspace and verify composition didn't get cancelled. This is to verify the fix
         // for crbug.com/429916.
         WebKeyboardEvent keyEvent;
         keyEvent.domKey = Platform::current()->domKeyEnumFromString("\b");
         keyEvent.windowsKeyCode = VKEY_BACK;
         keyEvent.type = WebInputEvent::RawKeyDown;
         webView->handleInputEvent(keyEvent);
 
         frame->setEditableSelectionOffsets(6, 6);
-        EXPECT_TRUE(webView->setComposition("fghi", emptyUnderlines, 0, 4));
+        EXPECT_TRUE(inputMethodController()->setComposition("fghi", emptyUnderlines, 0, 4));
         frame->setEditableSelectionOffsets(10, 10);
         verifySelectionAndComposition(webView, 10, 10, 6, 10, "after pressing Backspace");
 
         keyEvent.type = WebInputEvent::KeyUp;
         webView->handleInputEvent(keyEvent);
 
         webView->advanceFocus(false);
     }
 
     frame->setAutofillClient(0);
 }
 
 TEST_F(WebViewTest, FinishComposingTextTriggersAutofillTextChange)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     MockAutofillClient client;
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setAutofillClient(&client);
     webView->setInitialFocus(false);
 
     // Set up a composition that needs to be committed.
     std::string compositionText("testingtext");
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
-    webView->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0, compositionText.length());
+    inputMethodController()->setComposition(WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0, compositionText.length());
 
     WebTextInputInfo info = webView->textInputInfo();
     EXPECT_EQ(0, info.selectionStart);
     EXPECT_EQ((int) compositionText.length(), info.selectionEnd);
     EXPECT_EQ(0, info.compositionStart);
     EXPECT_EQ((int) compositionText.length(), info.compositionEnd);
 
     client.clearChangeCounts();
-    webView->finishComposingText(WebWidget::KeepSelection);
+    inputMethodController()->finishComposingText(WebInputMethodController::KeepSelection);
     EXPECT_EQ(0, client.textChangesWhileIgnored());
     EXPECT_EQ(1, client.textChangesWhileNotIgnored());
 
     frame->setAutofillClient(0);
 }
 
 TEST_F(WebViewTest, SetCompositionFromExistingTextTriggersAutofillTextChange)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     MockAutofillClient client;
@@ skipping 681 matching lines @@
     inputElement->setValue("testA");
     EXPECT_TRUE(client.textIsUpdated());
     WebTextInputInfo info = webViewImpl->textInputInfo();
     EXPECT_EQ("testA", std::string(info.value.utf8().data()));
 
     // (A.2) Focused and user input modifies value.
     client.reset();
     EXPECT_FALSE(client.textIsUpdated());
 
     WebVector<WebCompositionUnderline> emptyUnderlines;
-    webViewImpl->setComposition(WebString::fromUTF8("2"), emptyUnderlines, 1, 1);
-    webViewImpl->finishComposingText(WebWidget::KeepSelection);
+    inputMethodController()->setComposition(WebString::fromUTF8("2"), emptyUnderlines, 1, 1);
+    inputMethodController()->finishComposingText(WebInputMethodController::KeepSelection);
     EXPECT_FALSE(client.textIsUpdated());
     info = webViewImpl->textInputInfo();
     EXPECT_EQ("testA2", std::string(info.value.utf8().data()));
 
     // (A.3) Unfocused and value is changed by script.
     client.reset();
     EXPECT_FALSE(client.textIsUpdated());
     document->clearFocusedElement();
     webViewImpl->setFocus(false);
     EXPECT_NE(document->focusedElement(), static_cast<Element*>(inputElement));
     inputElement->setValue("testA3");
     EXPECT_FALSE(client.textIsUpdated());
 
     // (B) <textarea>
     // (B.1) Focused and value is changed by script.
     client.reset();
     EXPECT_FALSE(client.textIsUpdated());
     HTMLTextAreaElement* textAreaElement = toHTMLTextAreaElement(document->getElementById("textarea"));
     document->setFocusedElement(textAreaElement, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
     webViewImpl->setFocus(true);
     EXPECT_EQ(document->focusedElement(), static_cast<Element*>(textAreaElement));
     textAreaElement->setValue("testB");
     EXPECT_TRUE(client.textIsUpdated());
     info = webViewImpl->textInputInfo();
     EXPECT_EQ("testB", std::string(info.value.utf8().data()));
 
     // (B.2) Focused and user input modifies value.
     client.reset();
     EXPECT_FALSE(client.textIsUpdated());
-    webViewImpl->setComposition(WebString::fromUTF8("2"), emptyUnderlines, 1, 1);
-    webViewImpl->finishComposingText(WebWidget::KeepSelection);
+    inputMethodController()->setComposition(WebString::fromUTF8("2"), emptyUnderlines, 1, 1);
+    inputMethodController()->finishComposingText(WebInputMethodController::KeepSelection);
     info = webViewImpl->textInputInfo();
     EXPECT_EQ("testB2", std::string(info.value.utf8().data()));
 
     // (B.3) Unfocused and value is changed by script.
     client.reset();
     EXPECT_FALSE(client.textIsUpdated());
     document->clearFocusedElement();
     webViewImpl->setFocus(false);
     EXPECT_NE(document->focusedElement(), static_cast<Element*>(textAreaElement));
     inputElement->setValue("testB3");
@@ skipping 72 matching lines @@
 
 TEST_F(WebViewTest, CompositionIsUserGesture)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_populated.html"));
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_populated.html");
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     MockAutofillClient client;
     frame->setAutofillClient(&client);
     webView->setInitialFocus(false);
 
-    EXPECT_TRUE(webView->setComposition(WebString::fromUTF8(std::string("hello").c_str()), WebVector<WebCompositionUnderline>(), 3, 3));
+    EXPECT_TRUE(inputMethodController()->setComposition(WebString::fromUTF8(std::string("hello").c_str()), WebVector<WebCompositionUnderline>(), 3, 3));
     EXPECT_EQ(1, client.textChangesFromUserGesture());
     EXPECT_FALSE(UserGestureIndicator::processingUserGesture());
     EXPECT_TRUE(frame->hasMarkedText());
 
     frame->setAutofillClient(0);
 }
 
 TEST_F(WebViewTest, CompareSelectAllToContentAsText)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("longpress_selection.html"));
@@ skipping 327 matching lines @@
 
 TEST_F(WebViewTest, PasswordFieldEditingIsUserGesture)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("input_field_password.html"));
     MockAutofillClient client;
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "input_field_password.html", true);
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->setAutofillClient(&client);
     webView->setInitialFocus(false);
 
-    EXPECT_TRUE(webView->commitText(WebString::fromUTF8(std::string("hello").c_str()), 0));
+    EXPECT_TRUE(inputMethodController()->commitText(WebString::fromUTF8(std::string("hello").c_str()), 0));
     EXPECT_EQ(1, client.textChangesFromUserGesture());
     EXPECT_FALSE(UserGestureIndicator::processingUserGesture());
     frame->setAutofillClient(0);
 }
 
 // Verify that a WebView created with a ScopedPageLoadDeferrer already on the
 // stack defers its loads.
 TEST_F(WebViewTest, CreatedDuringLoadDeferral)
 {
     {
@@ skipping 57 matching lines @@
             EXPECT_TRUE(webView->page()->defersLoading());
         }
 
         EXPECT_TRUE(webView->page()->defersLoading());
     }
 
     EXPECT_FALSE(webView->page()->defersLoading());
 }
 
 } // namespace blink