Reflow comments in core/loader

third_party/WebKit/Source/core/loader/FrameLoader.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
- * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 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:
  *
  * 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 66 matching lines @@
 
   void init();
 
   ResourceRequest resourceRequestForReload(
       FrameLoadType,
       const KURL& overrideURL = KURL(),
       ClientRedirectPolicy = ClientRedirectPolicy::NotClientRedirect);
 
   ProgressTracker& progress() const { return *m_progressTracker; }
 
-  // Starts a load. It will eventually call startLoad() or
-  // loadInSameDocument(). For history navigations or reloads, an appropriate
-  // FrameLoadType should be given. Otherwise, FrameLoadTypeStandard should be
-  // used (and the final FrameLoadType will be computed). For history
-  // navigations, a history item and a HistoryLoadType should also be provided.
+  // Starts a load. It will eventually call startLoad() or loadInSameDocument().
+  // For history navigations or reloads, an appropriate FrameLoadType should be
+  // given. Otherwise, FrameLoadTypeStandard should be used (and the final
+  // FrameLoadType will be computed). For history navigations, a history item
+  // and a HistoryLoadType should also be provided.
   void load(const FrameLoadRequest&,
             FrameLoadType = FrameLoadTypeStandard,
             HistoryItem* = nullptr,
             HistoryLoadType = HistoryDifferentDocumentLoad);
 
   static void reportLocalLoadFailed(LocalFrame*, const String& url);
 
-  // Warning: stopAllLoaders can and will detach the LocalFrame out from under you. All callers need to either protect the LocalFrame
-  // or guarantee they won't in any way access the LocalFrame after stopAllLoaders returns.
+  // Warning: stopAllLoaders can and will detach the LocalFrame out from under
+  // you. All callers need to either protect the LocalFrame or guarantee they
+  // won't in any way access the LocalFrame after stopAllLoaders returns.
   void stopAllLoaders();
 
-  // FIXME: clear() is trying to do too many things. We should break it down into smaller functions.
+  // FIXME: clear() is trying to do too many things. We should break it down
+  // into smaller functions.
   void clear();
 
   void replaceDocumentWhileExecutingJavaScriptURL(const String& source,
                                                   Document* ownerDocument);
 
-  // Notifies the client that the initial empty document has been accessed,
-  // and thus it is no longer safe to show a provisional URL above the
-  // document without risking a URL spoof. The client must not call back into
-  // JavaScript.
+  // Notifies the client that the initial empty document has been accessed, and
+  // thus it is no longer safe to show a provisional URL above the document
+  // without risking a URL spoof. The client must not call back into JavaScript.
   void didAccessInitialDocument();
 
   DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
   DocumentLoader* provisionalDocumentLoader() const {
     return m_provisionalDocumentLoader.get();
   }
 
   void loadFailed(DocumentLoader*, const ResourceError&);
 
   bool isLoadingMainFrame() const;
@@ skipping 17 matching lines @@
 
   void receivedFirstData();
 
   String userAgent() const;
 
   void dispatchDidClearWindowObjectInMainWorld();
   void dispatchDidClearDocumentOfWindowObject();
   void dispatchDocumentElementAvailable();
   void runScriptsAtDocumentElementAvailable();
 
-  // The following sandbox flags will be forced, regardless of changes to
-  // the sandbox attribute of any parent frames.
+  // The following sandbox flags will be forced, regardless of changes to the
+  // sandbox attribute of any parent frames.
   void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
   SandboxFlags effectiveSandboxFlags() const;
 
   WebInsecureRequestPolicy getInsecureRequestPolicy() const;
   SecurityContext::InsecureNavigationsSet* insecureNavigationsToUpgrade() const;
   void upgradeInsecureRequest(ResourceRequest&, Document*) const;
 
   Frame* opener();
   void setOpener(LocalFrame*);
 
   void detach();
 
   void finishedParsing();
   void checkCompleted();
 
   void receivedMainResourceRedirect(const KURL& newURL);
 
   void clearProvisionalHistoryItem();
 
-  // This prepares the FrameLoader for the next commit. It will dispatch
-  // unload events, abort XHR requests and detach the document. Returns true
-  // if the frame is ready to receive the next commit, or false otherwise.
+  // This prepares the FrameLoader for the next commit. It will dispatch unload
+  // events, abort XHR requests and detach the document. Returns true if the
+  // frame is ready to receive the next commit, or false otherwise.
   bool prepareForCommit();
 
   void commitProvisionalLoad();
 
   FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
 
   void applyUserAgent(ResourceRequest&);
 
   bool shouldInterruptLoadForXFrameOptions(const String&,
                                            const KURL&,
@@ skipping 63 matching lines @@
 
   void scheduleCheckCompleted();
 
   void detachDocumentLoader(Member<DocumentLoader>&);
 
   std::unique_ptr<TracedValue> toTracedValue() const;
   void takeObjectSnapshot() const;
 
   Member<LocalFrame> m_frame;
 
-  // FIXME: These should be std::unique_ptr<T> to reduce build times and simplify
-  // header dependencies unless performance testing proves otherwise.
+  // FIXME: These should be std::unique_ptr<T> to reduce build times and
+  // simplify header dependencies unless performance testing proves otherwise.
   // Some of these could be lazily created for memory savings on devices.
   mutable FrameLoaderStateMachine m_stateMachine;
 
   Member<ProgressTracker> m_progressTracker;
 
   FrameLoadType m_loadType;
 
-  // Document loaders for the three phases of frame loading. Note that while
-  // a new request is being loaded, the old document loader may still be referenced.
-  // E.g. while a new request is in the "policy" state, the old document loader may
-  // be consulted in particular as it makes sense to imply certain settings on the new loader.
+  // Document loaders for the three phases of frame loading. Note that while a
+  // new request is being loaded, the old document loader may still be
+  // referenced. E.g. while a new request is in the "policy" state, the old
+  // document loader may be consulted in particular as it makes sense to imply
+  // certain settings on the new loader.
   Member<DocumentLoader> m_documentLoader;
   Member<DocumentLoader> m_provisionalDocumentLoader;
 
   Member<HistoryItem> m_currentItem;
   Member<HistoryItem> m_provisionalItem;
 
   class DeferredHistoryLoad
       : public GarbageCollectedFinalized<DeferredHistoryLoad> {
     WTF_MAKE_NONCOPYABLE(DeferredHistoryLoad);
 
@@ skipping 31 matching lines @@
   SandboxFlags m_forcedSandboxFlags;
 
   bool m_dispatchingDidClearWindowObjectInMainWorld;
   bool m_protectProvisionalLoader;
   bool m_isNavigationHandledByClient;
 };
 
 }  // namespace blink
 
 #endif  // FrameLoader_h