[refactor] - Move textInputInfo() and textInputType() from WebWidget to WebInputMethodController

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 733 matching lines @@
   testAutoResize(minAutoResize, maxAutoResize, pageWidth, pageHeight,
                  expectedWidth, expectedHeight, NoHorizontalScrollbar,
                  NoVerticalScrollbar);
 }
 
 void WebViewTest::testTextInputType(WebTextInputType expectedType,
                                     const std::string& htmlFile) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8(htmlFile.c_str()));
-  WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
-  EXPECT_EQ(WebTextInputTypeNone, webView->textInputType());
-  EXPECT_EQ(WebTextInputTypeNone, webView->textInputInfo().type);
+  WebViewImpl* webView =
+      m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
+  WebInputMethodControllerImpl* controller =
+      webView->mainFrameImpl()->inputMethodController();
+  EXPECT_EQ(WebTextInputTypeNone, controller->textInputType());
+  EXPECT_EQ(WebTextInputTypeNone, controller->textInputInfo().type);
   webView->setInitialFocus(false);
-  EXPECT_EQ(expectedType, webView->textInputType());
-  EXPECT_EQ(expectedType, webView->textInputInfo().type);
+  EXPECT_EQ(expectedType, controller->textInputType());
+  EXPECT_EQ(expectedType, controller->textInputInfo().type);
   webView->clearFocusedElement();
-  EXPECT_EQ(WebTextInputTypeNone, webView->textInputType());
-  EXPECT_EQ(WebTextInputTypeNone, webView->textInputInfo().type);
+  EXPECT_EQ(WebTextInputTypeNone, controller->textInputType());
+  EXPECT_EQ(WebTextInputTypeNone, controller->textInputInfo().type);
 }
 
 TEST_P(WebViewTest, TextInputType) {
   testTextInputType(WebTextInputTypeText, "input_field_default.html");
   testTextInputType(WebTextInputTypePassword, "input_field_password.html");
   testTextInputType(WebTextInputTypeEmail, "input_field_email.html");
   testTextInputType(WebTextInputTypeSearch, "input_field_search.html");
   testTextInputType(WebTextInputTypeNumber, "input_field_number.html");
   testTextInputType(WebTextInputTypeTelephone, "input_field_tel.html");
   testTextInputType(WebTextInputTypeURL, "input_field_url.html");
@@ skipping 21 matching lines @@
       baseURL);
   webViewImpl->setInitialFocus(false);
 
   // Add id="foo" to <path>, thus triggering the condition described above.
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   document->body()
       ->querySelector("path", ASSERT_NO_EXCEPTION)
       ->setIdAttribute("foo");
 
   // This should not DCHECK.
-  EXPECT_EQ(WebTextInputTypeText, webViewImpl->textInputInfo().type);
+  EXPECT_EQ(WebTextInputTypeText, webViewImpl->mainFrameImpl()
+                                      ->inputMethodController()
+                                      ->textInputInfo()
+                                      .type);
 }
 
 void WebViewTest::testInputMode(WebTextInputMode expectedInputMode,
                                 const std::string& htmlFile) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8(htmlFile.c_str()));
