Add a warning whenever link preloads are not used

third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 29 matching lines @@
 #include "core/dom/FrameRequestCallback.h"
 #include "core/dom/SandboxFlags.h"
 #include "core/dom/custom/CustomElementRegistry.h"
 #include "core/editing/Editor.h"
 #include "core/events/DOMWindowEventQueue.h"
 #include "core/events/HashChangeEvent.h"
 #include "core/events/MessageEvent.h"
 #include "core/events/PageTransitionEvent.h"
 #include "core/events/PopStateEvent.h"
 #include "core/events/ScopedEventQueue.h"
+#include "core/fetch/ResourceFetcher.h"
 #include "core/frame/BarProp.h"
 #include "core/frame/DOMVisualViewport.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/History.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Navigator.h"
 #include "core/frame/Screen.h"
 #include "core/frame/ScrollToOptions.h"
@@ skipping 16 matching lines @@
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/Suborigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFrameScheduler.h"
 #include "public/platform/WebScreenInfo.h"
 #include <memory>
 
 namespace blink {
 
+// Timeout for link preloads to be used after window.onload
+static const int unusedPreloadTimeoutInSeconds = 3;
+
 class PostMessageTimer final : public GarbageCollectedFinalized<PostMessageTimer>, public SuspendableTimer {
     USING_GARBAGE_COLLECTED_MIXIN(PostMessageTimer);
 public:
     PostMessageTimer(LocalDOMWindow& window, MessageEvent* event, PassRefPtr<SecurityOrigin> targetOrigin, std::unique_ptr<SourceLocation> location, UserGestureToken* userGestureToken)
         : SuspendableTimer(window.document())
         , m_event(event)
         , m_window(&window)
         , m_targetOrigin(targetOrigin)
         , m_location(std::move(location))
         , m_userGestureToken(userGestureToken)
@@ skipping 157 matching lines @@
 }
 
 bool LocalDOMWindow::allowPopUp()
 {
     return frame() && allowPopUp(*frame());
 }
 
 LocalDOMWindow::LocalDOMWindow(LocalFrame& frame)
     : m_frame(&frame)
     , m_visualViewport(DOMVisualViewport::create(this))
+    , m_unusedPreloadsTimer(this, &LocalDOMWindow::warnUnusedPreloads)
     , m_shouldPrintWhenFinishedLoading(false)
 {
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 void LocalDOMWindow::clearDocument()
 {
     if (!m_document)
         return;
 
     ASSERT(!m_document->isActive());
 
     // FIXME: This should be part of ActiveDOMObject shutdown
     clearEventQueue();
 
+    m_unusedPreloadsTimer.stop();
     m_document->clearDOMWindow();
     m_document = nullptr;
 }
 
 void LocalDOMWindow::clearEventQueue()
 {
     if (!m_eventQueue)
         return;
     m_eventQueue->close();
     m_eventQueue.clear();
@@ skipping 1041 matching lines @@
         it->didRemoveEventListener(this, eventType);
     }
 
     if (eventType == EventTypeNames::unload) {
         removeUnloadEventListener(this);
     } else if (eventType == EventTypeNames::beforeunload && allowsBeforeUnloadListeners(this)) {
         removeBeforeUnloadEventListener(this);
     }
 }
 
+void LocalDOMWindow::warnUnusedPreloads(TimerBase* base)
+{
+    if (frame() && frame()->loader().documentLoader()) {
+        ResourceFetcher* fetcher = frame()->loader().documentLoader()->fetcher();
+        DCHECK(fetcher);
+        if (fetcher->countPreloads())
+            fetcher->warnUnusedPreloads();
+    }
+}
+
 void LocalDOMWindow::dispatchLoadEvent()
 {
     Event* loadEvent(Event::create(EventTypeNames::load));
     if (frame() && frame()->loader().documentLoader() && !frame()->loader().documentLoader()->timing().loadEventStart()) {
         DocumentLoader* documentLoader = frame()->loader().documentLoader();
         DocumentLoadTiming& timing = documentLoader->timing();
         timing.markLoadEventStart();
         dispatchEvent(loadEvent, document());
         timing.markLoadEventEnd();
+        DCHECK(documentLoader->fetcher());
+        if (frame() && documentLoader == frame()->loader().documentLoader() && documentLoader->fetcher()->countPreloads())
+            m_unusedPreloadsTimer.startOneShot(unusedPreloadTimeoutInSeconds, BLINK_FROM_HERE);
     } else {
         dispatchEvent(loadEvent, document());
     }
 
     // For load events, send a separate load event to the enclosing frame only.
     // This is a DOM extension and is independent of bubbling/capturing rules of
     // the DOM.
     FrameOwner* owner = frame() ? frame()->owner() : nullptr;
     if (owner)
         owner->dispatchLoad();
@@ skipping 135 matching lines @@
 LocalFrame* LocalDOMWindow::frame() const
 {
     // If the LocalDOMWindow still has a frame reference, that frame must point
     // back to this LocalDOMWindow: otherwise, it's easy to get into a situation
     // where script execution leaks between different LocalDOMWindows.
     SECURITY_DCHECK(!m_frame || m_frame->domWindow() == this);
     return m_frame;
 }
 
 } // namespace blink