[refactor] Remove WebWidget::applyReplacementRange

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 903 matching lines @@
 
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
 
   // The test requires non-empty composition.
   std::string compositionText("hello");
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->setComposition(
-      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 5, 5);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      5, 5);
 
   // Do arbitrary change to make layout dirty.
   Document& document = *webView->mainFrameImpl()->frame()->document();
   Element* br = document.createElement("br");
   document.body()->appendChild(br);
 
   // Should not hit assertion when calling
   // WebInputMethodController::finishComposingText with non-empty composition
   // and dirty layout.
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
 }
 
 TEST_P(WebViewTest, FinishComposingTextCursorPositionChange) {
   registerMockedHttpURLLoad("input_field_populated.html");
   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;
   activeInputMethodController->setComposition(
-      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, 3, 3);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      3, 3);
 
   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 = 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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      3, 3);
   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 = 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) {
   registerMockedHttpURLLoad("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->commitText("hello", emptyUnderlines, 0);
-  activeInputMethodController->commitText("world", emptyUnderlines, -5);
+  activeInputMethodController->commitText("hello", emptyUnderlines, WebRange(),
+                                          0);
+  activeInputMethodController->commitText("world", emptyUnderlines, WebRange(),
+                                          -5);
   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);
 
   // 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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      0, 0);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      3, 3);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      -2, -2);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      5, 5);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      -5, -5);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      8, 8);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      -100, -100);
   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);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      100, 100);
   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) {
   registerMockedHttpURLLoad("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->commitText("hello", emptyUnderlines, 0);
+  activeInputMethodController->commitText("hello", emptyUnderlines, WebRange(),
+                                          0);
   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);
 
-  activeInputMethodController->setComposition(WebString::fromUTF8(""),
-                                              emptyUnderlines, 0, 0);
+  activeInputMethodController->setComposition(
+      WebString::fromUTF8(""), emptyUnderlines, WebRange(), 0, 0);
   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);
+  activeInputMethodController->setComposition(
+      WebString::fromUTF8(""), emptyUnderlines, WebRange(), -2, -2);
   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) {
   registerMockedHttpURLLoad("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;
 
   // Caret is on the left of composing text.
-  activeInputMethodController->commitText("ab", emptyUnderlines, -2);
+  activeInputMethodController->commitText("ab", emptyUnderlines, WebRange(),
+                                          -2);
   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", emptyUnderlines, 1);
+  activeInputMethodController->commitText("c", emptyUnderlines, WebRange(), 1);
   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", emptyUnderlines, -5);
+  activeInputMethodController->commitText("def", emptyUnderlines, WebRange(),
+                                          -5);
   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", emptyUnderlines, 6);
+  activeInputMethodController->commitText("g", emptyUnderlines, WebRange(), 6);
   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", emptyUnderlines, -100);
+  activeInputMethodController->commitText("hi", emptyUnderlines, WebRange(),
+                                          -100);
   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", emptyUnderlines, 100);
+  activeInputMethodController->commitText("jk", emptyUnderlines, WebRange(),
+                                          100);
   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) {
   registerMockedHttpURLLoad("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);
+  activeInputMethodController->setComposition(
+      WebString::fromUTF8("abc"), emptyUnderlines, WebRange(), 0, 0);
   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", emptyUnderlines, -2);
+  activeInputMethodController->commitText("hello", emptyUnderlines, WebRange(),
+                                          -2);
   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);
+  activeInputMethodController->setComposition(
+      WebString::fromUTF8("abc"), emptyUnderlines, WebRange(), 0, 0);
   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("", emptyUnderlines, 2);
+  activeInputMethodController->commitText("", emptyUnderlines, WebRange(), 2);
   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", emptyUnderlines, -5);
+  activeInputMethodController->commitText("world", emptyUnderlines, WebRange(),
+                                          -5);
   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("", emptyUnderlines, 5);
+  activeInputMethodController->commitText("", emptyUnderlines, WebRange(), 5);
   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) {
   registerMockedHttpURLLoad("form_with_input.html");
@@ skipping 54 matching lines @@
   activeInputMethodController->finishComposingText(
       WebInputMethodController::KeepSelection);
   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()), emptyUnderlines, 0);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      0);
   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) {
@@ skipping 91 matching lines @@
   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");
   WebVector<WebCompositionUnderline> emptyUnderlines;
   activeInputMethodController->commitText(
-      WebString::fromUTF8(newLineText.c_str()), emptyUnderlines, 0);
+      WebString::fromUTF8(newLineText.c_str()), emptyUnderlines, WebRange(), 0);
   WebTextInputInfo info = activeInputMethodController->textInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopq\nrstuvwxyz",
             std::string(info.value.utf8().data()));
 
   frame->setEditableSelectionOffsets(31, 31);
   frame->setCompositionFromExistingText(30, 34, underlines);
   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()), emptyUnderlines, 0);
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      0);
   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) {
@@ skipping 18 matching lines @@
   webView->setInitialFocus(false);
 
   std::string compositionTextFirst("hello ");
   std::string compositionTextSecond("world");
   WebVector<WebCompositionUnderline> emptyUnderlines;
   WebInputMethodController* activeInputMethodController =
       webView->mainFrameImpl()
           ->frameWidget()
           ->getActiveWebInputMethodController();
   activeInputMethodController->commitText(
-      WebString::fromUTF8(compositionTextFirst.c_str()), emptyUnderlines, 0);
+      WebString::fromUTF8(compositionTextFirst.c_str()), emptyUnderlines,
+      WebRange(), 0);
   activeInputMethodController->setComposition(
-      WebString::fromUTF8(compositionTextSecond.c_str()), emptyUnderlines, 5,
-      5);
+      WebString::fromUTF8(compositionTextSecond.c_str()), emptyUnderlines,
+      WebRange(), 5, 5);
 
   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);
