Reflow comments in core/loader

third_party/WebKit/Source/core/loader/FrameFetchContextTest.cpp

 /*
  * Copyright (c) 2015, 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 103 matching lines @@
         SubstituteData());
     childDocument = childFrame->document();
     FrameFetchContext* childFetchContext = static_cast<FrameFetchContext*>(
         &childDocumentLoader->fetcher()->context());
     FrameFetchContext::provideDocumentToContext(*childFetchContext,
                                                 childDocument.get());
     return childFetchContext;
   }
 
   std::unique_ptr<DummyPageHolder> dummyPageHolder;
-  // We don't use the DocumentLoader directly in any tests, but need to keep it around as long
-  // as the ResourceFetcher and Document live due to indirect usage.
+  // We don't use the DocumentLoader directly in any tests, but need to keep it
+  // around as long as the ResourceFetcher and Document live due to indirect
+  // usage.
   Persistent<DocumentLoader> documentLoader;
   Persistent<Document> document;
   Persistent<FrameFetchContext> fetchContext;
 
   Persistent<StubFrameLoaderClientWithParent> childClient;
   Persistent<LocalFrame> childFrame;
   Persistent<DocumentLoader> childDocumentLoader;
   Persistent<Document> childDocument;
   Persistent<DummyFrameOwner> owner;
 };
 
-// This test class sets up a mock frame loader client that expects a
-// call to didDisplayContentWithCertificateErrors().
+// This test class sets up a mock frame loader client that expects a call to
+// didDisplayContentWithCertificateErrors().
 class FrameFetchContextDisplayedCertificateErrorsTest
     : public FrameFetchContextTest {
  protected:
   void SetUp() override {
     url = KURL(KURL(), "https://example.test/foo");
     mainResourceUrl = KURL(KURL(), "https://www.example.test");
     MockFrameLoaderClient* client = new MockFrameLoaderClient;
     EXPECT_CALL(*client, didDisplayContentWithCertificateErrors(url));
     dummyPageHolder =
         DummyPageHolder::create(IntSize(500, 500), nullptr, client);
@@ skipping 62 matching lines @@
     fetchRequest.mutableResourceRequest().setRequestContext(
         WebURLRequest::RequestContextScript);
     fetchRequest.mutableResourceRequest().setFrameType(frameType);
 
     fetchContext->upgradeInsecureRequest(fetchRequest.mutableResourceRequest());
 
     EXPECT_EQ(shouldPrefer ? String("1") : String(),
               fetchRequest.resourceRequest().httpHeaderField(
                   HTTPNames::Upgrade_Insecure_Requests));
 
-    // Calling upgradeInsecureRequest more than once shouldn't affect the header.
+    // Calling upgradeInsecureRequest more than once shouldn't affect the
+    // header.
     if (shouldPrefer) {
       fetchContext->upgradeInsecureRequest(
           fetchRequest.mutableResourceRequest());
       EXPECT_EQ("1", fetchRequest.resourceRequest().httpHeaderField(
                          HTTPNames::Upgrade_Insecure_Requests));
     }
   }
 
   RefPtr<SecurityOrigin> exampleOrigin;
   RefPtr<SecurityOrigin> secureOrigin;
@@ skipping 39 matching lines @@
                   WebURLRequest::FrameTypeTopLevel, test.original);
     expectUpgrade(test.original, WebURLRequest::RequestContextScript,
                   WebURLRequest::FrameTypeAuxiliary, test.original);
 
     // unless the request context is RequestContextForm.
     expectUpgrade(test.original, WebURLRequest::RequestContextForm,
                   WebURLRequest::FrameTypeTopLevel, test.upgraded);
     expectUpgrade(test.original, WebURLRequest::RequestContextForm,
                   WebURLRequest::FrameTypeAuxiliary, test.upgraded);
 
-    // Or unless the host of the resource is in the document's InsecureNavigationsSet:
+    // Or unless the host of the resource is in the document's
+    // InsecureNavigationsSet:
     document->addInsecureNavigationUpgrade(
         exampleOrigin->host().impl()->hash());
     expectUpgrade(test.original, WebURLRequest::RequestContextScript,
                   WebURLRequest::FrameTypeTopLevel, test.upgraded);
     expectUpgrade(test.original, WebURLRequest::RequestContextScript,
                   WebURLRequest::FrameTypeAuxiliary, test.upgraded);
   }
 }
 
 TEST_F(FrameFetchContextUpgradeTest, DoNotUpgradeInsecureResourceRequests) {
@@ skipping 33 matching lines @@
       {"http://example.test/page.html", WebURLRequest::FrameTypeNested, true},
       {"http://example.test/page.html", WebURLRequest::FrameTypeNone, false},
       {"http://example.test/page.html", WebURLRequest::FrameTypeTopLevel, true},
       {"https://example.test/page.html", WebURLRequest::FrameTypeAuxiliary,
        true},
       {"https://example.test/page.html", WebURLRequest::FrameTypeNested, true},
       {"https://example.test/page.html", WebURLRequest::FrameTypeNone, false},
       {"https://example.test/page.html", WebURLRequest::FrameTypeTopLevel,
        true}};
 
-  // This should work correctly both when the FrameFetchContext has a Document, and
-  // when it doesn't (e.g. during main frame navigations), so run through the tests
-  // both before and after providing a document to the context.
+  // This should work correctly both when the FrameFetchContext has a Document,
+  // and when it doesn't (e.g. during main frame navigations), so run through
+  // the tests both before and after providing a document to the context.
   for (const auto& test : tests) {
     document->setInsecureRequestPolicy(kLeaveInsecureRequestsAlone);
     expectHTTPSHeader(test.toRequest, test.frameType, test.shouldPrefer);
 
     document->setInsecureRequestPolicy(kUpgradeInsecureRequests);
     expectHTTPSHeader(test.toRequest, test.frameType, test.shouldPrefer);
   }
 
   FrameFetchContext::provideDocumentToContext(*fetchContext, document.get());
 
@@ skipping 153 matching lines @@
       // No document origin => unique request origin
       {"", false, "", WebURLRequest::FrameTypeNone, "null"},
       {"", true, "", WebURLRequest::FrameTypeNone, "null"},
 
       // Document origin => request origin
       {"http://example.test", false, "", WebURLRequest::FrameTypeNone,
        "http://example.test"},
       {"http://example.test", true, "", WebURLRequest::FrameTypeNone,
        "http://example.test"},
 
-      // If the request already has a requestor origin, then 'populateRequestData' leaves it alone:
+      // If the request already has a requestor origin, then
+      // 'populateRequestData' leaves it alone:
       {"http://example.test", false, "http://not-example.test",
        WebURLRequest::FrameTypeNone, "http://not-example.test"},
       {"http://example.test", true, "http://not-example.test",
        WebURLRequest::FrameTypeNone, "http://not-example.test"},
 
-      // If the request's frame type is not 'none', then 'populateRequestData' leaves it alone:
+      // If the request's frame type is not 'none', then 'populateRequestData'
+      // leaves it alone:
       {"http://example.test", false, "", WebURLRequest::FrameTypeTopLevel, ""},
       {"http://example.test", false, "", WebURLRequest::FrameTypeAuxiliary, ""},
       {"http://example.test", false, "", WebURLRequest::FrameTypeNested, ""},
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(::testing::Message() << test.documentURL << " => "
                                       << test.serializedOrigin);
     // Set up a new document to ensure sandbox flags are cleared:
     dummyPageHolder = DummyPageHolder::create(IntSize(500, 500));
@@ skipping 65 matching lines @@
   fetchContext->addAdditionalRequestHeaders(resourceRequest, FetchMainResource);
   EXPECT_EQ("on", resourceRequest.httpHeaderField("Save-Data"));
 }
 
 TEST_F(FrameFetchContextTest, DisabledDataSaver) {
   ResourceRequest resourceRequest("http://www.example.com");
   fetchContext->addAdditionalRequestHeaders(resourceRequest, FetchMainResource);
   EXPECT_EQ(String(), resourceRequest.httpHeaderField("Save-Data"));
 }
 
-// Tests that when a resource with certificate errors is loaded from the
-// memory cache, the embedder is notified.
+// Tests that when a resource with certificate errors is loaded from the memory
+// cache, the embedder is notified.
 TEST_F(FrameFetchContextDisplayedCertificateErrorsTest,
        MemoryCacheCertificateError) {
   ResourceRequest resourceRequest(url);
   ResourceResponse response;
   response.setURL(url);
   response.setHasMajorCertificateErrors(true);
   Resource* resource = Resource::create(resourceRequest, Resource::Image);
   resource->setResponse(response);
   fetchContext->dispatchDidLoadResourceFromMemoryCache(
       createUniqueIdentifier(), resource, WebURLRequest::FrameTypeNone,
@@ skipping 118 matching lines @@
     fetchContext->addAdditionalRequestHeaders(mainRequest, FetchMainResource);
     EXPECT_EQ(test.isExternalExpectation, mainRequest.isExternalRequest());
 
     ResourceRequest subRequest(test.url);
     fetchContext->addAdditionalRequestHeaders(subRequest, FetchSubresource);
     EXPECT_EQ(test.isExternalExpectation, subRequest.isExternalRequest());
   }
 }
 
 }  // namespace blink