-  WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
-  webView->setInitialFocus(false);
-  EXPECT_EQ(expectedInputMode, webView->textInputInfo().inputMode);
+  WebViewImpl* webViewImpl =
+      m_webViewHelper.initializeAndLoad(m_baseURL + htmlFile);
+  webViewImpl->setInitialFocus(false);
+  EXPECT_EQ(expectedInputMode, webViewImpl->mainFrameImpl()
+                                   ->inputMethodController()
+                                   ->textInputInfo()
+                                   .inputMode);
 }
 
 TEST_P(WebViewTest, InputMode) {
   testInputMode(WebTextInputMode::kWebTextInputModeDefault,
                 "input_mode_default.html");
   testInputMode(WebTextInputMode::kWebTextInputModeDefault,
                 "input_mode_default_unknown.html");
   testInputMode(WebTextInputMode::kWebTextInputModeVerbatim,
                 "input_mode_default_verbatim.html");
   testInputMode(WebTextInputMode::kWebTextInputModeVerbatim,
@@ skipping 24 matching lines @@
                 "input_mode_type_email.html");
   testInputMode(WebTextInputMode::kWebTextInputModeUrl,
                 "input_mode_type_url.html");
 }
 
 TEST_P(WebViewTest, TextInputInfoWithReplacedElements) {
   std::string url = m_baseURL + "div_with_image.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "div_with_image.html");
   URLTestHelpers::registerMockedURLLoad(toKURL("http://www.test.com/foo.png"),
                                         "white-1x1.png");
-  WebView* webView = m_webViewHelper.initializeAndLoad(url);
-  webView->setInitialFocus(false);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url);
+  webViewImpl->setInitialFocus(false);
+  WebTextInputInfo info =
+      webViewImpl->mainFrameImpl()->inputMethodController()->textInputInfo();
 
   EXPECT_EQ("foo\xef\xbf\xbc", info.value.utf8());
 }
 
 TEST_P(WebViewTest, SetEditableSelectionOffsetsAndTextInputInfo) {
   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);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
+  WebInputMethodControllerImpl* activeInputMethodController =
+      frame->inputMethodController();
   frame->setEditableSelectionOffsets(5, 13);
   EXPECT_EQ("56789abc", frame->selectionAsText());
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", info.value);
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(13, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("content_editable_populated.html"));
   webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content_editable_populated.html");
   webView->setInitialFocus(false);
   frame = webView->mainFrameImpl();
   frame->setEditableSelectionOffsets(8, 19);
   EXPECT_EQ("89abcdefghi", frame->selectionAsText());
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", info.value);
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(19, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 // Regression test for crbug.com/663645
 TEST_P(WebViewTest, FinishComposingTextDoesNotAssert) {
   URLTestHelpers::registerMockedURLFromBaseURL(
@@ skipping 38 matching lines @@
   std::string compositionText("hello");
 
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
 
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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);
 
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(3, info.selectionStart);
   EXPECT_EQ(3, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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);
 
   activeInputMethodController->finishComposingText(
       WebInputMethodController::DoNotKeepSelection);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(8, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionForNewCaretPositions) {
   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);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   activeInputMethodController->commitText("hello", 0);
   activeInputMethodController->commitText("world", -5);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0, 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -2, -2);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 5, 5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -5, -5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 8, 8);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, -100,
       -100);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 100, 100);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, SetCompositionWithEmptyText) {
   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);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   activeInputMethodController->commitText("hello", 0);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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;
 
   activeInputMethodController->setComposition(WebString::fromUTF8(""),
                                               emptyUnderlines, 0, 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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);
 
   activeInputMethodController->setComposition(WebString::fromUTF8(""),
                                               emptyUnderlines, -2, -2);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, CommitTextForNewCaretPositions) {
   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);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   // Caret is on the left of composing text.
   activeInputMethodController->commitText("ab", -2);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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.
   activeInputMethodController->commitText("c", 1);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("def", -5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("g", 6);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("hi", -100);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("jk", 100);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, CommitTextWhileComposing) {
   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);
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(WebString::fromUTF8("abc"),
                                               emptyUnderlines, 0, 0);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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.
   activeInputMethodController->commitText("hello", -2);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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);
 
   activeInputMethodController->setComposition(WebString::fromUTF8("abc"),
                                               emptyUnderlines, 0, 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("", 2);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("world", -5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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.
   activeInputMethodController->commitText("", 5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, FinishCompositionDoesNotRevealSelection) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
@@ skipping 12 matching lines @@
       emptyUnderlines, 3, 3);
 
   // Scroll the input field out of the viewport.
   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();
+  WebTextInputInfo info = frame->inputMethodController()->textInputInfo();
   EXPECT_EQ("hello", std::string(info.value.utf8().data()));
 
   // Verify that the input field is not scrolled back into the viewport.
   frame->frameWidget()
       ->getActiveWebInputMethodController()
       ->finishComposingText(WebInputMethodController::DoNotKeepSelection);
   EXPECT_EQ(0, webView->mainFrame()->scrollOffset().width);
   EXPECT_EQ(offsetHeight, webView->mainFrame()->scrollOffset().height);
 }
 
 TEST_P(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();
+  WebInputMethodController* activeInputMethodController =
+      frame->inputMethodController();
   frame->setEditableSelectionOffsets(4, 4);
   frame->setCompositionFromExistingText(8, 12, emptyUnderlines);
 
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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);
 
