reflow comments in web/

third_party/WebKit/Source/web/WebLocalFrameImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 // WebView (for the toplevel frame only)
 //    O
 //    |           WebFrame
 //    |              O
 //    |              |
 //   Page O------- LocalFrame (m_mainFrame) O-------O FrameView
 //                   ||
 //                   ||
 //               FrameLoader
 //
-// FrameLoader and LocalFrame are formerly one object that was split apart because
-// it got too big. They basically have the same lifetime, hence the double line.
+// FrameLoader and LocalFrame are formerly one object that was split apart
+// because it got too big. They basically have the same lifetime, hence the
+// double line.
 //
 // From the perspective of the embedder, WebFrame is simply an object that it
 // allocates by calling WebFrame::create() and must be freed by calling close().
 // Internally, WebFrame is actually refcounted and it holds a reference to its
 // corresponding LocalFrame in blink.
 //
-// Oilpan: the middle objects + Page in the above diagram are Oilpan heap allocated,
-// WebView and FrameView are currently not. In terms of ownership and control, the
-// relationships stays the same, but the references from the off-heap WebView to the
-// on-heap Page is handled by a Persistent<>, not a RefPtr<>. Similarly, the mutual
-// strong references between the on-heap LocalFrame and the off-heap FrameView
-// is through a RefPtr (from LocalFrame to FrameView), and a Persistent refers
-// to the LocalFrame in the other direction.
+// Oilpan: the middle objects + Page in the above diagram are Oilpan heap
+// allocated, WebView and FrameView are currently not. In terms of ownership
+// and control, the relationships stays the same, but the references from the
+// off-heap WebView to the on-heap Page is handled by a Persistent<>, not a
+// RefPtr<>. Similarly, the mutual strong references between the on-heap
+// LocalFrame and the off-heap FrameView is through a RefPtr (from LocalFrame
+// to FrameView), and a Persistent refers to the LocalFrame in the other
+// direction.
 //
-// From the embedder's point of view, the use of Oilpan brings no changes. close()
-// must still be used to signal that the embedder is through with the WebFrame.
-// Calling it will bring about the release and finalization of the frame object,
-// and everything underneath.
+// From the embedder's point of view, the use of Oilpan brings no changes.
+// close() must still be used to signal that the embedder is through with the
+// WebFrame.  Calling it will bring about the release and finalization of the
+// frame object, and everything underneath.
 //
 // How frames are destroyed
 // ------------------------
 //
 // The main frame is never destroyed and is re-used. The FrameLoader is re-used
 // and a reference to the main frame is kept by the Page.
 //
 // When frame content is replaced, all subframes are destroyed. This happens
 // in Frame::detachChildren for each subframe in a pre-order depth-first
 // traversal. Note that child node order may not match DOM node order!
 // detachChildren() (virtually) calls Frame::detach(), which again calls
-// FrameLoaderClient::detached(). This triggers WebFrame to clear its reference to
-// LocalFrame. FrameLoaderClient::detached() also notifies the embedder via WebFrameClient
-// that the frame is detached. Most embedders will invoke close() on the WebFrame
-// at this point, triggering its deletion unless something else is still retaining a reference.
+// FrameLoaderClient::detached(). This triggers WebFrame to clear its reference
+// to LocalFrame. FrameLoaderClient::detached() also notifies the embedder via
+// WebFrameClient that the frame is detached. Most embedders will invoke
+// close() on the WebFrame at this point, triggering its deletion unless
+// something else is still retaining a reference.
 //