@@ skipping 838 matching lines @@
   runPendingTasks();
 
   WebString target = WebString::fromUTF8("target");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   WebInputMethodController* activeInputMethodController =
       frame->frameWidget()->getActiveWebInputMethodController();
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureTap, target));
   WebVector<WebCompositionUnderline> emptyUnderlines;
   frame->setEditableSelectionOffsets(8, 8);
   EXPECT_TRUE(activeInputMethodController->setComposition(
-      "12345", emptyUnderlines, 8, 13));
+      "12345", emptyUnderlines, WebRange(), 8, 13));
   EXPECT_TRUE(frame->frame()->inputMethodController().hasComposition());
   EXPECT_EQ("", std::string(frame->selectionAsText().utf8().data()));
   EXPECT_FALSE(frame->frame()->selection().isHandleVisible());
   EXPECT_TRUE(frame->frame()->inputMethodController().hasComposition());
 
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureLongPress, target));
   EXPECT_EQ("testword12345",
             std::string(frame->selectionAsText().utf8().data()));
   EXPECT_TRUE(frame->frame()->selection().isHandleVisible());
   EXPECT_TRUE(frame->frame()->inputMethodController().hasComposition());
@@ skipping 350 matching lines @@
   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);
     WebInputMethodController* activeInputMethodController =
         frame->frameWidget()->getActiveWebInputMethodController();
     EXPECT_TRUE(activeInputMethodController->setComposition(
-        "fghij", emptyUnderlines, 0, 5));
+        "fghij", emptyUnderlines, WebRange(), 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(WebInputEvent::RawKeyDown,
                               WebInputEvent::NoModifiers,
                               WebInputEvent::TimeStampForTesting);
     keyEvent.domKey = Platform::current()->domKeyEnumFromString("\b");
     keyEvent.windowsKeyCode = VKEY_BACK;
     webView->handleInputEvent(WebCoalescedInputEvent(keyEvent));
 
     frame->setEditableSelectionOffsets(6, 6);
     EXPECT_TRUE(activeInputMethodController->setComposition(
-        "fghi", emptyUnderlines, 0, 4));
+        "fghi", emptyUnderlines, WebRange(), 0, 4));
     frame->setEditableSelectionOffsets(10, 10);
     verifySelectionAndComposition(webView, 10, 10, 6, 10,
                                   "after pressing Backspace");
 
     keyEvent.setType(WebInputEvent::KeyUp);
     webView->handleInputEvent(WebCoalescedInputEvent(keyEvent));
 
     webView->advanceFocus(false);
   }
 
@@ skipping 13 matching lines @@
   HTMLFormControlElement* form =
       toHTMLFormControlElement(document.getElementById("sample"));
 
   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());
+      WebString::fromUTF8(compositionText.c_str()), emptyUnderlines, WebRange(),
+      0, compositionText.length());
 
   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);
 
   form->setAutofilled(true);
   client.clearChangeCounts();
 
@@ skipping 759 matching lines @@
   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(
       frame->frameWidget()->getActiveWebInputMethodController()->setComposition(
           WebString::fromUTF8(std::string("hello").c_str()),
-          WebVector<WebCompositionUnderline>(), 3, 3));
+          WebVector<WebCompositionUnderline>(), WebRange(), 3, 3));
   EXPECT_EQ(1, client.textChangesFromUserGesture());
   EXPECT_FALSE(UserGestureIndicator::processingUserGesture());
   EXPECT_TRUE(frame->hasMarkedText());
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, CompareSelectAllToContentAsText) {
   registerMockedHttpURLLoad("longpress_selection.html");
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
@@ skipping 391 matching lines @@
       m_baseURL + "input_field_password.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   WebVector<WebCompositionUnderline> emptyUnderlines;
 
   EXPECT_TRUE(
       frame->frameWidget()->getActiveWebInputMethodController()->commitText(
           WebString::fromUTF8(std::string("hello").c_str()), emptyUnderlines,
-          0));
+          WebRange(), 0));
   EXPECT_EQ(1, client.textChangesFromUserGesture());
   EXPECT_FALSE(UserGestureIndicator::processingUserGesture());
   frame->setAutofillClient(0);
 }
 
 // Verify that a WebView created with a ScopedPageSuspender already on the
 // stack defers its loads.
 TEST_P(WebViewTest, CreatedDuringPageSuspension) {
   {
     WebViewImpl* webView = m_webViewHelper.initialize();
@@ skipping 274 matching lines @@
   EXPECT_EQ(expectedWidth, vwElement->offsetWidth());
   EXPECT_EQ(expectedHeight, vwElement->offsetHeight());
 
   webView->resize(WebSize(800, 600));
   frame->printEnd();
 
   EXPECT_EQ(800, vwElement->offsetWidth());
 }
 
 }  // namespace blink