reflow comments in core/frame

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 115 matching lines @@
 
   // Eager finalization is needed to promptly stop this timer object.
   // (see DOMTimer comment for more.)
   EAGERLY_FINALIZE();
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_event);
     visitor->trace(m_window);
     SuspendableTimer::trace(visitor);
   }
 
-  // TODO(alexclarke): Override timerTaskRunner() to pass in a document specific default task runner.
+  // TODO(alexclarke): Override timerTaskRunner() to pass in a document specific
+  // default task runner.
 
  private:
   void fired() override {
     InspectorInstrumentation::AsyncTask asyncTask(m_window->document(), this);
     m_disposalAllowed = false;
     m_window->postMessageTimerFired(this);
     dispose();
     // Oilpan optimization: unregister as an observer right away.
     clearContext();
   }
@@ skipping 151 matching lines @@
     m_navigator->setLanguagesChanged();
 
   dispatchEvent(Event::create(EventTypeNames::languagechange));
 }
 
 Document* LocalDOMWindow::createDocument(const String& mimeType,
                                          const DocumentInit& init,
                                          bool forceXHTML) {
   Document* document = nullptr;
   if (forceXHTML) {
-    // This is a hack for XSLTProcessor. See XSLTProcessor::createDocumentFromSource().
+    // This is a hack for XSLTProcessor. See
+    // XSLTProcessor::createDocumentFromSource().
     document = Document::create(init);
   } else {
     document = DOMImplementation::createDocument(
         mimeType, init,
         init.frame() ? init.frame()->inViewSourceMode() : false);
     if (document->isPluginDocument() && document->isSandboxed(SandboxPlugins))
       document = SinkDocument::create(init);
   }
 
   return document;
@@ skipping 65 matching lines @@
 }
 
 void LocalDOMWindow::documentWasClosed() {
   dispatchWindowLoadEvent();
   enqueuePageshowEvent(PageshowEventNotPersisted);
   if (m_pendingStateObject)
     enqueuePopstateEvent(m_pendingStateObject.release());
 }
 
 void LocalDOMWindow::enqueuePageshowEvent(PageshowEventPersistence persisted) {
-  // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36334 Pageshow event needs to fire asynchronously.
-  // As per spec pageshow must be triggered asynchronously.
-  // However to be compatible with other browsers blink fires pageshow synchronously.
+  // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36334 Pageshow event needs
+  // to fire asynchronously.  As per spec pageshow must be triggered
+  // asynchronously.  However to be compatible with other browsers blink fires
+  // pageshow synchronously.
   dispatchEvent(
       PageTransitionEvent::create(EventTypeNames::pageshow, persisted),
       m_document.get());
 }
 
 void LocalDOMWindow::enqueueHashchangeEvent(const String& oldURL,
                                             const String& newURL) {
   enqueueWindowEvent(HashChangeEvent::create(oldURL, newURL));
 }
 
 void LocalDOMWindow::enqueuePopstateEvent(
     PassRefPtr<SerializedScriptValue> stateObject) {
-  // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36202 Popstate event needs to fire asynchronously
+  // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36202 Popstate event needs
+  // to fire asynchronously
   dispatchEvent(PopStateEvent::create(std::move(stateObject), history()));
 }
 
 void LocalDOMWindow::statePopped(
     PassRefPtr<SerializedScriptValue> stateObject) {
   if (!frame())
     return;
 
   // Per step 11 of section 6.5.9 (history traversal) of the HTML5 spec, we
   // defer firing of popstate until we're in the complete state.
   if (document()->isLoadCompleted())
     enqueuePopstateEvent(std::move(stateObject));
   else
     m_pendingStateObject = stateObject;
 }
 
 LocalDOMWindow::~LocalDOMWindow() {
   // Cleared when detaching document.
   ASSERT(!m_eventQueue);
 }
 
 void LocalDOMWindow::dispose() {
-  // Oilpan: should the LocalDOMWindow be GCed along with its LocalFrame without the
-  // frame having first notified its observers of imminent destruction, the
+  // Oilpan: should the LocalDOMWindow be GCed along with its LocalFrame without
+  // the frame having first notified its observers of imminent destruction, the
   // LocalDOMWindow will not have had an opportunity to remove event listeners.
   //
-  // Arrange for that removal to happen using a prefinalizer action. Making LocalDOMWindow
-  // eager finalizable is problematic as other eagerly finalized objects may well
-  // want to access their associated LocalDOMWindow from their destructors.
+  // Arrange for that removal to happen using a prefinalizer action. Making
+  // LocalDOMWindow eager finalizable is problematic as other eagerly finalized
+  // objects may well want to access their associated LocalDOMWindow from their
+  // destructors.
   if (!frame())
     return;
 
   removeAllEventListeners();
 }
 
 ExecutionContext* LocalDOMWindow::getExecutionContext() const {
   return m_document.get();
 }
 
