Reflow comments in core/loader

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

 /*
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
+ * reserved.
  * Copyright (C) 2012 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
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 115 matching lines @@
   virtual void progressEstimateChanged(double progressEstimate) = 0;
   virtual void didStopLoading() = 0;
 
   virtual void loadURLExternally(const ResourceRequest&,
                                  NavigationPolicy,
                                  const String& suggestedName,
                                  bool replacesCurrentHistoryItem) = 0;
 
   virtual bool navigateBackForward(int offset) const = 0;
 
-  // Another page has accessed the initial empty document of this frame.
-  // It is no longer safe to display a provisional URL, since a URL spoof
-  // is now possible.
+  // Another page has accessed the initial empty document of this frame. It is
+  // no longer safe to display a provisional URL, since a URL spoof is now
+  // possible.
   virtual void didAccessInitialDocument() {}
 
   // This frame has displayed inactive content (such as an image) from an
   // insecure source.  Inactive content cannot spread to other frames.
   virtual void didDisplayInsecureContent() = 0;
 
-  // The indicated security origin has run active content (such as a
-  // script) from an insecure source.  Note that the insecure content can
-  // spread to other frames in the same origin.
+  // The indicated security origin has run active content (such as a script)
+  // from an insecure source.  Note that the insecure content can spread to
+  // other frames in the same origin.
   virtual void didRunInsecureContent(SecurityOrigin*, const KURL&) = 0;
   virtual void didDetectXSS(const KURL&, bool didBlockEntirePage) = 0;
   virtual void didDispatchPingLoader(const KURL&) = 0;
 
   // The frame displayed content with certificate errors with given URL.
   virtual void didDisplayContentWithCertificateErrors(const KURL&) = 0;
   // The frame ran content with certificate errors with the given URL.
   virtual void didRunContentWithCertificateErrors(const KURL&) = 0;
 
   // Will be called when |PerformanceTiming| events are updated
   virtual void didChangePerformanceTiming() {}
 
   // Will be called when a particular loading code path has been used. This
-  // propogates renderer loading behavior to the browser process for
-  // histograms.
+  // propogates renderer loading behavior to the browser process for histograms.
   virtual void didObserveLoadingBehavior(WebLoadingBehaviorFlag) {}
 
-  // Transmits the change in the set of watched CSS selectors property
-  // that match any element on the frame.
+  // Transmits the change in the set of watched CSS selectors property that
+  // match any element on the frame.
   virtual void selectorMatchChanged(const Vector<String>& addedSelectors,
                                     const Vector<String>& removedSelectors) = 0;
 
   virtual DocumentLoader* createDocumentLoader(LocalFrame*,
                                                const ResourceRequest&,
                                                const SubstituteData&) = 0;
 
   virtual String userAgent() = 0;
 
   virtual String doNotTrackValue() = 0;
 
   virtual void transitionToCommittedForNewPage() = 0;
 
   virtual LocalFrame* createFrame(const FrameLoadRequest&,
                                   const AtomicString& name,
                                   HTMLFrameOwnerElement*) = 0;
-  // Whether or not plugin creation should fail if the HTMLPlugInElement isn't in the DOM after plugin initialization.
+  // Whether or not plugin creation should fail if the HTMLPlugInElement isn't
+  // in the DOM after plugin initialization.
   enum DetachedPluginPolicy {
     FailOnDetachedPlugin,
     AllowDetachedPlugin,
   };
   virtual bool canCreatePluginWithoutRenderer(const String& mimeType) const = 0;
   virtual Widget* createPlugin(HTMLPlugInElement*,
                                const KURL&,
                                const Vector<String>&,
                                const Vector<String>&,
                                const String&,
@@ skipping 43 matching lines @@
     return enabledPerSettings;
   }
   virtual bool allowMedia(const KURL&) { return true; }
   virtual bool allowRunningInsecureContent(bool enabledPerSettings,
                                            SecurityOrigin*,
                                            const KURL&) {
     return enabledPerSettings;
   }
   virtual bool allowAutoplay(bool defaultValue) { return defaultValue; }
 
-  // Reports that passive mixed content was found at the provided URL. It may
-  // or may not be actually displayed later, what would be flagged by
+  // Reports that passive mixed content was found at the provided URL. It may or
+  // may not be actually displayed later, what would be flagged by
   // didDisplayInsecureContent.
   virtual void passiveInsecureContentFound(const KURL&) {}
 
   // This callback notifies the client that the frame was about to run
-  // JavaScript but did not because allowScript returned false. We
-  // have a separate callback here because there are a number of places
-  // that need to know if JavaScript is enabled but are not necessarily
-  // preparing to execute script.
+  // JavaScript but did not because allowScript returned false. We have a
+  // separate callback here because there are a number of places that need to
+  // know if JavaScript is enabled but are not necessarily preparing to execute
+  // script.
   virtual void didNotAllowScript() {}
   // This callback is similar, but for plugins.
   virtual void didNotAllowPlugins() {}
 
   // This callback notifies the client that the frame created a Keygen element.
   virtual void didUseKeygen() {}
 
   virtual WebCookieJar* cookieJar() const = 0;
 
   virtual void didChangeName(const String& name, const String& uniqueName) {}
 
   virtual void didEnforceInsecureRequestPolicy(WebInsecureRequestPolicy) {}
 
   virtual void didUpdateToUniqueOrigin() {}
 
   virtual void didChangeSandboxFlags(Frame* childFrame, SandboxFlags) {}
 
-  // Called when a new Content Security Policy is added to the frame's
-  // document.  This can be triggered by handling of HTTP headers, handling
-  // of <meta> element, or by inheriting CSP from the parent (in case of
-  // about:blank).
+  // Called when a new Content Security Policy is added to the frame's document.
+  // This can be triggered by handling of HTTP headers, handling of <meta>
+  // element, or by inheriting CSP from the parent (in case of about:blank).
   virtual void didAddContentSecurityPolicy(const String& headerValue,
                                            ContentSecurityPolicyHeaderType,
                                            ContentSecurityPolicyHeaderSource) {}
 
   virtual void didChangeFrameOwnerProperties(HTMLFrameElementBase*) {}
 
   virtual void dispatchWillStartUsingPeerConnectionHandler(
       WebRTCPeerConnectionHandler*) {}
 
   virtual bool allowWebGL(bool enabledPerSettings) {
     return enabledPerSettings;
   }
 
-  // If an HTML document is being loaded, informs the embedder that the document will have its <body> attached soon.
+  // If an HTML document is being loaded, informs the embedder that the document
+  // will have its <body> attached soon.
   virtual void dispatchWillInsertBody() {}
 
   virtual std::unique_ptr<WebServiceWorkerProvider>
   createServiceWorkerProvider() = 0;
 
   virtual bool isControlledByServiceWorker(DocumentLoader&) = 0;
 
   virtual int64_t serviceWorkerID(DocumentLoader&) = 0;
 
   virtual SharedWorkerRepositoryClient* sharedWorkerRepositoryClient() {
     return 0;
   }
 
   virtual std::unique_ptr<WebApplicationCacheHost> createApplicationCacheHost(
       WebApplicationCacheHostClient*) = 0;
 
   virtual void dispatchDidChangeManifest() {}
 
   virtual unsigned backForwardLength() { return 0; }
 
   virtual bool isFrameLoaderClientImpl() const { return false; }
 
-  // Called when elements preventing the sudden termination of the frame
-  // become present or stop being present. |type| is the type of element
-  // (BeforeUnload handler, Unload handler).
+  // Called when elements preventing the sudden termination of the frame become
+  // present or stop being present. |type| is the type of element (BeforeUnload
+  // handler, Unload handler).
   enum SuddenTerminationDisablerType {
     BeforeUnloadHandler,
     UnloadHandler,
   };
   virtual void suddenTerminationDisablerChanged(bool present,
                                                 SuddenTerminationDisablerType) {
   }
 
   virtual LinkResource* createServiceWorkerLinkResource(HTMLLinkElement*) {
     return nullptr;
   }
 
   // Effective connection type when this frame was loaded.
   virtual WebEffectiveConnectionType getEffectiveConnectionType() {
     return WebEffectiveConnectionType::TypeUnknown;
   }
 
-  // Overwrites the given URL to use an HTML5 embed if possible.
-  // An empty URL is returned if the URL is not overriden.
+  // Overwrites the given URL to use an HTML5 embed if possible. An empty URL is
+  // returned if the URL is not overriden.
   virtual KURL overrideFlashEmbedWithHTML(const KURL&) { return KURL(); }
 };
 
 }  // namespace blink
 
 #endif  // FrameLoaderClient_h