-// The client is expected to be set whenever the WebLocalFrameImpl is attached to
-// the DOM.
+// The client is expected to be set whenever the WebLocalFrameImpl is attached
+// to the DOM.
 
 #include "web/WebLocalFrameImpl.h"
 
 #include "bindings/core/v8/BindingSecurity.h"
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/ScriptValue.h"
@@ skipping 889 matching lines @@
     unsigned length,
     WebRect& rectInViewport) const {
   if ((location + length < location) && (location + length))
     length = 0;
 
   Element* editable =
       frame()->selection().rootEditableElementOrDocumentElement();
   if (!editable)
     return false;
 
-  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   editable->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   const EphemeralRange range =
       PlainTextRange(location, location + length).createRange(*editable);
   if (range.isNull())
     return false;
   IntRect intRect = frame()->editor().firstRectForRange(range);
   rectInViewport = WebRect(intRect);
   rectInViewport = frame()->view()->contentsToViewport(rectInViewport);
   return true;
@@ skipping 67 matching lines @@
 }
 
 bool WebLocalFrameImpl::isSpellCheckingEnabled() const {
   return frame()->spellChecker().isSpellCheckingEnabled();
 }
 
 void WebLocalFrameImpl::requestTextChecking(const WebElement& webElement) {
   if (webElement.isNull())
     return;
 
-  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame()->document()->lifecycle());
 
   frame()->spellChecker().requestTextChecking(
       *webElement.constUnwrap<Element>());
 }
 
 void WebLocalFrameImpl::replaceMisspelledRange(const WebString& text) {
-  // If this caret selection has two or more markers, this function replace the range covered by the first marker with the specified word as Microsoft Word does.
+  // If this caret selection has two or more markers, this function replace the
+  // range covered by the first marker with the specified word as Microsoft Word
+  // does.
   if (pluginContainerFromFrame(frame()))
     return;
   frame()->spellChecker().replaceMisspelledRange(text);
 }
 
 void WebLocalFrameImpl::removeSpellingMarkers() {
   frame()->spellChecker().removeSpellingMarkers();
 }
 
 bool WebLocalFrameImpl::hasSelection() const {
@@ skipping 32 matching lines @@
   if (pluginContainer)
     return pluginContainer->plugin()->selectionAsMarkup();
 
   return frame()->selection().selectedHTMLForClipboard();
 }
 
 void WebLocalFrameImpl::selectWordAroundPosition(LocalFrame* frame,
                                                  VisiblePosition position) {
   TRACE_EVENT0("blink", "WebLocalFrameImpl::selectWordAroundPosition");
 
-  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   frame->selection().selectWordAroundPosition(position);
 }
 
 bool WebLocalFrameImpl::selectWordAroundCaret() {
   TRACE_EVENT0("blink", "WebLocalFrameImpl::selectWordAroundCaret");
   FrameSelection& selection = frame()->selection();
   if (selection.isNone() || selection.isRange())
     return false;
 
-  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   return frame()->selection().selectWordAroundPosition(
       selection.selection().visibleStart());
 }
 
 void WebLocalFrameImpl::selectRange(const WebPoint& baseInViewport,
                                     const WebPoint& extentInViewport) {
   moveRangeSelection(baseInViewport, extentInViewport);
 }
 
 void WebLocalFrameImpl::selectRange(const WebRange& webRange) {
   TRACE_EVENT0("blink", "WebLocalFrameImpl::selectRange");
 
-  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame()->document()->lifecycle());
 
   frame()->selection().setSelectedRange(
       webRange.createEphemeralRange(frame()), VP_DEFAULT_AFFINITY,
       SelectionDirectionalMode::NonDirectional, NotUserTriggered);
 }
 
 WebString WebLocalFrameImpl::rangeAsText(const WebRange& webRange) {
-  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame()->document()->lifecycle());
 
   return plainText(webRange.createEphemeralRange(frame()),
                    TextIteratorEmitsObjectReplacementCharacter);
 }
 
 void WebLocalFrameImpl::moveRangeSelectionExtent(const WebPoint& point) {
@@ skipping 240 matching lines @@
 }
 
 WebString WebLocalFrameImpl::layerTreeAsText(bool showDebugInfo) const {
   if (!frame())
     return WebString();
 
   return WebString(frame()->layerTreeAsText(
       showDebugInfo ? LayerTreeIncludesDebugInfo : LayerTreeNormal));
 }
 
