Make prepareRequest() a separate callback of FetchContext

third_party/WebKit/Source/core/loader/appcache/ApplicationCacheHost.cpp

 /*
  * Copyright (C) 2009 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 33 matching lines @@
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/appcache/ApplicationCache.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLError.h"
+#include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 #include "public/platform/WebVector.h"
 
 namespace blink {
 
 // We provide a custom implementation of this class that calls out to the
 // embedding application instead of using WebCore's built in appcache system.
 // This file replaces webcore/appcache/ApplicationCacheHost.cpp in our build.
 
 ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader)
     : m_domApplicationCache(nullptr),
       m_documentLoader(documentLoader),
       m_defersEvents(true) {
   DCHECK(m_documentLoader);
 }
 
 ApplicationCacheHost::~ApplicationCacheHost() {
   // Verify that detachFromDocumentLoader() has been performed already.
   DCHECK(!m_host);
 }
 
+void ApplicationCacheHost::willStartLoading(ResourceRequest& request) {
+  if (!isApplicationCacheEnabled())
+    return;
+
+  if (request.frameType() == WebURLRequest::FrameTypeTopLevel ||
+      request.frameType() == WebURLRequest::FrameTypeNested) {
+    willStartLoadingMainResource(request);
+  } else {
+    willStartLoadingResource(request);
+  }
+}
+
 void ApplicationCacheHost::willStartLoadingMainResource(
     ResourceRequest& request) {
   // We defer creating the outer host object to avoid spurious
   // creation/destruction around creating empty documents. At this point, we're
   // initiating a main resource load for the document, so its for real.
 
-  if (!isApplicationCacheEnabled())
-    return;
+  DCHECK(isApplicationCacheEnabled());
 
   DCHECK(m_documentLoader->frame());
   LocalFrame& frame = *m_documentLoader->frame();
   m_host = frame.loader().client()->createApplicationCacheHost(this);
   if (!m_host)
     return;
 
   WrappedResourceRequest wrapped(request);
 
   const WebApplicationCacheHost* spawningHost = nullptr;
@@ skipping 240 matching lines @@
   notifyApplicationCache(kErrorEvent, 0, 0, reason, url.string(), status,
                          message);
 }
 
 DEFINE_TRACE(ApplicationCacheHost) {
   visitor->trace(m_domApplicationCache);
   visitor->trace(m_documentLoader);
 }
 
 }  // namespace blink