-  WebInputMethodController* activeInputMethodController =
-      frame->frameWidget()->getActiveWebInputMethodController();
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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");
   activeInputMethodController->commitText(
       WebString::fromUTF8(compositionText.c_str()), 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, ExtendSelectionAndDelete) {
   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();
   webView->setInitialFocus(false);
   frame->setEditableSelectionOffsets(10, 10);
   frame->extendSelectionAndDelete(5, 8);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebInputMethodController* activeInputMethodController =
+      frame->inputMethodController();
+  WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("01234ijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(5, info.selectionEnd);
   frame->extendSelectionAndDelete(10, 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("ijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
 }
 
 TEST_P(WebViewTest, DeleteSurroundingText) {
   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");
   WebLocalFrameImpl* frame = toWebLocalFrameImpl(webView->mainFrame());
+  WebInputMethodController* activeInputMethodController =
+      frame->inputMethodController();
   webView->setInitialFocus(false);
 
   frame->setEditableSelectionOffsets(10, 10);
   frame->deleteSurroundingText(5, 8);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("01234ijklmnopqrstuvwxyz", std::string(info.value.utf8().data()));
   EXPECT_EQ(5, info.selectionStart);
   EXPECT_EQ(5, info.selectionEnd);
 
   frame->setEditableSelectionOffsets(5, 10);
   frame->deleteSurroundingText(3, 5);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("01ijklmstuvwxyz", std::string(info.value.utf8().data()));
   EXPECT_EQ(2, info.selectionStart);
   EXPECT_EQ(7, info.selectionEnd);
 
   frame->setEditableSelectionOffsets(5, 5);
   frame->deleteSurroundingText(10, 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("lmstuvwxyz", std::string(info.value.utf8().data()));
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 
   frame->deleteSurroundingText(0, 20);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("", std::string(info.value.utf8().data()));
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 
   frame->deleteSurroundingText(10, 10);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("", std::string(info.value.utf8().data()));
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingText) {
   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);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
+  WebInputMethodController* activeInputMethodController =
+      frame->inputMethodController();
   frame->setEditableSelectionOffsets(4, 10);
   frame->setCompositionFromExistingText(8, 12, underlines);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(8, info.compositionStart);
   EXPECT_EQ(12, info.compositionEnd);
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setCompositionFromExistingText(0, 0, emptyUnderlines);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(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();
   WebInputMethodController* activeInputMethodController =
       frame->frameWidget()->getActiveWebInputMethodController();
   frame->setEditableSelectionOffsets(27, 27);
   std::string newLineText("\n");
   activeInputMethodController->commitText(
       WebString::fromUTF8(newLineText.c_str()), 0);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopq\nrstuvwxyz",
             std::string(info.value.utf8().data()));
 
   frame->setEditableSelectionOffsets(31, 31);
   frame->setCompositionFromExistingText(30, 34, underlines);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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");
   activeInputMethodController->commitText(
       WebString::fromUTF8(compositionText.c_str()), 0);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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_P(WebViewTest, SetCompositionFromExistingTextInRichText) {
   URLTestHelpers::registerMockedURLFromBaseURL(
@@ skipping 26 matching lines @@
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
   activeInputMethodController->commitText(
       WebString::fromUTF8(compositionTextFirst.c_str()), 0);
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionTextSecond.c_str()), emptyUnderlines, 5,
       5);
 
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.utf8().data()));
   EXPECT_EQ(6, info.selectionStart);
   EXPECT_EQ(6, info.selectionEnd);
   EXPECT_EQ(6, info.compositionStart);
   EXPECT_EQ(11, info.compositionEnd);
 
   frame->setEditableSelectionOffsets(8, 8);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.utf8().data()));
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(8, info.selectionEnd);
   EXPECT_EQ(6, info.compositionStart);
   EXPECT_EQ(11, info.compositionEnd);
 
   frame->setEditableSelectionOffsets(11, 11);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->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);
 
   frame->setEditableSelectionOffsets(6, 11);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.utf8().data()));
   EXPECT_EQ(6, info.selectionStart);
   EXPECT_EQ(11, info.selectionEnd);
   EXPECT_EQ(6, info.compositionStart);
   EXPECT_EQ(11, info.compositionEnd);
 
   frame->setEditableSelectionOffsets(2, 2);
