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 68 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/DevToolsEmulator.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 783 matching lines @@
   EXPECT_EQ(8, info.selectionStart);
   EXPECT_EQ(19, info.selectionEnd);
   EXPECT_EQ(-1, info.compositionStart);
   EXPECT_EQ(-1, info.compositionEnd);
 }
 
 TEST_P(WebViewTest, FinishComposingTextCursorPositionChange) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
-  WebView* webView = m_webViewHelper.initializeAndLoad(
+  WebViewImpl* 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");
 
+  WebInputMethodController* activeInputMethodController =
+      webView->mainFrameImpl()
+          ->frameWidget()
+          ->getActiveWebInputMethodController();
   WebVector<WebCompositionUnderline> emptyUnderlines;
-  webView->setComposition(WebString::fromUTF8(compositionText.c_str()),
-                          emptyUnderlines, 3, 3);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, SetCompositionForNewCaretPositions) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
-  WebView* webView = m_webViewHelper.initializeAndLoad(
+  WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
+  WebInputMethodController* activeInputMethodController =
+      webView->mainFrameImpl()
+          ->frameWidget()
+          ->getActiveWebInputMethodController();
 
-  webView->commitText("hello", 0);
-  webView->commitText("world", -5);
+  activeInputMethodController->commitText("hello", 0);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, SetCompositionWithEmptyText) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
-  WebView* webView = m_webViewHelper.initializeAndLoad(
+  WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
+  WebInputMethodController* activeInputMethodController =
+      webView->mainFrameImpl()
+          ->frameWidget()
+          ->getActiveWebInputMethodController();
 
-  webView->commitText("hello", 0);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, CommitTextForNewCaretPositions) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
-  WebView* webView = m_webViewHelper.initializeAndLoad(
+  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.
-  webView->commitText("ab", -2);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, CommitTextWhileComposing) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
-  WebView* webView = m_webViewHelper.initializeAndLoad(
+  WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "input_field_populated.html");
   webView->setInitialFocus(false);
+  WebInputMethodController* activeInputMethodController =
+      webView->mainFrameImpl()
+          ->frameWidget()
+          ->getActiveWebInputMethodController();
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
-  webView->setComposition(WebString::fromUTF8("abc"), emptyUnderlines, 0, 0);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, FinishCompositionDoesNotRevealSelection) {
   URLTestHelpers::registerMockedURLFromBaseURL(
@@ skipping 17 matching lines @@
       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);
+  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();
   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);
+  WebInputMethodController* activeInputMethodController =
+      frame->frameWidget()->getActiveWebInputMethodController();
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, ExtendSelectionAndDelete) {
@@ skipping 87 matching lines @@
 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");
-  webView->commitText(WebString::fromUTF8(newLineText.c_str()), 0);
+  activeInputMethodController->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);
+  activeInputMethodController->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_P(WebViewTest, SetCompositionFromExistingTextInRichText) {
@@ skipping 17 matching lines @@
   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);
+  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();
   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 1217 matching lines @@
       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));
+    WebInputMethodController* activeInputMethodController =
+        frame->frameWidget()->getActiveWebInputMethodController();
+    EXPECT_TRUE(activeInputMethodController->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(activeInputMethodController->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_P(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);
-
+  WebInputMethodController* activeInputMethodController =
+      frame->frameWidget()->getActiveWebInputMethodController();
   // 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());
+  activeInputMethodController->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);
+  activeInputMethodController->finishComposingText(
+      WebInputMethodController::KeepSelection);
   EXPECT_EQ(0, client.textChangesWhileIgnored());
   EXPECT_EQ(1, client.textChangesWhileNotIgnored());
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextTriggersAutofillTextChange) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("input_field_populated.html"));
@@ skipping 731 matching lines @@
   NonUserInputTextUpdateWebWidgetClient client;
   std::string url = m_baseURL + "non_user_input_text_update.html";
   URLTestHelpers::registerMockedURLLoad(toKURL(url),
                                         "non_user_input_text_update.html");
   WebViewImpl* webViewImpl =
       m_webViewHelper.initializeAndLoad(url, true, nullptr, nullptr, &client);
   webViewImpl->setInitialFocus(false);
 
   WebLocalFrameImpl* frame = webViewImpl->mainFrameImpl();
   Document* document = frame->frame()->document();
+  WebInputMethodController* activeInputMethodController =
+      frame->frameWidget()->getActiveWebInputMethodController();
 
   // (A) <input>
   // (A.1) Focused and value is changed by script.
   client.reset();
   EXPECT_FALSE(client.textIsUpdated());
 
   HTMLInputElement* inputElement =
       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();
   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);
+  activeInputMethodController->setComposition(WebString::fromUTF8("2"),
+                                              emptyUnderlines, 1, 1);
+  activeInputMethodController->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));
@@ skipping 12 matching lines @@
   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);
+  activeInputMethodController->setComposition(WebString::fromUTF8("2"),
+                                              emptyUnderlines, 1, 1);
+  activeInputMethodController->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 80 matching lines @@
       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));
+      frame->frameWidget()->getActiveWebInputMethodController()->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_P(WebViewTest, CompareSelectAllToContentAsText) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
@@ skipping 377 matching lines @@
   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(
+      frame->frameWidget()->getActiveWebInputMethodController()->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_P(WebViewTest, CreatedDuringLoadDeferral) {
   {
     WebViewImpl* webView = m_webViewHelper.initialize();
@@ skipping 205 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