tyrbot test for commitText

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 802 matching lines @@
     frame->setEditableSelectionOffsets(8, 19);
     EXPECT_EQ("89abcdefghi", frame->selectionAsText());
     info = webView->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);
 }
 
-TEST_F(WebViewTest, ConfirmCompositionCursorPositionChange)
+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);
 
     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->confirmComposition(WebWidget::KeepSelection);
+    webView->finishComposingText(WebWidget::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);
     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->confirmComposition(WebWidget::DoNotKeepSelection);
+    webView->finishComposingText(WebWidget::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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form_with_input.html"));
     WebViewImpl* webView = m_webViewHelper.initializeAndLoad(m_baseURL + "form_with_input.html");
     webView->resize(WebSize(800, 600));
     webView->setInitialFocus(false);
     EXPECT_EQ(0, webView->mainFrame()->scrollOffset().width);
     EXPECT_EQ(0, webView->mainFrame()->scrollOffset().height);
 
     // Set up a composition from existing text that needs to be committed.
     Vector<CompositionUnderline> emptyUnderlines;
     WebLocalFrameImpl* frame = webView->mainFrameImpl();
     frame->frame()->inputMethodController().setCompositionFromExistingText(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();
     EXPECT_EQ("hello", std::string(info.value.utf8().data()));
 
     // Verify that the input field is not scrolled back into the viewport.
-    webView->confirmComposition(WebWidget::DoNotKeepSelection);
+    webView->finishComposingText(WebWidget::DoNotKeepSelection);
     EXPECT_EQ(0, webView->mainFrame()->scrollOffset().width);
     EXPECT_EQ(offsetHeight, webView->mainFrame()->scrollOffset().height);
 }
 
-TEST_F(WebViewTest, InsertNewLinePlacementAfterConfirmComposition)
+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->confirmComposition(WebWidget::KeepSelection);
+    webView->finishComposingText(WebWidget::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->confirmComposition(WebString::fromUTF8(compositionText.c_str()));
+    webView->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->confirmComposition(WebString::fromUTF8(newLineText.c_str()));
+    webView->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->confirmComposition(WebString::fromUTF8(compositionText.c_str()));
+    webView->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->confirmComposition(WebString::fromUTF8(compositionTextFirst.c_str()));
+    webView->commitText(WebString::fromUTF8(compositionTextFirst.c_str()), 0);
     webView->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();
@@ skipping 1048 matching lines @@
 
         keyEvent.type = WebInputEvent::KeyUp;
         webView->handleInputEvent(keyEvent);
 
         webView->advanceFocus(false);
     }
 
     frame->setAutofillClient(0);
 }
 
-TEST_F(WebViewTest, ConfirmCompositionTriggersAutofillTextChange)
+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());
 
     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->confirmComposition();
+    webView->finishComposingText(WebWidget::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 683 matching lines @@
     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->confirmComposition(WebWidget::KeepSelection);
+    webViewImpl->finishComposingText(WebWidget::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 10 matching lines @@
     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->confirmComposition(WebWidget::KeepSelection);
+    webViewImpl->finishComposingText(WebWidget::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 420 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->confirmComposition(WebString::fromUTF8(std::string("hello").c_str())));
+    EXPECT_TRUE(webView->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