-  info = webView->textInputInfo();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("hello world", 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);
 }
 
 TEST_P(WebViewTest, IsSelectionAnchorFirst) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
@@ skipping 1131 matching lines @@
   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.
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setEditableSelectionOffsets(4, 10);
   frame->setCompositionFromExistingText(8, 12, emptyUnderlines);
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = frame->inputMethodController()->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(10, info.selectionEnd);
   EXPECT_EQ(8, info.compositionStart);
   EXPECT_EQ(12, info.compositionEnd);
 
   // Clear the focus and track that the subsequent composition commit does not
   // trigger a text changed notification for autofill.
   client.clearChangeCounts();
   webView->setFocus(false);
   EXPECT_EQ(0, client.textChangesWhileNotIgnored());
 
   frame->setAutofillClient(0);
 }
 
-static void verifySelectionAndComposition(WebView* webView,
+static void verifySelectionAndComposition(WebViewImpl* webView,
                                           int selectionStart,
                                           int selectionEnd,
                                           int compositionStart,
                                           int compositionEnd,
                                           const char* failMessage) {
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info =
+      webView->mainFrameImpl()->inputMethodController()->textInputInfo();
   EXPECT_EQ(selectionStart, info.selectionStart) << failMessage;
   EXPECT_EQ(selectionEnd, info.selectionEnd) << failMessage;
   EXPECT_EQ(compositionStart, info.compositionStart) << failMessage;
   EXPECT_EQ(compositionEnd, info.compositionEnd) << failMessage;
 }
 
 TEST_P(WebViewTest, CompositionNotCancelledByBackspace) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("composition_not_cancelled_by_backspace.html"));
@@ skipping 53 matching lines @@
   WebInputMethodController* activeInputMethodController =
       frame->frameWidget()->getActiveWebInputMethodController();
   // Set up a composition that needs to be committed.
   std::string compositionText("testingtext");
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(
       WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 0,
       compositionText.length());
 
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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();
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
   EXPECT_EQ(0, client.textChangesWhileIgnored());
   EXPECT_EQ(1, client.textChangesWhileNotIgnored());
@@ skipping 10 matching lines @@
       m_baseURL + "input_field_populated.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
   client.clearChangeCounts();
   frame->setCompositionFromExistingText(8, 12, emptyUnderlines);
 
