Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/CachingCorrectnessTest.cpp

 /*
  * Copyright (c) 2014, 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 76 matching lines @@
         break;
       case Resource::Image:
         resource = ImageResource::create(ResourceRequest(response.url()));
         break;
       default:
         EXPECT_TRUE(false) << "'Unreachable' code was reached";
         return nullptr;
     }
     resource->setResponse(response);
     resource->finish();
-    // Because we didn't give any real data, an image will have set its
-    // status to DecodeError. Override it so the resource is cacaheable
-    // for testing purposes.
+    // Because we didn't give any real data, an image will have set its status
+    // to DecodeError. Override it so the resource is cacaheable for testing
+    // purposes.
     if (type == Resource::Image)
       resource->setStatus(Resource::Cached);
     memoryCache()->add(resource);
 
     return resource;
   }
 
   Resource* resourceFromResourceRequest(ResourceRequest request,
                                         Resource::Type type = Resource::Raw) {
     if (request.url().isNull())
@@ skipping 57 matching lines @@
 
 TEST_F(CachingCorrectnessTest, FreshFromLastModified) {
   ResourceResponse fresh200Response;
   fresh200Response.setHTTPStatusCode(200);
   fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   fresh200Response.setHTTPHeaderField("Last-Modified",
                                       kOneDayBeforeOriginalRequest);
 
   Resource* fresh200 = resourceFromResourceResponse(fresh200Response);
 
-  // Advance the clock within the implicit freshness period of this resource before we make a request.
+  // Advance the clock within the implicit freshness period of this resource
+  // before we make a request.
   advanceClock(600.);
 
   Resource* fetched = fetch();
   EXPECT_EQ(fresh200, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshFromExpires) {
   ResourceResponse fresh200Response;
   fresh200Response.setHTTPStatusCode(200);
   fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
   Resource* fresh200 = resourceFromResourceResponse(fresh200Response);
 
-  // Advance the clock within the freshness period of this resource before we make a request.
+  // Advance the clock within the freshness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. - 15.);
 
   Resource* fetched = fetch();
   EXPECT_EQ(fresh200, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshFromMaxAge) {
   ResourceResponse fresh200Response;
   fresh200Response.setHTTPStatusCode(200);
   fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   fresh200Response.setHTTPHeaderField("Cache-Control", "max-age=600");
 
   Resource* fresh200 = resourceFromResourceResponse(fresh200Response);
 
-  // Advance the clock within the freshness period of this resource before we make a request.
+  // Advance the clock within the freshness period of this resource before we
+  // make a request.
   advanceClock(500.);
 
   Resource* fetched = fetch();
   EXPECT_EQ(fresh200, fetched);
 }
 
-// The strong validator causes a revalidation to be launched, and the proxy and original resources leak because of their reference loop.
+// The strong validator causes a revalidation to be launched, and the proxy and
+// original resources leak because of their reference loop.
 TEST_F(CachingCorrectnessTest, DISABLED_ExpiredFromLastModified) {
   ResourceResponse expired200Response;
   expired200Response.setHTTPStatusCode(200);
   expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   expired200Response.setHTTPHeaderField("Last-Modified",
                                         kOneDayBeforeOriginalRequest);
 
   Resource* expired200 = resourceFromResourceResponse(expired200Response);
 
   // Advance the clock beyond the implicit freshness period.
   advanceClock(24. * 60. * 60. * 0.2);
 
   Resource* fetched = fetch();
   EXPECT_NE(expired200, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, ExpiredFromExpires) {
   ResourceResponse expired200Response;
   expired200Response.setHTTPStatusCode(200);
   expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
   Resource* expired200 = resourceFromResourceResponse(expired200Response);
 
-  // Advance the clock within the expiredness period of this resource before we make a request.
+  // Advance the clock within the expiredness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. + 15.);
 
   Resource* fetched = fetch();
   EXPECT_NE(expired200, fetched);
 }
 
-// If the image hasn't been loaded in this "document" before, then it shouldn't have list of available images logic.
+// If the image hasn't been loaded in this "document" before, then it shouldn't
+// have list of available images logic.
 TEST_F(CachingCorrectnessTest, NewImageExpiredFromExpires) {
   ResourceResponse expired200Response;
   expired200Response.setHTTPStatusCode(200);
   expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
   Resource* expired200 =
       resourceFromResourceResponse(expired200Response, Resource::Image);
 
-  // Advance the clock within the expiredness period of this resource before we make a request.
+  // Advance the clock within the expiredness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. + 15.);
 
   Resource* fetched = fetchImage();
   EXPECT_NE(expired200, fetched);
 }
 
-// If the image has been loaded in this "document" before, then it should have list of available images logic, and so
-// normal cache testing should be bypassed.
+// If the image has been loaded in this "document" before, then it should have
+// list of available images logic, and so normal cache testing should be
+// bypassed.
 TEST_F(CachingCorrectnessTest, ReuseImageExpiredFromExpires) {
   ResourceResponse expired200Response;
   expired200Response.setHTTPStatusCode(200);
   expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest);
 
   Resource* expired200 =
       resourceFromResourceResponse(expired200Response, Resource::Image);
 
-  // Advance the clock within the freshness period, and make a request to add this image to the document resources.
+  // Advance the clock within the freshness period, and make a request to add
+  // this image to the document resources.
   advanceClock(15.);
   Resource* firstFetched = fetchImage();
   EXPECT_EQ(expired200, firstFetched);
 
-  // Advance the clock within the expiredness period of this resource before we make a request.
+  // Advance the clock within the expiredness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. + 15.);
 
   Resource* fetched = fetchImage();
   EXPECT_EQ(expired200, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, ExpiredFromMaxAge) {
   ResourceResponse expired200Response;
   expired200Response.setHTTPStatusCode(200);
   expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
   expired200Response.setHTTPHeaderField("Cache-Control", "max-age=600");
 
   Resource* expired200 = resourceFromResourceResponse(expired200Response);
 
-  // Advance the clock within the expiredness period of this resource before we make a request.
+  // Advance the clock within the expiredness period of this resource before we
+  // make a request.
   advanceClock(700.);
 
   Resource* fetched = fetch();
   EXPECT_NE(expired200, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshButNoCache) {
   ResourceResponse fresh200NocacheResponse;
   fresh200NocacheResponse.setHTTPStatusCode(200);
   fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Date,
                                              kOriginalRequestDateAsString);
   fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Expires,
                                              kOneDayAfterOriginalRequest);
   fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Cache_Control,
                                              "no-cache");
 
   Resource* fresh200Nocache =
       resourceFromResourceResponse(fresh200NocacheResponse);
 
-  // Advance the clock within the freshness period of this resource before we make a request.
+  // Advance the clock within the freshness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. - 15.);
 
   Resource* fetched = fetch();
   EXPECT_NE(fresh200Nocache, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, RequestWithNoCahe) {
   ResourceRequest noCacheRequest;
   noCacheRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
   Resource* noCacheResource = resourceFromResourceRequest(noCacheRequest);
   Resource* fetched = fetch();
   EXPECT_NE(noCacheResource, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshButNoStore) {
   ResourceResponse fresh200NostoreResponse;
   fresh200NostoreResponse.setHTTPStatusCode(200);
   fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Date,
                                              kOriginalRequestDateAsString);
   fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Expires,
                                              kOneDayAfterOriginalRequest);
   fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Cache_Control,
                                              "no-store");
 
   Resource* fresh200Nostore =
       resourceFromResourceResponse(fresh200NostoreResponse);
 
-  // Advance the clock within the freshness period of this resource before we make a request.
+  // Advance the clock within the freshness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. - 15.);
 
   Resource* fetched = fetch();
   EXPECT_NE(fresh200Nostore, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, RequestWithNoStore) {
   ResourceRequest noStoreRequest;
   noStoreRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-store");
   Resource* noStoreResource = resourceFromResourceRequest(noStoreRequest);
   Resource* fetched = fetch();
   EXPECT_NE(noStoreResource, fetched);
 }
 
 // FIXME: Determine if ignoring must-revalidate for blink is correct behaviour.
 // See crbug.com/340088 .
 TEST_F(CachingCorrectnessTest, DISABLED_FreshButMustRevalidate) {
   ResourceResponse fresh200MustRevalidateResponse;
   fresh200MustRevalidateResponse.setHTTPStatusCode(200);
   fresh200MustRevalidateResponse.setHTTPHeaderField(
       HTTPNames::Date, kOriginalRequestDateAsString);
   fresh200MustRevalidateResponse.setHTTPHeaderField(
       HTTPNames::Expires, kOneDayAfterOriginalRequest);
   fresh200MustRevalidateResponse.setHTTPHeaderField(HTTPNames::Cache_Control,
                                                     "must-revalidate");
 
   Resource* fresh200MustRevalidate =
       resourceFromResourceResponse(fresh200MustRevalidateResponse);
 
-  // Advance the clock within the freshness period of this resource before we make a request.
+  // Advance the clock within the freshness period of this resource before we
+  // make a request.
   advanceClock(24. * 60. * 60. - 15.);
 
   Resource* fetched = fetch();
   EXPECT_NE(fresh200MustRevalidate, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshWithFreshRedirect) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
@@ skipping 205 matching lines @@
   firstResource->finish();
   memoryCache()->add(firstResource);
 
   advanceClock(500.);
 
   Resource* fetched = fetch();
   EXPECT_EQ(firstResource, fetched);
 }
 
 }  // namespace blink