[InputEvent] Support |sequence<Range> getRanges()| in 'beforeinput'

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

Index: third_party/WebKit/Source/core/events/InputEvent.cpp
diff --git a/third_party/WebKit/Source/core/events/InputEvent.cpp b/third_party/WebKit/Source/core/events/InputEvent.cpp
index 337496ae8c03ae9750243fa347e79f0160a22ed1..c93f0c214be48c108f260f336e7a7aee46fd9659 100644
--- a/third_party/WebKit/Source/core/events/InputEvent.cpp
+++ b/third_party/WebKit/Source/core/events/InputEvent.cpp
@@ -4,6 +4,7 @@
 
 #include "core/events/InputEvent.h"
 
+#include "core/dom/Range.h"
 #include "core/events/EventDispatcher.h"
 #include "public/platform/WebEditingCommandType.h"
 
@@ -62,10 +63,12 @@ InputEvent::InputEvent(const AtomicString& type, const InputEventInit& initializ
         m_data = initializer.data();
     if (initializer.hasIsComposing())
         m_isComposing = initializer.isComposing();
+    if (initializer.hasRanges())
+        m_ranges = initializer.ranges();
 }
 
 /* static */
-InputEvent* InputEvent::createBeforeInput(InputType inputType, const String& data, EventCancelable cancelable, EventIsComposing isComposing)
+InputEvent* InputEvent::createBeforeInput(InputType inputType, const String& data, EventCancelable cancelable, EventIsComposing isComposing, const RangeVector* ranges)
 {
     InputEventInit inputEventInit;
 
@@ -76,6 +79,8 @@ InputEvent* InputEvent::createBeforeInput(InputType inputType, const String& dat
     inputEventInit.setInputType(convertInputTypeToString(inputType));
     inputEventInit.setData(data);
     inputEventInit.setIsComposing(isComposing == IsComposing);
+    if (ranges)
+        inputEventInit.setRanges(*ranges);
 
     return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
 }
@@ -90,9 +95,38 @@ bool InputEvent::isInputEvent() const
     return true;
 }
 
+EventDispatchMediator* InputEvent::createMediator()
+{
+    return InputEventDispatchMediator::create(this);
+}
+
 DEFINE_TRACE(InputEvent)
 {
     UIEvent::trace(visitor);
+    visitor->trace(m_ranges);
+}
+
+InputEventDispatchMediator* InputEventDispatchMediator::create(InputEvent* inputEvent)
+{
+    return new InputEventDispatchMediator(inputEvent);
+}
+
+InputEventDispatchMediator::InputEventDispatchMediator(InputEvent* inputEvent)
+    : EventDispatchMediator(inputEvent)
+{
+}
+
+InputEvent& InputEventDispatchMediator::event() const
+{
+    return toInputEvent(EventDispatchMediator::event());
+}
+
+DispatchEventResult InputEventDispatchMediator::dispatchEvent(EventDispatcher& dispatcher) const
+{
+    DispatchEventResult result = dispatcher.dispatch();
+    // Clear |m_ranges| manually in case event object was held by JavaScript.

[ojan, 2016/05/31 17:47:29]

Can you explain this in more detail? I thought we could mostly avoid manually
clearing in an Oilpan world. Disclaimer: My knowledge of oilpan is super
limited.

[chongz, 2016/05/31 18:32:26]

Added more detailed comments. We want to dereference |Range| in case developers
want to hold |InputEvent| objects but not aware that it will reference |Range|
objects.

Actually this operation should be safe since it's only clearing the vector but
not freeing the memory. So the |Range| object inside shouldn't be freed if (by
any chance) it's still referenced by someone else.

[ojan, 2016/05/31 21:35:58]

I thought the idea was that we would expose StaticRange here, in which case it's
OK for them to hold on to it. Am I misremembering?

Also, is that web exposed? e.g. if I call getRanges on an input event after
we've cleared m_ranges, what happens?

+    event().m_ranges.clear();
+    return result;
 }
 
 } // namespace blink