test all

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

 /*
  * Copyright (C) 2013 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 61 matching lines @@
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceLoadPriority.h"
 #include "platform/loader/fetch/ResourceLoadingLog.h"
 #include "platform/loader/fetch/ResourceTimingInfo.h"
 #include "platform/loader/fetch/UniqueIdentifier.h"
 #include "platform/mhtml/MHTMLArchive.h"
 #include "platform/network/NetworkStateNotifier.h"
 #include "platform/network/NetworkUtils.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/wtf/Vector.h"
+#include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "public/platform/WebViewScheduler.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 
 namespace blink {
 
 namespace {
 
 void EmitWarningForDocWriteScripts(const String& url, Document& document) {
@@ skipping 356 matching lines @@
     unsigned long identifier,
     ResourceRequest& request,
     const ResourceResponse& redirect_response,
     const FetchInitiatorInfo& initiator_info) {
   if (redirect_response.IsNull()) {
     // Progress doesn't care about redirects, only notify it when an
     // initial request is sent.
     GetFrame()->Loader().Progress().WillStartLoading(identifier,
                                                      request.Priority());
   }
-  probe::willSendRequest(GetFrame(), identifier, MasterDocumentLoader(),
-                         request, redirect_response, initiator_info);
+  probe::willSendRequest(GetFrame()->GetDocument(), identifier,
+                         MasterDocumentLoader(), request, redirect_response,
+                         initiator_info);
   if (GetFrame()->FrameScheduler())
     GetFrame()->FrameScheduler()->DidStartLoading(identifier);
 }
 
 void FrameFetchContext::DispatchDidReceiveResponse(
     unsigned long identifier,
     const ResourceResponse& response,
     WebURLRequest::FrameType frame_type,
     WebURLRequest::RequestContext request_context,
     Resource* resource,
@@ skipping 28 matching lines @@
       resource_loading_policy, LinkLoader::kLoadAll, nullptr);
 
   if (response.HasMajorCertificateErrors()) {
     MixedContentChecker::HandleCertificateError(GetFrame(), response,
                                                 frame_type, request_context);
   }
 
   GetFrame()->Loader().Progress().IncrementProgress(identifier, response);
   GetLocalFrameClient()->DispatchDidReceiveResponse(response);
   DocumentLoader* document_loader = MasterDocumentLoader();
-  probe::didReceiveResourceResponse(GetFrame(), identifier, document_loader,
-                                    response, resource);
+  probe::didReceiveResourceResponse(GetFrame()->GetDocument(), identifier,
+                                    document_loader, response, resource);
   // It is essential that inspector gets resource response BEFORE console.
   GetFrame()->Console().ReportResourceResponseReceived(document_loader,
                                                        identifier, response);
 }
 
 void FrameFetchContext::DispatchDidReceiveData(unsigned long identifier,
                                                const char* data,
                                                int data_length) {
   GetFrame()->Loader().Progress().IncrementProgress(identifier, data_length);
-  probe::didReceiveData(GetFrame(), identifier, data, data_length);
+  probe::didReceiveData(GetFrame()->GetDocument(), identifier,
+                        MasterDocumentLoader(), data, data_length);
 }
 
 void FrameFetchContext::DispatchDidReceiveEncodedData(unsigned long identifier,
                                                       int encoded_data_length) {
-  probe::didReceiveEncodedDataLength(GetFrame(), identifier,
+  probe::didReceiveEncodedDataLength(GetFrame()->GetDocument(), identifier,
                                      encoded_data_length);
 }
 
 void FrameFetchContext::DispatchDidDownloadData(unsigned long identifier,
                                                 int data_length,
                                                 int encoded_data_length) {
   GetFrame()->Loader().Progress().IncrementProgress(identifier, data_length);
-  probe::didReceiveData(GetFrame(), identifier, 0, data_length);
-  probe::didReceiveEncodedDataLength(GetFrame(), identifier,
+  probe::didReceiveData(GetFrame()->GetDocument(), identifier,
+                        MasterDocumentLoader(), 0, data_length);
+  probe::didReceiveEncodedDataLength(GetFrame()->GetDocument(), identifier,
                                      encoded_data_length);
 }
 
 void FrameFetchContext::DispatchDidFinishLoading(unsigned long identifier,
                                                  double finish_time,
                                                  int64_t encoded_data_length,
                                                  int64_t decoded_body_length) {
   GetFrame()->Loader().Progress().CompleteProgress(identifier);
-  probe::didFinishLoading(GetFrame(), identifier, finish_time,
+  probe::didFinishLoading(GetFrame()->GetDocument(), identifier,
+                          MasterDocumentLoader(), finish_time,
                           encoded_data_length, decoded_body_length);
   if (GetFrame()->FrameScheduler())
     GetFrame()->FrameScheduler()->DidStopLoading(identifier);
 }
 
 void FrameFetchContext::DispatchDidFail(unsigned long identifier,
                                         const ResourceError& error,
                                         int64_t encoded_data_length,
                                         bool is_internal_request) {
   GetFrame()->Loader().Progress().CompleteProgress(identifier);
-  probe::didFailLoading(GetFrame(), identifier, error);
+  probe::didFailLoading(GetFrame()->GetDocument(), identifier, error);
   // Notification to FrameConsole should come AFTER InspectorInstrumentation
   // call, DevTools front-end relies on this.
   if (!is_internal_request)
     GetFrame()->Console().DidFailLoading(identifier, error);
   if (GetFrame()->FrameScheduler())
     GetFrame()->FrameScheduler()->DidStopLoading(identifier);
 }
 
 void FrameFetchContext::DispatchDidLoadResourceFromMemoryCache(
     unsigned long identifier,
@@ skipping 77 matching lines @@
     const ResourceRequest& resource_request,
     const KURL& url,
     const ResourceLoaderOptions& options,
     SecurityViolationReportingPolicy reporting_policy,
     FetchParameters::OriginRestriction origin_restriction) const {
   ResourceRequestBlockedReason blocked_reason = CanRequestInternal(
       type, resource_request, url, options, reporting_policy,
       origin_restriction, resource_request.GetRedirectStatus());
   if (blocked_reason != ResourceRequestBlockedReason::kNone &&
       reporting_policy == SecurityViolationReportingPolicy::kReport) {
-    probe::didBlockRequest(GetFrame(), resource_request, MasterDocumentLoader(),
-                           options.initiator_info, blocked_reason);
+    probe::didBlockRequest(GetDocument(), resource_request,
+                           MasterDocumentLoader(), options.initiator_info,
+                           blocked_reason);
   }
   return blocked_reason;
 }
 
 ResourceRequestBlockedReason FrameFetchContext::AllowResponse(
     Resource::Type type,
     const ResourceRequest& resource_request,
     const KURL& url,
     const ResourceLoaderOptions& options) const {
   ResourceRequestBlockedReason blocked_reason =
       CanRequestInternal(type, resource_request, url, options,
                          SecurityViolationReportingPolicy::kReport,
                          FetchParameters::kUseDefaultOriginRestrictionForType,
                          RedirectStatus::kFollowedRedirect);
   if (blocked_reason != ResourceRequestBlockedReason::kNone) {
-    probe::didBlockRequest(GetFrame(), resource_request, MasterDocumentLoader(),
-                           options.initiator_info, blocked_reason);
+    probe::didBlockRequest(GetDocument(), resource_request,
+                           MasterDocumentLoader(), options.initiator_info,
+                           blocked_reason);
   }
   return blocked_reason;
 }
 
 ResourceRequestBlockedReason FrameFetchContext::CanRequestInternal(
     Resource::Type type,
     const ResourceRequest& resource_request,
     const KURL& url,
     const ResourceLoaderOptions& options,
     SecurityViolationReportingPolicy reporting_policy,
     FetchParameters::OriginRestriction origin_restriction,
     ResourceRequest::RedirectStatus redirect_status) const {
   bool should_block_request = false;
-  probe::shouldBlockRequest(GetFrame(), resource_request,
+  probe::shouldBlockRequest(GetDocument(), resource_request,
                             &should_block_request);
   if (should_block_request)
     return ResourceRequestBlockedReason::kInspector;
 
   SecurityOrigin* security_origin = options.security_origin.Get();
   if (!security_origin && execution_context_)
     security_origin = execution_context_->GetSecurityOrigin();
 
   if (origin_restriction != FetchParameters::kNoOriginRestriction &&
       security_origin && !security_origin->CanDisplay(url)) {
@@ skipping 165 matching lines @@
 
 int64_t FrameFetchContext::ServiceWorkerID() const {
   DCHECK(MasterDocumentLoader());
   auto* service_worker_network_provider =
       MasterDocumentLoader()->GetServiceWorkerNetworkProvider();
   return service_worker_network_provider
              ? service_worker_network_provider->ServiceWorkerID()
              : -1;
 }
 
+int FrameFetchContext::ApplicationCacheHostID() const {
+  if (!document_loader_)
+    return 0;
+  return document_loader_->GetApplicationCacheHost()->GetHostID();
+}
+
 bool FrameFetchContext::IsMainFrame() const {
   return GetFrame()->IsMainFrame();
 }
 
 bool FrameFetchContext::DefersLoading() const {
   return GetFrame()->GetPage()->Suspended();
 }
 
 bool FrameFetchContext::IsLoadComplete() const {
   return GetDocument() && GetDocument()->LoadEventFinished();
@@ skipping 140 matching lines @@
     return priority;
 
   // If enabled, drop the priority of all resources in a subframe.
   if (GetFrame()->GetSettings()->GetLowPriorityIframes() &&
       !GetFrame()->IsMainFrame())
     return kResourceLoadPriorityVeryLow;
 
   return priority;
 }
 
+RefPtr<WebTaskRunner> FrameFetchContext::TimerTaskRunner() const {
+  return GetFrame()->FrameScheduler()->TimerTaskRunner();
+}
+
 RefPtr<WebTaskRunner> FrameFetchContext::LoadingTaskRunner() const {
   return GetFrame()->FrameScheduler()->LoadingTaskRunner();
 }
 
+WebURLLoader* FrameFetchContext::CreateURLLoader() {
+  return Platform::Current()->CreateURLLoader();
+}
+
 DEFINE_TRACE(FrameFetchContext) {
   visitor->Trace(document_loader_);
   BaseFetchContext::Trace(visitor);
 }
 
 }  // namespace blink