Delay instantiating InputDeviceCapabilities until accessed.

third_party/WebKit/Source/core/page/FocusController.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 320 matching lines @@
         toHTMLSlotElement(parent)->assignedNodes().isEmpty())
       return !SlotScopedTraversal::isSlotScoped(current) &&
              toHTMLSlotElement(parent) == slot;
     parent = parent->parentElement();
   }
   return false;
 }
 
 inline void dispatchBlurEvent(const Document& document,
                               Element& focusedElement) {
-  focusedElement.dispatchBlurEvent(nullptr, WebFocusTypePage);
+  focusedElement.dispatchBlurEvent(nullptr, WebFocusTypePage,
+                                   InputDeviceCapabilities::Null);
   if (focusedElement == document.focusedElement()) {
-    focusedElement.dispatchFocusOutEvent(EventTypeNames::focusout, nullptr);
-    if (focusedElement == document.focusedElement())
-      focusedElement.dispatchFocusOutEvent(EventTypeNames::DOMFocusOut,
-                                           nullptr);
+    focusedElement.dispatchFocusOutEvent(EventTypeNames::focusout, nullptr,
+                                         InputDeviceCapabilities::Null);
+    if (focusedElement == document.focusedElement()) {
+      focusedElement.dispatchFocusOutEvent(EventTypeNames::DOMFocusOut, nullptr,
+                                           InputDeviceCapabilities::Null);
+    }
   }
 }
 
 inline void dispatchFocusEvent(const Document& document,
                                Element& focusedElement) {
-  focusedElement.dispatchFocusEvent(0, WebFocusTypePage);
+  focusedElement.dispatchFocusEvent(0, WebFocusTypePage,
+                                    InputDeviceCapabilities::Null);
   if (focusedElement == document.focusedElement()) {
     focusedElement.dispatchFocusInEvent(EventTypeNames::focusin, nullptr,
-                                        WebFocusTypePage);
-    if (focusedElement == document.focusedElement())
+                                        WebFocusTypePage,
+                                        InputDeviceCapabilities::Null);
+    if (focusedElement == document.focusedElement()) {
       focusedElement.dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr,
-                                          WebFocusTypePage);
+                                          WebFocusTypePage,
+                                          InputDeviceCapabilities::Null);
+    }
   }
 }
 
 inline void dispatchEventsOnWindowAndFocusedElement(Document* document,
                                                     bool focused) {
   DCHECK(document);
   // If we have a focused element we should dispatch blur on it before we blur
   // the window.  If we have a focused element we should dispatch focus on it
   // after we focus the window.  https://bugs.webkit.org/show_bug.cgi?id=27105
 
@@ skipping 501 matching lines @@
       toLocalFrame(m_focusedFrame.get())->view()) {
     toLocalFrame(m_focusedFrame.get())->selection().setFocused(focused);
     dispatchEventsOnWindowAndFocusedElement(
         toLocalFrame(m_focusedFrame.get())->document(), focused);
   }
 
   notifyFocusChangedObservers();
 }
 
 bool FocusController::setInitialFocus(WebFocusType type) {
-  bool didAdvanceFocus = advanceFocus(type, true);
+  bool didAdvanceFocus =
+      advanceFocus(type, true, InputDeviceCapabilities::Null);
 
   // If focus is being set initially, accessibility needs to be informed that
   // system focus has moved into the web area again, even if focus did not
   // change within WebCore.  PostNotification is called instead of
   // handleFocusedUIElementChanged, because this will send the notification even
   // if the element is the same.
   if (focusedOrMainFrame()->isLocalFrame()) {
     Document* document = toLocalFrame(focusedOrMainFrame())->document();
     if (AXObjectCache* cache = document->existingAXObjectCache())
       cache->handleInitialFocus();
   }
 
   return didAdvanceFocus;
 }
 
 bool FocusController::advanceFocus(
     WebFocusType type,
     bool initialFocus,
-    InputDeviceCapabilities* sourceCapabilities) {
+    const InputDeviceCapabilitiesValue& sourceCapabilities) {
   switch (type) {
     case WebFocusTypeForward:
     case WebFocusTypeBackward: {
       // We should never hit this when a RemoteFrame is focused, since the key
       // event that initiated focus advancement should've been routed to that
       // frame's process from the beginning.
       LocalFrame* startingFrame = toLocalFrame(focusedOrMainFrame());
       return advanceFocusInDocumentOrder(startingFrame, nullptr, type,
                                          initialFocus, sourceCapabilities);
     }
     case WebFocusTypeLeft:
     case WebFocusTypeRight:
     case WebFocusTypeUp:
     case WebFocusTypeDown:
       return advanceFocusDirectionally(type);
     default:
       NOTREACHED();
   }
 
   return false;
 }
 
 bool FocusController::advanceFocusAcrossFrames(
     WebFocusType type,
     RemoteFrame* from,
     LocalFrame* to,
-    InputDeviceCapabilities* sourceCapabilities) {
+    const InputDeviceCapabilitiesValue& sourceCapabilities) {
   // If we are shifting focus from a child frame to its parent, the
   // child frame has no more focusable elements, and we should continue
   // looking for focusable elements in the parent, starting from the <iframe>
   // element of the child frame.
   Element* start = nullptr;
   if (from->tree().parent() == to) {
     DCHECK(from->owner()->isLocal());
     start = toHTMLFrameOwnerElement(from->owner());
   }
 
   return advanceFocusInDocumentOrder(to, start, type, false,
                                      sourceCapabilities);
 }
 
 #if DCHECK_IS_ON()
 inline bool isNonFocusableShadowHost(const Element& element) {
   return isShadowHostWithoutCustomFocusLogic(element) && !element.isFocusable();
 }
 #endif
 
 bool FocusController::advanceFocusInDocumentOrder(
     LocalFrame* frame,
     Element* start,
     WebFocusType type,
     bool initialFocus,
-    InputDeviceCapabilities* sourceCapabilities) {
+    const InputDeviceCapabilitiesValue& sourceCapabilities) {
   DCHECK(frame);
   Document* document = frame->document();
   document->updateDistribution();
 
   Element* current = start;
 #if DCHECK_IS_ON()
   DCHECK(!current || !isNonFocusableShadowHost(*current));
 #endif
   if (!current && !initialFocus)
     current = document->sequentialFocusNavigationStartingPoint(type);
@@ skipping 128 matching lines @@
       selectionStartNode->ownerShadowHost() == newFocusedElement)
     return;
 
   selection.clear();
 }
 
 bool FocusController::setFocusedElement(Element* element,
                                         Frame* newFocusedFrame) {
   return setFocusedElement(
       element, newFocusedFrame,
-      FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
+      FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone,
+                  InputDeviceCapabilities::Null));
 }
 
 bool FocusController::setFocusedElement(Element* element,
                                         Frame* newFocusedFrame,
                                         const FocusParams& params) {
   LocalFrame* oldFocusedFrame = focusedFrame();
   Document* oldDocument =
       oldFocusedFrame ? oldFocusedFrame->document() : nullptr;
 
   Element* oldFocusedElement =
@@ skipping 231 matching lines @@
   if (focusCandidate.isOffscreenAfterScrolling) {
     Node* container = focusCandidate.enclosingScrollableBox;
     scrollInDirection(container, type);
     return true;
   }
 
   // We found a new focus node, navigate to it.
   Element* element = toElement(focusCandidate.focusableNode);
   DCHECK(element);
 
-  element->focus(FocusParams(SelectionBehaviorOnFocus::Reset, type, nullptr));
+  element->focus(FocusParams(SelectionBehaviorOnFocus::Reset, type,
+                             InputDeviceCapabilities::Null));
   return true;
 }
 
 bool FocusController::advanceFocusDirectionally(WebFocusType type) {
   // FIXME: Directional focus changes don't yet work with RemoteFrames.
   if (!focusedOrMainFrame()->isLocalFrame())
     return false;
   LocalFrame* curFrame = toLocalFrame(focusedOrMainFrame());
   DCHECK(curFrame);
 
@@ skipping 50 matching lines @@
     it->focusedFrameChanged();
 }
 
 DEFINE_TRACE(FocusController) {
   visitor->trace(m_page);
   visitor->trace(m_focusedFrame);
   visitor->trace(m_focusChangedObservers);
 }
 
 }  // namespace blink