Move compositor InputHandler from RenderViewImpl to RenderWidget.

third_party/WebKit/Source/core/frame/EventHandlerRegistry.cpp

 // Copyright 2014 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/frame/EventHandlerRegistry.h"
 
 #include "core/events/EventListenerOptions.h"
 #include "core/events/EventUtil.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 101 matching lines @@
 }
 
 void EventHandlerRegistry::updateEventHandlerInternal(
     ChangeOperation op,
     EventHandlerClass handlerClass,
     EventTarget* target) {
   bool hadHandlers = m_targets[handlerClass].size();
   bool targetSetChanged = updateEventHandlerTargets(op, handlerClass, target);
   bool hasHandlers = m_targets[handlerClass].size();
 
-  if (hadHandlers != hasHandlers)
-    notifyHasHandlersChanged(handlerClass, hasHandlers);
+  if (hadHandlers != hasHandlers) {
+    Frame* mainFrame = m_frameHost->page().mainFrame();
+    LocalFrame* frame =
+        mainFrame->isLocalFrame() ? toLocalFrame(mainFrame) : nullptr;
+    if (Node* node = target->toNode())
+      frame = node->document().frame();

[dcheng, 2016/11/10 07:46:11]

My reading of this is we'll need to handle the LocalDOMWindow case a well: we
can just get the frame from the LocalDOMWindow and plumb that through, right?

(We should probably also assert that those are the only EventTarget types we're
handling)

[wjmaclean, 2016/11/10 15:57:15]

Done. (DCHECK'd as ASSERT is deprecated.)

[wjmaclean, 2016/11/11 15:40:51]

Hmmm, that didn't work. It seems we must have more than just Node and
LocalDOMWindow coming through here.

[dcheng, 2016/11/11 22:32:11]

Does the debugger know what type of EventTarget is getting passed in here? It'd
be good to see what else we're not covering.

+
+    notifyHasHandlersChanged(frame, handlerClass, hasHandlers);
+  }
 
   if (targetSetChanged)
     notifyDidAddOrRemoveEventHandlerTarget(handlerClass);
 }
 
 void EventHandlerRegistry::updateEventHandlerOfType(
     ChangeOperation op,
     const AtomicString& eventType,
     const AddEventListenerOptions& options,
     EventTarget* target) {
@@ skipping 69 matching lines @@
 }
 
 void EventHandlerRegistry::didRemoveAllEventHandlers(EventTarget& target) {
   for (size_t i = 0; i < EventHandlerClassCount; ++i) {
     EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
     updateEventHandlerInternal(RemoveAll, handlerClass, &target);
   }
 }
 
 void EventHandlerRegistry::notifyHasHandlersChanged(
+    LocalFrame* frame,
     EventHandlerClass handlerClass,
     bool hasActiveHandlers) {
   switch (handlerClass) {
     case ScrollEvent:
       m_frameHost->chromeClient().setHasScrollEventHandlers(hasActiveHandlers);
       break;
     case WheelEventBlocking:
     case WheelEventPassive:
       m_frameHost->chromeClient().setEventListenerProperties(
-          WebEventListenerClass::MouseWheel,
+          frame, WebEventListenerClass::MouseWheel,
           webEventListenerProperties(hasEventHandlers(WheelEventBlocking),
                                      hasEventHandlers(WheelEventPassive)));
       break;
     case TouchStartOrMoveEventBlocking:
     case TouchStartOrMoveEventPassive:
       m_frameHost->chromeClient().setEventListenerProperties(
-          WebEventListenerClass::TouchStartOrMove,
+          frame, WebEventListenerClass::TouchStartOrMove,
           webEventListenerProperties(
               hasEventHandlers(TouchStartOrMoveEventBlocking),
               hasEventHandlers(TouchStartOrMoveEventPassive)));
       break;
     case TouchEndOrCancelEventBlocking:
     case TouchEndOrCancelEventPassive:
       m_frameHost->chromeClient().setEventListenerProperties(
-          WebEventListenerClass::TouchEndOrCancel,
+          frame, WebEventListenerClass::TouchEndOrCancel,
           webEventListenerProperties(
               hasEventHandlers(TouchEndOrCancelEventBlocking),
               hasEventHandlers(TouchEndOrCancelEventPassive)));
       break;
 #if ENABLE(ASSERT)
     case EventsForTesting:
       break;
 #endif
     default:
       ASSERT_NOT_REACHED();
@@ skipping 80 matching lines @@
         ASSERT(window->frame());
         ASSERT(window->frame()->host());
         ASSERT(window->frame()->host() == m_frameHost);
       }
     }
   }
 #endif  // ENABLE(ASSERT)
 }
 
 }  // namespace blink