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

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"
 
 namespace blink {
 
 namespace {
 
 const struct {
     InputEvent::InputType inputType;
     const char* stringName;
@@ skipping 38 matching lines @@
     : UIEvent(type, initializer)
 {
     // TODO(ojan): We should find a way to prevent conversion like 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.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;
 
     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);
 
     return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
 }
 
 String InputEvent::inputType() const
 {
     return convertInputTypeToString(m_inputType);
 }
 
 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