[InputEvent] Change |InputEventInit::sequence<Range> ranges| to |sequence<StaticRange> targetRanges|

third_party/WebKit/Source/core/events/InputEvent.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/events/InputEvent.h"
 
 #include "core/dom/Range.h"
 #include "core/events/EventDispatcher.h"
 #include "public/platform/WebEditingCommandType.h"
 
@@ skipping 75 matching lines @@
   // String->enum->String just in order to use initializer.
   // See InputEvent::createBeforeInput() for the first conversion.
   if (initializer.hasInputType())
     m_inputType = convertStringToInputType(initializer.inputType());
   if (initializer.hasData())
     m_data = initializer.data();
   if (initializer.hasDataTransfer())
     m_dataTransfer = initializer.dataTransfer();
   if (initializer.hasIsComposing())
     m_isComposing = initializer.isComposing();
-  if (initializer.hasRanges())
-    m_ranges = initializer.ranges();
+  if (!initializer.hasTargetRanges())
+    return;
+  for (const auto& range : initializer.targetRanges())
+    m_ranges.push_back(range->toRange());
 }
 
 /* static */
 InputEvent* InputEvent::createBeforeInput(InputType inputType,
                                           const String& data,
                                           EventCancelable cancelable,
                                           EventIsComposing isComposing,
-                                          const RangeVector* ranges) {
+                                          const StaticRangeVector* ranges) {
   InputEventInit inputEventInit;
 
   inputEventInit.setBubbles(true);
   inputEventInit.setCancelable(cancelable == IsCancelable);
   // TODO(ojan): We should find a way to prevent conversion like
   // String->enum->String just in order to use initializer.
   // See InputEvent::InputEvent() for the second conversion.
   inputEventInit.setInputType(convertInputTypeToString(inputType));
   inputEventInit.setData(data);
   inputEventInit.setIsComposing(isComposing == IsComposing);
   if (ranges)
-    inputEventInit.setRanges(*ranges);
+    inputEventInit.setTargetRanges(*ranges);
   inputEventInit.setComposed(true);
   return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
 }
 
 /* static */
 InputEvent* InputEvent::createBeforeInput(InputType inputType,
                                           DataTransfer* dataTransfer,
                                           EventCancelable cancelable,
                                           EventIsComposing isComposing,
-                                          const RangeVector* ranges) {
+                                          const StaticRangeVector* ranges) {
   InputEventInit inputEventInit;
 
   inputEventInit.setBubbles(true);
   inputEventInit.setCancelable(cancelable == IsCancelable);
   inputEventInit.setInputType(convertInputTypeToString(inputType));
   inputEventInit.setDataTransfer(dataTransfer);
   inputEventInit.setIsComposing(isComposing == IsComposing);
   if (ranges)
-    inputEventInit.setRanges(*ranges);
+    inputEventInit.setTargetRanges(*ranges);
   inputEventInit.setComposed(true);
   return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
 }
 
 /* static */
 InputEvent* InputEvent::createInput(InputType inputType,
                                     const String& data,
                                     EventIsComposing isComposing,
-                                    const RangeVector* ranges) {
+                                    const StaticRangeVector* ranges) {
   InputEventInit inputEventInit;
 
   inputEventInit.setBubbles(true);
   inputEventInit.setCancelable(false);
   // TODO(ojan): We should find a way to prevent conversion like
   // String->enum->String just in order to use initializer.
   // See InputEvent::InputEvent() for the second conversion.
   inputEventInit.setInputType(convertInputTypeToString(inputType));
   inputEventInit.setData(data);
   inputEventInit.setIsComposing(isComposing == IsComposing);
   if (ranges)
-    inputEventInit.setRanges(*ranges);
+    inputEventInit.setTargetRanges(*ranges);
   inputEventInit.setComposed(true);
   return InputEvent::create(EventTypeNames::input, inputEventInit);
 }
 
 String InputEvent::inputType() const {
   return convertInputTypeToString(m_inputType);
 }
 
 StaticRangeVector InputEvent::getTargetRanges() const {
   StaticRangeVector staticRanges;
   for (const auto& range : m_ranges)
-    staticRanges.push_back(StaticRange::create(
-        range->ownerDocument(), range->startContainer(), range->startOffset(),
-        range->endContainer(), range->endOffset()));
+    staticRanges.push_back(StaticRange::create(range));
   return staticRanges;
 }
 
 bool InputEvent::isInputEvent() const {
   return true;
 }
 
 // TODO(chongz): We should get rid of this |EventDispatchMediator| pattern and
 // introduce simpler interface such as |beforeDispatchEvent()| and
 // |afterDispatchEvent()| virtual methods.
@@ skipping 32 matching lines @@
   //   3. We don't want authors to hold live |Range| indefinitely by holding
   //      |InputEvent|, so we clear them after dispatch.
   // Authors should explicitly call |getTargetRanges()|->|toRange()| if they
   // want to keep a copy of |Range|.  See Editing TF meeting notes:
   // https://docs.google.com/document/d/1hCj6QX77NYIVY0RWrMHT1Yra6t8_Qu8PopaWLG0AM58/edit?usp=sharing
   event().m_ranges.clear();
   return result;
 }
 
 }  // namespace blink