-// WebLocalFrameImpl public ---------------------------------------------------------
+// WebLocalFrameImpl public --------------------------------------------------
 
 WebLocalFrame* WebLocalFrame::create(WebTreeScopeType scope,
                                      WebFrameClient* client,
                                      WebFrame* opener) {
   return WebLocalFrameImpl::create(scope, client, opener);
 }
 
 WebLocalFrame* WebLocalFrame::createProvisional(WebFrameClient* client,
                                                 WebRemoteFrame* oldWebFrame,
                                                 WebSandboxFlags flags) {
@@ skipping 14 matching lines @@
     WebSandboxFlags flags) {
   WebLocalFrameImpl* webFrame = new WebLocalFrameImpl(oldWebFrame, client);
   Frame* oldFrame = oldWebFrame->toImplBase()->frame();
   webFrame->setParent(oldWebFrame->parent());
   webFrame->setOpener(oldWebFrame->opener());
   // Note: this *always* temporarily sets a frame owner, even for main frames!
   // When a core Frame is created with no owner, it attempts to set itself as
   // the main frame of the Page. However, this is a provisional frame, and may
   // disappear, so Page::m_mainFrame can't be updated just yet.
   FrameOwner* tempOwner = DummyFrameOwner::create();
-  // TODO(dcheng): This block is very similar to initializeCoreFrame. Try to reuse it here.
+  // TODO(dcheng): This block is very similar to initializeCoreFrame. Try to
+  // reuse it here.
   LocalFrame* frame = LocalFrame::create(
       webFrame->m_frameLoaderClientImpl.get(), oldFrame->host(), tempOwner,
       client ? client->interfaceProvider() : nullptr);
   // Set the name and unique name directly, bypassing any of the normal logic
   // to calculate unique name.
   frame->tree().setPrecalculatedName(
       toWebRemoteFrameImpl(oldWebFrame)->frame()->tree().name(),
       toWebRemoteFrameImpl(oldWebFrame)->frame()->tree().uniqueName());
   webFrame->setCoreFrame(frame);
 
@@ skipping 102 matching lines @@
   if (!webframeChild)
     return nullptr;
 
   webframeChild->initializeCoreFrame(frame()->host(), ownerElement, name,
                                      uniqueName);
   // Initializing the core frame may cause the new child to be detached, since
   // it may dispatch a load event in the parent.
   if (!webframeChild->parent())
     return nullptr;
 
-  // If we're moving in the back/forward list, we might want to replace the content
-  // of this child frame with whatever was there at that point.
+  // If we're moving in the back/forward list, we might want to replace the
+  // content of this child frame with whatever was there at that point.
   HistoryItem* childItem = nullptr;
   if (isBackForwardLoadType(frame()->loader().loadType()) &&
       !frame()->document()->loadEventFinished())
     childItem = webframeChild->client()->historyItemForNewChildFrame();
 
   FrameLoadRequest newRequest = request;
   FrameLoadType loadType = FrameLoadTypeStandard;
   if (childItem) {
     newRequest = FrameLoadRequest(
         request.originDocument(),
@@ skipping 85 matching lines @@
   if (!m_textFinder || !m_textFinder->activeMatchFrame())
     return;
 
   if (Range* activeMatch = m_textFinder->activeMatch()) {
     // If the user has set the selection since the match was found, we
     // don't focus anything.
     VisibleSelection selection(frame()->selection().selection());
     if (!selection.isNone())
       return;
 
-    // Need to clean out style and layout state before querying Element::isFocusable().
+    // Need to clean out style and layout state before querying
+    // Element::isFocusable().
     frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
     // Try to find the first focusable node up the chain, which will, for
     // example, focus links if we have found text within the link.
     Node* node = activeMatch->firstNode();
     if (node && node->isInShadowTree()) {
       if (Node* host = node->ownerShadowHost()) {
         if (isHTMLInputElement(*host) || isHTMLTextAreaElement(*host))
           node = host;
       }
@@ skipping 36 matching lines @@
     // active match as the selection (so that when you end the Find session,
     // you'll have the last thing you found highlighted) and make sure that
     // we have nothing focused (otherwise you might have text selected but
     // a link focused, which is weird).
     frame()->selection().setSelection(createVisibleSelection(activeMatchRange));
     frame()->document()->clearFocusedElement();
 
     // Finally clear the active match, for two reasons:
     // We just finished the find 'session' and we don't want future (potentially
     // unrelated) find 'sessions' operations to start at the same place.
-    // The WebLocalFrameImpl could get reused and the activeMatch could end up pointing
-    // to a document that is no longer valid. Keeping an invalid reference around
-    // is just asking for trouble.
+    // The WebLocalFrameImpl could get reused and the activeMatch could end up
+    // pointing to a document that is no longer valid. Keeping an invalid
+    // reference around is just asking for trouble.
     m_textFinder->resetActiveMatch();
   }
 }
 
 void WebLocalFrameImpl::didFail(const ResourceError& error,
                                 bool wasProvisional,
                                 HistoryCommitType commitType) {
   if (!client())
     return;
   WebURLError webError = error;
@@ skipping 40 matching lines @@
   // key difference is that we need to suppress loading the string result
   // from evaluating the JS URL if executing the JS URL resulted in a
   // location change. We also allow a JS URL to be loaded even if scripts on
   // the page are otherwise disabled.
 
   if (!frame()->document() || !frame()->page())
     return;
 
   Document* ownerDocument(frame()->document());
 
-  // Protect privileged pages against bookmarklets and other javascript manipulations.
+  // Protect privileged pages against bookmarklets and other javascript
+  // manipulations.
   if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(
           frame()->document()->url().protocol()))
     return;
 
   String script = decodeURLEscapeSequences(
       url.getString().substring(strlen("javascript:")));
   UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
   v8::HandleScope handleScope(toIsolate(frame()));
   v8::Local<v8::Value> result =
       frame()->script().executeScriptInMainWorldAndReturnValue(
@@ skipping 276 matching lines @@
                              const WebString& searchText,
                              const WebFindOptions& options,
                              bool wrapWithinFrame,
                              bool* activeNow) {
   if (!frame())
     return false;
 
   // Unlikely, but just in case we try to find-in-page on a detached frame.
   DCHECK(frame()->host());
 
-  // 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.
   frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   return ensureTextFinder().find(identifier, searchText, options,
                                  wrapWithinFrame, activeNow);
 }
 
 void WebLocalFrameImpl::stopFinding(StopFindAction action) {
   bool clearSelection = action == StopFindActionClearSelection;
   if (clearSelection)
     executeCommand(WebString::fromUTF8("Unselect"));
@@ skipping 175 matching lines @@
     feature = UseCounter::ChromeLoadTimesNpnNegotiatedProtocol;
   } else if (metric == "wasAlternateProtocolAvailable") {
     feature = UseCounter::ChromeLoadTimesWasAlternateProtocolAvailable;
   } else if (metric == "connectionInfo") {
     feature = UseCounter::ChromeLoadTimesConnectionInfo;
   }
   UseCounter::count(frame(), feature);
 }
 
 }  // namespace blink