Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/Resource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
-    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.
 
     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
     Library General Public License for more details.
@@ skipping 29 matching lines @@
 namespace blink {
 
 struct FetchInitiatorInfo;
 class CachedMetadata;
 class FetchRequest;
 class ResourceClient;
 class ResourceTimingInfo;
 class ResourceLoader;
 class SecurityOrigin;
 
-// A resource that is held in the cache. Classes who want to use this object should derive
-// from ResourceClient, to get the function calls in case the requested data has arrived.
-// This class also does the actual communication with the loader to obtain the resource from the network.
+// A resource that is held in the cache. Classes who want to use this object
+// should derive from ResourceClient, to get the function calls in case the
+// requested data has arrived. This class also does the actual communication
+// with the loader to obtain the resource from the network.
 class CORE_EXPORT Resource : public GarbageCollectedFinalized<Resource>,
                              public MemoryCoordinatorClient {
   USING_GARBAGE_COLLECTED_MIXIN(Resource);
   WTF_MAKE_NONCOPYABLE(Resource);
 
  public:
   // |Type| enum values are used in UMAs, so do not change the values of
-  // existing |Type|. When adding a new |Type|, append it at the end and
-  // update |kLastResourceType|.
+  // existing |Type|. When adding a new |Type|, append it at the end and update
+  // |kLastResourceType|.
   enum Type {
     MainResource,
     Image,
     CSSStyleSheet,
     Script,
     Font,
     Raw,
     SVGDocument,
     XSLStyleSheet,
     LinkPrefetch,
@@ skipping 56 matching lines @@
 
   const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
   const ResourceRequest& lastResourceRequest() const;
 
   virtual void setRevalidatingRequest(const ResourceRequest&);
 
   void setFetcherSecurityOrigin(SecurityOrigin* origin) {
     m_fetcherSecurityOrigin = origin;
   }
 
-  // This url can have a fragment, but it can match resources that differ by the fragment only.
+  // This url can have a fragment, but it can match resources that differ by the
+  // fragment only.
   const KURL& url() const { return m_resourceRequest.url(); }
   Type getType() const { return static_cast<Type>(m_type); }
   const ResourceLoaderOptions& options() const { return m_options; }
   ResourceLoaderOptions& mutableOptions() { return m_options; }
 
   void didChangePriority(ResourceLoadPriority, int intraPriorityValue);
   virtual ResourcePriority priorityFromObservers() {
     return ResourcePriority();
   }
 
@@ skipping 26 matching lines @@
   bool isLoading() const { return m_status == Pending; }
   bool stillNeedsLoad() const { return m_status < Pending; }
 
   void setLoader(ResourceLoader*);
   ResourceLoader* loader() const { return m_loader.get(); }
 
   virtual bool isImage() const { return false; }
   bool shouldBlockLoadEvent() const;
   bool isLoadEventBlockingResourceType() const;
 
-  // Computes the status of an object after loading.
-  // Updates the expire date on the cache entry file
+  // Computes the status of an object after loading. Updates the expire date on
+  // the cache entry file
   virtual void finish(double finishTime);
   void finish() { finish(0.0); }
 
-  // FIXME: Remove the stringless variant once all the callsites' error messages are updated.
+  // FIXME: Remove the stringless variant once all the callsites' error messages
+  // are updated.
   bool passesAccessControlCheck(SecurityOrigin*) const;
   bool passesAccessControlCheck(SecurityOrigin*,
                                 String& errorDescription) const;
 
   bool isEligibleForIntegrityCheck(SecurityOrigin*) const;
 
   virtual PassRefPtr<const SharedBuffer> resourceBuffer() const {
     return m_data;
   }
   void setResourceBuffer(PassRefPtr<SharedBuffer>);
 
   virtual void willFollowRedirect(ResourceRequest&, const ResourceResponse&);
 
-  // Called when a redirect response was received but a decision has
-  // already been made to not follow it.
+  // Called when a redirect response was received but a decision has already
+  // been made to not follow it.
   virtual void willNotFollowRedirect() {}
 
   virtual void responseReceived(const ResourceResponse&,
                                 std::unique_ptr<WebDataConsumerHandle>);
   void setResponse(const ResourceResponse&);
   const ResourceResponse& response() const { return m_response; }
 
   virtual void reportResourceTimingToClients(const ResourceTimingInfo&) {}
 
   // Sets the serialized metadata retrieved from the platform's cache.
   virtual void setSerializedCachedMetadata(const char*, size_t);
 
   // This may return nullptr when the resource isn't cacheable.
   CachedMetadataHandler* cacheHandler();
 
   AtomicString httpContentType() const;
 
   bool wasCanceled() const { return m_error.isCancellation(); }
   bool errorOccurred() const {
     return m_status == LoadError || m_status == DecodeError;
   }
   bool loadFailedOrCanceled() { return !m_error.isNull(); }
 
   DataBufferingPolicy getDataBufferingPolicy() const {
     return m_options.dataBufferingPolicy;
   }
   void setDataBufferingPolicy(DataBufferingPolicy);
 
-  // The isPreloaded() flag is using a counter in order to make sure that even when
-  // multiple ResourceFetchers are preloading the resource, it will remain marked as
-  // preloaded until *all* of them have used it.
+  // The isPreloaded() flag is using a counter in order to make sure that even
+  // when multiple ResourceFetchers are preloading the resource, it will remain
+  // marked as preloaded until *all* of them have used it.
   bool isUnusedPreload() const {
     return isPreloaded() && getPreloadResult() == PreloadNotReferenced;
   }
   bool isPreloaded() const { return m_preloadCount; }
   void increasePreloadCount() { ++m_preloadCount; }
   void decreasePreloadCount() {
     DCHECK(m_preloadCount);
     --m_preloadCount;
   }
 
@@ skipping 193 matching lines @@
 };
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName)                   \
   DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource,    \
                     resource->getType() == Resource::typeName, \
                     resource.getType() == Resource::typeName);
 
 }  // namespace blink
 
 #endif