Converge <link rel=preload> loading logic with preloadScanner

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/loader/LinkLoader.h"
 
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/Settings.h"
 #include "core/html/LinkRelAttribute.h"
+#include "core/loader/DocumentLoader.h"
 #include "core/loader/LinkLoaderClient.h"
 #include "core/loader/NetworkHintsInterface.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/network/ResourceLoadPriority.h"
 
 #include <base/macros.h>
 #include <gtest/gtest.h>
 
 namespace blink {
 
@@ skipping 54 matching lines @@
 };
 
 TEST(LinkLoaderTest, Preload)
 {
     struct TestCase {
         const char* href;
         const char* as;
         const ResourceLoadPriority priority;
         const bool shouldLoad;
     } cases[] = {
-        {"data://example.com/cat.jpg", "image", ResourceLoadPriorityVeryLow, true},
-        {"data://example.com/cat.jpg", "script", ResourceLoadPriorityMedium, true},
-        {"data://example.com/cat.jpg", "stylesheet", ResourceLoadPriorityHigh, true},
-        {"data://example.com/cat.jpg", "blabla", ResourceLoadPriorityUnresolved, true},
-        {"data://example.com/cat.jpg", "image", ResourceLoadPriorityUnresolved, false},
+        {"data://example.test/cat.jpg", "image", ResourceLoadPriorityVeryLow, true},
+        {"data://example.test/cat.js", "script", ResourceLoadPriorityMedium, true},
+        {"data://example.test/cat.css", "stylesheet", ResourceLoadPriorityHigh, true},
+        {"data://example.test/cat.blob", "blabla", ResourceLoadPriorityUnresolved, false},
     };
 
     // Test the cases with a single header
     for (const auto& testCase : cases) {
         OwnPtr<DummyPageHolder> dummyPageHolder = DummyPageHolder::create(IntSize(500, 500));
+        dummyPageHolder->frame().settings()->setScriptEnabled(true);
         MockLinkLoaderClient loaderClient(testCase.shouldLoad);
         LinkLoader loader(&loaderClient);
         KURL hrefURL = KURL(KURL(), testCase.href);
         loader.loadLink(LinkRelAttribute("preload"),
             AtomicString(),
             String(),
             testCase.as,
             hrefURL,
             dummyPageHolder->document(),
             NetworkHintsMock());
-        if (testCase.priority == ResourceLoadPriorityUnresolved) {
-            ASSERT(!loader.resource());
-        } else {
-            ASSERT(loader.resource());
-            ASSERT_EQ(testCase.priority, loader.resource()->resourceRequest().priority());
+        ASSERT(dummyPageHolder->document().fetcher());
+        WillBeHeapListHashSet<RawPtrWillBeMember<Resource>>* preloads = dummyPageHolder->document().fetcher()->preloads();
+        if (testCase.shouldLoad)
+            ASSERT_LT(nullptr, preloads);

[Nate Chapin, 2015/11/03 20:18:11]

ASSERT_LT(nullptr, ...) looks fishy.

ASSERT_NE instead?

+        if (preloads) {
+            if (testCase.priority == ResourceLoadPriorityUnresolved) {
+                ASSERT_EQ((unsigned)0, preloads->size());
+            } else {
+                ASSERT_EQ((unsigned)1, preloads->size());
+                if (preloads->size() > 0)
+                    ASSERT_EQ(testCase.priority, preloads->begin().get()->get()->resourceRequest().priority());
+            }
         }
     }
 }
 
 TEST(LinkLoaderTest, DNSPrefetch)
 {
     struct {
         const char* href;
         const bool shouldLoad;
     } cases[] = {
@@ skipping 53 matching lines @@
             hrefURL,
             dummyPageHolder->document(),
             networkHints);
         ASSERT_EQ(testCase.shouldLoad, networkHints.didPreconnect());
         ASSERT_EQ(testCase.isHTTPS, networkHints.isHTTPS());
         ASSERT_EQ(testCase.isCrossOrigin, networkHints.isCrossOrigin());
     }
 }
 
 } // namespace blink