reflow comments in core/events,core/fileapi

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
- * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 41 matching lines @@
 
 EventDispatcher::EventDispatcher(Node& node, Event* event)
     : m_node(node), m_event(event) {
   DCHECK(m_event.get());
   m_view = node.document().view();
   m_event->initEventPath(*m_node);
 }
 
 void EventDispatcher::dispatchScopedEvent(Node& node,
                                           EventDispatchMediator* mediator) {
-  // We need to set the target here because it can go away by the time we actually fire the event.
+  // We need to set the target here because it can go away by the time we
+  // actually fire the event.
   mediator->event().setTarget(
       EventPath::eventTargetRespectingTargetRules(node));
   ScopedEventQueue::instance()->enqueueEventDispatchMediator(mediator);
 }
 
 void EventDispatcher::dispatchSimulatedClick(
     Node& node,
     Event* underlyingEvent,
     SimulatedClickMouseEventOptions mouseEventOptions,
     SimulatedClickCreationScope creationScope) {
   // This persistent vector doesn't cause leaks, because added Nodes are removed
-  // before dispatchSimulatedClick() returns. This vector is here just to prevent
-  // the code from running into an infinite recursion of dispatchSimulatedClick().
+  // before dispatchSimulatedClick() returns. This vector is here just to
+  // prevent the code from running into an infinite recursion of
+  // dispatchSimulatedClick().
   DEFINE_STATIC_LOCAL(HeapHashSet<Member<Node>>,
                       nodesDispatchingSimulatedClicks,
                       (new HeapHashSet<Member<Node>>));
 
   if (isDisabledFormControl(&node))
     return;
 
   if (nodesDispatchingSimulatedClicks.contains(&node))
     return;
 
@@ skipping 31 matching lines @@
 
 DispatchEventResult EventDispatcher::dispatch() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                "EventDispatcher::dispatch");
 
 #if DCHECK_IS_ON()
   DCHECK(!m_eventDispatched);
   m_eventDispatched = true;
 #endif
   if (event().eventPath().isEmpty()) {
-    // eventPath() can be empty if event path is shrinked by relataedTarget retargeting.
+    // eventPath() can be empty if event path is shrinked by relataedTarget
+    // retargeting.
     return DispatchEventResult::NotCanceled;
   }
   m_event->eventPath().ensureWindowEventContext();
 
   m_event->setTarget(EventPath::eventTargetRespectingTargetRules(*m_node));
 #if DCHECK_IS_ON()
   DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
 #endif
   DCHECK(m_event->target());
   TRACE_EVENT1("devtools.timeline", "EventDispatch", "data",
@@ skipping 14 matching lines @@
   m_event->setCurrentTarget(nullptr);
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                        "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorUpdateCountersEvent::data());
 
   return EventTarget::dispatchEventResult(*m_event);
 }
 
 inline EventDispatchContinuation EventDispatcher::dispatchEventPreProcess(
     EventDispatchHandlingState*& preDispatchEventHandlerResult) {
-  // Give the target node a chance to do some work before DOM event handlers get a crack.
+  // Give the target node a chance to do some work before DOM event handlers get
+  // a crack.
   preDispatchEventHandlerResult =
       m_node->preDispatchEventHandler(m_event.get());
   return (m_event->eventPath().isEmpty() || m_event->propagationStopped())
              ? DoneDispatching
              : ContinueDispatching;
 }
 
 inline EventDispatchContinuation EventDispatcher::dispatchEventAtCapturing() {
-  // Trigger capturing event handlers, starting at the top and working our way down.
+  // Trigger capturing event handlers, starting at the top and working our way
+  // down.
   m_event->setEventPhase(Event::kCapturingPhase);
 
   if (m_event->eventPath().windowEventContext().handleLocalEvents(*m_event) &&
       m_event->propagationStopped())
     return DoneDispatching;
 
   for (size_t i = m_event->eventPath().size() - 1; i > 0; --i) {
     const NodeEventContext& eventContext = m_event->eventPath()[i];
     if (eventContext.currentTargetSameAsTarget())
       continue;
     eventContext.handleLocalEvents(*m_event);
     if (m_event->propagationStopped())
       return DoneDispatching;
   }
 
   return ContinueDispatching;
 }
 
 inline EventDispatchContinuation EventDispatcher::dispatchEventAtTarget() {
   m_event->setEventPhase(Event::kAtTarget);
   m_event->eventPath()[0].handleLocalEvents(*m_event);
   return m_event->propagationStopped() ? DoneDispatching : ContinueDispatching;
 }
 
 inline void EventDispatcher::dispatchEventAtBubbling() {
-  // Trigger bubbling event handlers, starting at the bottom and working our way up.
+  // Trigger bubbling event handlers, starting at the bottom and working our way
+  // up.
   size_t size = m_event->eventPath().size();
   for (size_t i = 1; i < size; ++i) {
     const NodeEventContext& eventContext = m_event->eventPath()[i];
     if (eventContext.currentTargetSameAsTarget()) {
       m_event->setEventPhase(Event::kAtTarget);
     } else if (m_event->bubbles() && !m_event->cancelBubble()) {
       m_event->setEventPhase(Event::kBubblingPhase);
     } else {
       if (m_event->bubbles() && m_event->cancelBubble() &&
           eventContext.node() &&
@@ skipping 22 matching lines @@
                       UseCounter::EventCancelBubbleAffected);
   }
 }
 
 inline void EventDispatcher::dispatchEventPostProcess(
     EventDispatchHandlingState* preDispatchEventHandlerResult) {
   m_event->setTarget(EventPath::eventTargetRespectingTargetRules(*m_node));
   m_event->setCurrentTarget(nullptr);
   m_event->setEventPhase(0);
 
-  // Pass the data from the preDispatchEventHandler to the postDispatchEventHandler.
+  // Pass the data from the preDispatchEventHandler to the
+  // postDispatchEventHandler.
   m_node->postDispatchEventHandler(m_event.get(),
                                    preDispatchEventHandlerResult);
 
   bool isClick = m_event->isMouseEvent() &&
                  toMouseEvent(*m_event).type() == EventTypeNames::click;
   if (isClick) {
-    // Fire an accessibility event indicating a node was clicked on.  This is safe if m_event->target()->toNode() returns null.
+    // Fire an accessibility event indicating a node was clicked on.  This is
+    // safe if m_event->target()->toNode() returns null.
     if (AXObjectCache* cache = m_node->document().existingAXObjectCache())
       cache->handleClicked(m_event->target()->toNode());
   }
 
   // The DOM Events spec says that events dispatched by JS (other than "click")
   // should not have their default handlers invoked.
   bool isTrustedOrClick =
       !RuntimeEnabledFeatures::trustedEventsDefaultActionEnabled() ||
       m_event->isTrusted() || isClick;
 
   // For Android WebView (distinguished by wideViewportQuirkEnabled)
   // enable untrusted events for mouse down on select elements because
   // fastclick.js seems to generate these. crbug.com/642698
   // TODO(dtapuska): Change this to a target SDK quirk crbug.com/643705
   if (!isTrustedOrClick && m_event->isMouseEvent() &&
       m_event->type() == EventTypeNames::mousedown &&
       isHTMLSelectElement(*m_node)) {
     if (Settings* settings = m_node->document().settings()) {
       isTrustedOrClick = settings->wideViewportQuirkEnabled();
     }
   }
 
-  // Call default event handlers. While the DOM does have a concept of preventing
-  // default handling, the detail of which handlers are called is an internal
-  // implementation detail and not part of the DOM.
+  // Call default event handlers. While the DOM does have a concept of
+  // preventing default handling, the detail of which handlers are called is an
+  // internal implementation detail and not part of the DOM.
   if (!m_event->defaultPrevented() && !m_event->defaultHandled() &&
       isTrustedOrClick) {
-    // Non-bubbling events call only one default event handler, the one for the target.
+    // Non-bubbling events call only one default event handler, the one for the
+    // target.
     m_node->willCallDefaultEventHandler(*m_event);
     m_node->defaultEventHandler(m_event.get());
     DCHECK(!m_event->defaultPrevented());
-    // For bubbling events, call default event handlers on the same targets in the
-    // same order as the bubbling phase.
+    // For bubbling events, call default event handlers on the same targets in
+    // the same order as the bubbling phase.
     if (!m_event->defaultHandled() && m_event->bubbles()) {
       size_t size = m_event->eventPath().size();
       for (size_t i = 1; i < size; ++i) {
         m_event->eventPath()[i].node()->willCallDefaultEventHandler(*m_event);
         m_event->eventPath()[i].node()->defaultEventHandler(m_event.get());
         DCHECK(!m_event->defaultPrevented());
         if (m_event->defaultHandled())
           break;
       }
     }
   }
 
   // Track the usage of sending a mousedown event to a select element to force
   // it to open. This measures a possible breakage of not allowing untrusted
   // events to open select boxes.
   if (!m_event->isTrusted() && m_event->isMouseEvent() &&
       m_event->type() == EventTypeNames::mousedown &&
       isHTMLSelectElement(*m_node)) {
     UseCounter::count(m_node->document(),
                       UseCounter::UntrustedMouseDownEventDispatchedToSelect);
   }
 }
 
 }  // namespace blink