-  WebTextInputInfo info = webView->textInputInfo();
+  WebTextInputInfo info = frame->inputMethodController()->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz",
             std::string(info.value.utf8().data()));
   EXPECT_EQ(8, info.compositionStart);
   EXPECT_EQ(12, info.compositionEnd);
 
   EXPECT_EQ(0, client.textChangesWhileIgnored());
   EXPECT_EQ(0, client.textChangesWhileNotIgnored());
 
   WebDocument document = webView->mainFrame()->document();
   EXPECT_EQ(WebString::fromUTF8("none"),
@@ skipping 645 matching lines @@
 };
 
 // This test verifies the text input flags are correctly exposed to script.
 TEST_P(WebViewTest, TextInputFlags) {
   std::string url = m_baseURL + "text_input_flags.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url), "text_input_flags.html");
   WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(url, true);
   webViewImpl->setInitialFocus(false);
 
   WebLocalFrameImpl* frame = webViewImpl->mainFrameImpl();
+  WebInputMethodControllerImpl* activeInputMethodController =
+      frame->inputMethodController();
   Document* document = frame->frame()->document();
 
   // (A) <input>
   // (A.1) Verifies autocorrect/autocomplete/spellcheck flags are Off and
   // autocapitalize is set to none.
   HTMLInputElement* inputElement =
       toHTMLInputElement(document->getElementById("input"));
   document->setFocusedElement(
       inputElement,
       FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
   webViewImpl->setFocus(true);
-  WebTextInputInfo info1 = webViewImpl->textInputInfo();
+  WebTextInputInfo info1 = activeInputMethodController->textInputInfo();
   EXPECT_EQ(WebTextInputFlagAutocompleteOff | WebTextInputFlagAutocorrectOff |
                 WebTextInputFlagSpellcheckOff |
                 WebTextInputFlagAutocapitalizeNone,
             info1.flags);
 
   // (A.2) Verifies autocorrect/autocomplete/spellcheck flags are On and
   // autocapitalize is set to sentences.
   inputElement = toHTMLInputElement(document->getElementById("input2"));
   document->setFocusedElement(
       inputElement,
       FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
   webViewImpl->setFocus(true);
-  WebTextInputInfo info2 = webViewImpl->textInputInfo();
+  WebTextInputInfo info2 = activeInputMethodController->textInputInfo();
   EXPECT_EQ(WebTextInputFlagAutocompleteOn | WebTextInputFlagAutocorrectOn |
                 WebTextInputFlagSpellcheckOn |
                 WebTextInputFlagAutocapitalizeSentences,
             info2.flags);
 
   // (B) <textarea> Verifies the default text input flags are
   // WebTextInputFlagAutocapitalizeSentences.
   HTMLTextAreaElement* textAreaElement =
       toHTMLTextAreaElement(document->getElementById("textarea"));
   document->setFocusedElement(
       textAreaElement,
       FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
   webViewImpl->setFocus(true);
-  WebTextInputInfo info3 = webViewImpl->textInputInfo();
+  WebTextInputInfo info3 = activeInputMethodController->textInputInfo();
   EXPECT_EQ(WebTextInputFlagAutocapitalizeSentences, info3.flags);
 
   // (C) Verifies the WebTextInputInfo's don't equal.
   EXPECT_FALSE(info1.equals(info2));
   EXPECT_FALSE(info2.equals(info3));
 
   // Free the webView before freeing the NonUserInputTextUpdateWebViewClient.
   m_webViewHelper.reset();
 }
 
@@ skipping 23 matching lines @@
       toHTMLInputElement(document->getElementById("input"));
   document->setFocusedElement(
       inputElement,
       FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
   webViewImpl->setFocus(true);
   EXPECT_EQ(document->focusedElement(), static_cast<Element*>(inputElement));
 
   // Emulate value change from script.
   inputElement->setValue("testA");
   EXPECT_TRUE(client.textIsUpdated());
-  WebTextInputInfo info = webViewImpl->textInputInfo();
+  WebTextInputInfo info = activeInputMethodController->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;
   activeInputMethodController->setComposition(WebString::fromUTF8("2"),
                                               emptyUnderlines, 1, 1);
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
   EXPECT_FALSE(client.textIsUpdated());
-  info = webViewImpl->textInputInfo();
+  info = activeInputMethodController->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();
+  info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("testB", std::string(info.value.utf8().data()));
 
   // (B.2) Focused and user input modifies value.
   client.reset();
   EXPECT_FALSE(client.textIsUpdated());
   activeInputMethodController->setComposition(WebString::fromUTF8("2"),
                                               emptyUnderlines, 1, 1);
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
-  info = webViewImpl->textInputInfo();
+  info = activeInputMethodController->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");
   EXPECT_FALSE(client.textIsUpdated());
@@ skipping 707 matching lines @@
       .translate(50, 55)
       .scale(1. / 2.f);
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
   // visibleContentRect doesn't change.
   EXPECT_EQ(IntRect(50, 55, 50, 75),
             *devToolsEmulator->visibleContentRectForPainting());
 }
 
 }  // namespace blink