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 376 matching lines @@
     }
 
     void reset()
     {
         m_contentDetectionRequested = false;
         m_pendingIntentsCancelled = false;
         m_scheduledIntentURL = WebURL();
         m_wasInMainFrame = false;
         m_contentDetectionResult = WebURL();
     }
+    bool contentDetectionRequested() const { return m_contentDetectionRequested; }

[lfg, 2016/09/16 20:17:09]

Was this an intended change?

[EhsanK, 2016/09/20 15:38:29]

No. Thanks for noticing it. I don't quite understand how the empty line got
removed.

 
-    bool contentDetectionRequested() const { return m_contentDetectionRequested; }
     bool pendingIntentsCancelled() const { return m_pendingIntentsCancelled; }
     const WebURL& scheduledIntentURL() const { return m_scheduledIntentURL; }
     bool wasInMainFrame() const { return m_wasInMainFrame; }
     void setContentDetectionResult(const WebURL& result) { m_contentDetectionResult = result; }
 
 private:
     bool m_contentDetectionRequested;
     bool m_pendingIntentsCancelled;
     WebURL m_scheduledIntentURL;
     bool m_wasInMainFrame;
@@ skipping 23 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
+{
+    return m_webViewHelper.webView()->getActiveWebInputMethodController();

[lfg, 2016/09/16 20:17:09]

Can you get this through the WebViewFrameWidget?

[EhsanK, 2016/09/20 15:38:29]

Acknowledged.

+}
+
 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