@@ skipping 186 matching lines @@
 
 void LocalDOMWindow::removePostMessageTimer(PostMessageTimer* timer) {
   m_postMessageTimers.remove(timer);
 }
 
 void LocalDOMWindow::dispatchMessageEventWithOriginCheck(
     SecurityOrigin* intendedTargetOrigin,
     Event* event,
     std::unique_ptr<SourceLocation> location) {
   if (intendedTargetOrigin) {
-    // Check target origin now since the target document may have changed since the timer was scheduled.
+    // Check target origin now since the target document may have changed since
+    // the timer was scheduled.
     SecurityOrigin* securityOrigin = document()->getSecurityOrigin();
     bool validTarget =
         intendedTargetOrigin->isSameSchemeHostPortAndSuborigin(securityOrigin);
     if (securityOrigin->hasSuborigin() &&
         securityOrigin->suborigin()->policyContains(
             Suborigin::SuboriginPolicyOptions::UnsafePostMessageReceive))
       validTarget = intendedTargetOrigin->isSameSchemeHostPort(securityOrigin);
 
     if (!validTarget) {
       String message = ExceptionMessages::failedToExecute(
@@ skipping 165 matching lines @@
 bool LocalDOMWindow::find(const String& string,
                           bool caseSensitive,
                           bool backwards,
                           bool wrap,
                           bool wholeWord,
                           bool /*searchInFrames*/,
                           bool /*showDialog*/) const {
   if (!isCurrentlyDisplayedInFrame())
     return false;
 
-  // Up-to-date, clean tree is required for finding text in page, since it relies
-  // on TextIterator to look over the text.
+  // Up-to-date, clean tree is required for finding text in page, since it
+  // relies on TextIterator to look over the text.
   document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   // FIXME (13016): Support searchInFrames and showDialog
   FindOptions options =
       (backwards ? Backwards : 0) | (caseSensitive ? 0 : CaseInsensitive) |
       (wrap ? WrapAround : 0) | (wholeWord ? WholeWord | AtWordStarts : 0);
   return frame()->editor().findString(string, options);
 }
 
 bool LocalDOMWindow::offscreenBuffering() const {
@@ skipping 44 matching lines @@
   if (!host)
     return FloatSize();
 
   // The main frame's viewport size depends on the page scale. Since the
   // initial page scale depends on the content width and is set after a
   // layout, perform one now so queries during page load will use the up to
   // date viewport.
   if (host->settings().viewportEnabled() && frame()->isMainFrame())
     document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
-  // FIXME: This is potentially too much work. We really only need to know the dimensions of the parent frame's layoutObject.
+  // FIXME: This is potentially too much work. We really only need to know the
+  // dimensions of the parent frame's layoutObject.
   if (Frame* parent = frame()->tree().parent()) {
     if (parent && parent->isLocalFrame())
       toLocalFrame(parent)
           ->document()
           ->updateStyleAndLayoutIgnorePendingStylesheets();
   }
 
   return frame()->isMainFrame() && !host->settings().inertVisualViewport()
              ? FloatSize(host->visualViewport().visibleRect().size())
              : FloatSize(view->visibleContentRect(scrollbarInclusion).size());
@@ skipping 234 matching lines @@
   if (!view)
     return;
 
   FrameHost* host = frame()->host();
   if (!host)
     return;
 
   x = ScrollableArea::normalizeNonFiniteScroll(x);
   y = ScrollableArea::normalizeNonFiniteScroll(y);
 
-  // It is only necessary to have an up-to-date layout if the position may be clamped,
-  // which is never the case for (0, 0).
+  // It is only necessary to have an up-to-date layout if the position may be
+  // clamped, which is never the case for (0, 0).
   if (x || y)
     document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DoublePoint layoutPos(x * frame()->pageZoomFactor(),
                         y * frame()->pageZoomFactor());
   ScrollableArea* viewport = host->settings().inertVisualViewport()
                                  ? view->layoutViewportScrollableArea()
                                  : view->getScrollableArea();
   viewport->setScrollPosition(layoutPos, ProgrammaticScroll,
                               ScrollBehaviorAuto);
 }
 
 void LocalDOMWindow::scrollTo(const ScrollToOptions& scrollToOptions) const {
   if (!isCurrentlyDisplayedInFrame())
     return;
 
   FrameView* view = frame()->view();
   if (!view)
     return;
 
   FrameHost* host = frame()->host();
   if (!host)
     return;
 
-  // It is only necessary to have an up-to-date layout if the position may be clamped,
-  // which is never the case for (0, 0).
+  // It is only necessary to have an up-to-date layout if the position may be
+  // clamped, which is never the case for (0, 0).
   if (!scrollToOptions.hasLeft() || !scrollToOptions.hasTop() ||
       scrollToOptions.left() || scrollToOptions.top()) {
     document()->updateStyleAndLayoutIgnorePendingStylesheets();
   }
 
   double scaledX = 0.0;
   double scaledY = 0.0;
 
   ScrollableArea* viewport = host->settings().inertVisualViewport()
                                  ? view->layoutViewportScrollableArea()
@@ skipping 22 matching lines @@
 void LocalDOMWindow::moveBy(int x, int y) const {
   if (!frame() || !frame()->isMainFrame())
     return;
 
   FrameHost* host = frame()->host();
   if (!host)
     return;
 
   IntRect windowRect = host->chromeClient().rootWindowRect();
   windowRect.saturatedMove(x, y);
-  // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
+  // Security check (the spec talks about UniversalBrowserWrite to disable this
+  // check...)
   host->chromeClient().setWindowRectWithAdjustment(windowRect, *frame());
 }
 
 void LocalDOMWindow::moveTo(int x, int y) const {
   if (!frame() || !frame()->isMainFrame())
     return;
 
   FrameHost* host = frame()->host();
   if (!host)
     return;
 
   IntRect windowRect = host->chromeClient().rootWindowRect();
   windowRect.setLocation(IntPoint(x, y));
-  // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
+  // Security check (the spec talks about UniversalBrowserWrite to disable this
+  // check...)
   host->chromeClient().setWindowRectWithAdjustment(windowRect, *frame());
 }
 
 void LocalDOMWindow::resizeBy(int x, int y) const {
   if (!frame() || !frame()->isMainFrame())
     return;
 
   FrameHost* host = frame()->host();
   if (!host)
     return;
@@ skipping 81 matching lines @@
   for (auto& it : m_eventListenerObservers) {
     it->didAddEventListener(this, eventType);
   }
 
   if (eventType == EventTypeNames::unload) {
     UseCounter::count(document(), UseCounter::DocumentUnloadRegistered);
     addUnloadEventListener(this);
   } else if (eventType == EventTypeNames::beforeunload) {
     UseCounter::count(document(), UseCounter::DocumentBeforeUnloadRegistered);
     if (allowsBeforeUnloadListeners(this)) {
-      // This is confusingly named. It doesn't actually add the listener. It just increments a count
-      // so that we know we have listeners registered for the purposes of determining if we can
-      // fast terminate the renderer process.
+      // This is confusingly named. It doesn't actually add the listener. It
+      // just increments a count so that we know we have listeners registered
+      // for the purposes of determining if we can fast terminate the renderer
+      // process.
       addBeforeUnloadEventListener(this);
     } else {
       // Subframes return false from allowsBeforeUnloadListeners.
       UseCounter::count(document(), UseCounter::SubFrameBeforeUnloadRegistered);
     }
   }
 }
 
 void LocalDOMWindow::removedEventListener(
     const AtomicString& eventType,
@@ skipping 27 matching lines @@
 void LocalDOMWindow::dispatchLoadEvent() {
   Event* loadEvent(Event::create(EventTypeNames::load));
   if (frame() && frame()->loader().documentLoader() &&
       !frame()->loader().documentLoader()->timing().loadEventStart()) {
     DocumentLoader* documentLoader = frame()->loader().documentLoader();
     DocumentLoadTiming& timing = documentLoader->timing();
     timing.markLoadEventStart();
     dispatchEvent(loadEvent, document());
     timing.markLoadEventEnd();
     DCHECK(documentLoader->fetcher());
-    // If fetcher->countPreloads() is not empty here, it's full of link preloads,
-    // as speculatove preloads were cleared at DCL.
+    // If fetcher->countPreloads() is not empty here, it's full of link
+    // preloads, as speculatove preloads were cleared at DCL.
     if (frame() && documentLoader == frame()->loader().documentLoader() &&
         documentLoader->fetcher()->countPreloads())
       m_unusedPreloadsTimer.startOneShot(unusedPreloadTimeoutInSeconds,
                                          BLINK_FROM_HERE);
   } else {
     dispatchEvent(loadEvent, document());
   }
 
   // For load events, send a separate load event to the enclosing frame only.
   // This is a DOM extension and is independent of bubbling/capturing rules of
@@ skipping 68 matching lines @@
     return nullptr;
   LocalFrame* firstFrame = enteredWindow->frame();
   if (!firstFrame)
     return nullptr;
 
   UseCounter::count(*activeDocument, UseCounter::DOMWindowOpen);
   if (!windowFeaturesString.isEmpty())
     UseCounter::count(*activeDocument, UseCounter::DOMWindowOpenFeatures);
 
   if (!enteredWindow->allowPopUp()) {
-    // Because FrameTree::find() returns true for empty strings, we must check for empty frame names.
-    // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
+    // Because FrameTree::find() returns true for empty strings, we must check
+    // for empty frame names.  Otherwise, illegitimate window.open() calls with
+    // no name will pass right through the popup blocker.
     if (frameName.isEmpty() || !frame()->tree().find(frameName))
       return nullptr;
   }
 
   // Get the target frame for the special cases of _top and _parent.
   // In those cases, we schedule a location change right now and return early.
   Frame* targetFrame = nullptr;
   if (frameName == "_top") {
     targetFrame = frame()->tree().top();
   } else if (frameName == "_parent") {
@@ skipping 54 matching lines @@
 
 LocalFrame* LocalDOMWindow::frame() const {
   // If the LocalDOMWindow still has a frame reference, that frame must point
   // back to this LocalDOMWindow: otherwise, it's easy to get into a situation
   // where script execution leaks between different LocalDOMWindows.
   SECURITY_DCHECK(!m_frame || m_frame->domWindow() == this);
   return m_frame;
 }
 
 }  // namespace blink