Make EventHandlerRegistry store Page instead of FrameHost

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"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/ChromeClient.h"
-#include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 namespace blink {
 
 namespace {
 
 WebEventListenerProperties webEventListenerProperties(bool hasBlocking,
                                                       bool hasPassive) {
   if (hasBlocking && hasPassive)
     return WebEventListenerProperties::BlockingAndPassive;
   if (hasBlocking)
     return WebEventListenerProperties::Blocking;
   if (hasPassive)
     return WebEventListenerProperties::Passive;
   return WebEventListenerProperties::Nothing;
 }
 
 }  // namespace
 
-EventHandlerRegistry::EventHandlerRegistry(FrameHost& frameHost)
-    : m_frameHost(&frameHost) {}
+EventHandlerRegistry::EventHandlerRegistry(Page& page) : m_page(&page) {}
 
 EventHandlerRegistry::~EventHandlerRegistry() {
   for (size_t i = 0; i < EventHandlerClassCount; ++i) {
     EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
     checkConsistency(handlerClass);
   }
 }
 
 bool EventHandlerRegistry::eventTypeToClass(
     const AtomicString& eventType,
@@ skipping 123 matching lines @@
                                               EventHandlerClass handlerClass) {
   updateEventHandlerInternal(Add, handlerClass, &target);
 }
 
 void EventHandlerRegistry::didRemoveEventHandler(
     EventTarget& target,
     EventHandlerClass handlerClass) {
   updateEventHandlerInternal(Remove, handlerClass, &target);
 }
 
-void EventHandlerRegistry::didMoveIntoFrameHost(EventTarget& target) {
+void EventHandlerRegistry::didMoveIntoPage(EventTarget& target) {
   if (!target.hasEventListeners())
     return;
 
   // This code is not efficient at all.
   Vector<AtomicString> eventTypes = target.eventTypes();
   for (size_t i = 0; i < eventTypes.size(); ++i) {
     EventListenerVector* listeners = target.getEventListeners(eventTypes[i]);
     if (!listeners)
       continue;
     for (unsigned count = listeners->size(); count > 0; --count) {
       EventHandlerClass handlerClass;
       if (!eventTypeToClass(eventTypes[i], (*listeners)[count - 1].options(),
                             &handlerClass))
         continue;
 
       didAddEventHandler(target, handlerClass);
     }
   }
 }
 
-void EventHandlerRegistry::didMoveOutOfFrameHost(EventTarget& target) {
+void EventHandlerRegistry::didMoveOutOfPage(EventTarget& target) {
   didRemoveAllEventHandlers(target);
 }
 
 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->page().chromeClient().setHasScrollEventHandlers(
-          frame, hasActiveHandlers);
+      m_page->chromeClient().setHasScrollEventHandlers(frame,
+                                                       hasActiveHandlers);
       break;
     case WheelEventBlocking:
     case WheelEventPassive:
-      m_frameHost->page().chromeClient().setEventListenerProperties(
+      m_page->chromeClient().setEventListenerProperties(
           frame, WebEventListenerClass::MouseWheel,
           webEventListenerProperties(hasEventHandlers(WheelEventBlocking),
                                      hasEventHandlers(WheelEventPassive)));
       break;
     case TouchStartOrMoveEventBlocking:
     case TouchStartOrMoveEventPassive:
-      m_frameHost->page().chromeClient().setEventListenerProperties(
+      m_page->chromeClient().setEventListenerProperties(
           frame, WebEventListenerClass::TouchStartOrMove,
           webEventListenerProperties(
               hasEventHandlers(TouchStartOrMoveEventBlocking),
               hasEventHandlers(TouchStartOrMoveEventPassive)));
       break;
     case TouchEndOrCancelEventBlocking:
     case TouchEndOrCancelEventPassive:
-      m_frameHost->page().chromeClient().setEventListenerProperties(
+      m_page->chromeClient().setEventListenerProperties(
           frame, WebEventListenerClass::TouchEndOrCancel,
           webEventListenerProperties(
               hasEventHandlers(TouchEndOrCancelEventBlocking),
               hasEventHandlers(TouchEndOrCancelEventPassive)));
       break;
 #if DCHECK_IS_ON()
     case EventsForTesting:
       break;
 #endif
     default:
       ASSERT_NOT_REACHED();
       break;
   }
 }
 
 void EventHandlerRegistry::notifyDidAddOrRemoveEventHandlerTarget(
     EventHandlerClass handlerClass) {
-  ScrollingCoordinator* scrollingCoordinator =
-      m_frameHost->page().scrollingCoordinator();
+  ScrollingCoordinator* scrollingCoordinator = m_page->scrollingCoordinator();
   if (scrollingCoordinator && handlerClass == TouchStartOrMoveEventBlocking)
     scrollingCoordinator->touchEventTargetRectsDidChange();
 }
 
 DEFINE_TRACE(EventHandlerRegistry) {
-  visitor->trace(m_frameHost);
+  visitor->trace(m_page);
   visitor->template registerWeakMembers<
       EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);
 }
 
 void EventHandlerRegistry::clearWeakMembers(Visitor* visitor) {
   Vector<UntracedMember<EventTarget>> deadTargets;
   for (size_t i = 0; i < EventHandlerClassCount; ++i) {
     EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
     const EventTargetSet* targets = &m_targets[handlerClass];
     for (const auto& eventTarget : *targets) {
@@ skipping 40 matching lines @@
 }
 
 void EventHandlerRegistry::checkConsistency(
     EventHandlerClass handlerClass) const {
 #if DCHECK_IS_ON()
   const EventTargetSet* targets = &m_targets[handlerClass];
   for (const auto& eventTarget : *targets) {
     if (Node* node = eventTarget.key->toNode()) {
       // See the comment for |documentDetached| if either of these assertions
       // fails.
-      DCHECK(node->document().frameHost());
-      DCHECK(node->document().frameHost() == m_frameHost);
+      DCHECK(node->document().page());
+      DCHECK(node->document().page() == m_page);
     } else if (LocalDOMWindow* window = eventTarget.key->toLocalDOMWindow()) {
       // If any of these assertions fail, LocalDOMWindow failed to unregister
       // its handlers properly.
       DCHECK(window->frame());
-      DCHECK(window->frame()->host());
-      DCHECK(window->frame()->host() == m_frameHost);
+      DCHECK(window->frame()->page());
+      DCHECK(window->frame()->page() == m_page);
     }
   }
 #endif  // DCHECK_IS_ON()
 }
 
 }  // namespace blink