Support DevTools for off-main-thread-fetch

third_party/WebKit/Source/core/inspector/InspectorNetworkAgent.cpp

 /*
  * Copyright (C) 2011 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/inspector/ConsoleMessage.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/NetworkResourcesData.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/Page.h"
 #include "core/probe/CoreProbes.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/xmlhttprequest/XMLHttpRequest.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/blob/BlobData.h"
 #include "platform/loader/fetch/FetchInitiatorInfo.h"
 #include "platform/loader/fetch/FetchInitiatorTypeNames.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceError.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceLoadTiming.h"
@@ skipping 481 matching lines @@
     response_object->setSecurityDetails(std::move(security_details));
   }
 
   return response_object;
 }
 
 InspectorNetworkAgent::~InspectorNetworkAgent() {}
 
 DEFINE_TRACE(InspectorNetworkAgent) {
   visitor->Trace(inspected_frames_);
+  visitor->Trace(worker_global_scope_);
   visitor->Trace(resources_data_);
   visitor->Trace(replay_xhrs_);
   visitor->Trace(replay_xhrs_to_be_deleted_);
   visitor->Trace(pending_xhr_replay_data_);
   InspectorBaseAgent::Trace(visitor);
 }
 
 void InspectorNetworkAgent::ShouldBlockRequest(const ResourceRequest& request,
                                                bool* result) {
   protocol::DictionaryValue* blocked_urls =
       state_->getObject(NetworkAgentState::kBlockedURLs);
   if (!blocked_urls)
     return;
 
   String url = request.Url().GetString();
   for (size_t i = 0; i < blocked_urls->size(); ++i) {
     auto entry = blocked_urls->at(i);
     if (Matches(url, entry.first)) {
       *result = true;
       return;
     }
   }
   return;
 }
 
 void InspectorNetworkAgent::DidBlockRequest(
-    LocalFrame* frame,
+    ExecutionContext* execution_context,
     const ResourceRequest& request,
     DocumentLoader* loader,
     const FetchInitiatorInfo& initiator_info,
     ResourceRequestBlockedReason reason) {
   unsigned long identifier = CreateUniqueIdentifier();
-  WillSendRequestInternal(frame, identifier, loader, request,
+  WillSendRequestInternal(execution_context, identifier, loader, request,
                           ResourceResponse(), initiator_info);
 
   String request_id = IdentifiersFactory::RequestId(identifier);
   String protocol_reason = BuildBlockedReason(reason);
   GetFrontend()->loadingFailed(
       request_id, MonotonicallyIncreasingTime(),
       InspectorPageAgent::ResourceTypeJson(
           resources_data_->GetResourceType(request_id)),
       String(), false, protocol_reason);
 }
 
 void InspectorNetworkAgent::DidChangeResourcePriority(
     unsigned long identifier,
     ResourceLoadPriority load_priority) {
   String request_id = IdentifiersFactory::RequestId(identifier);
   GetFrontend()->resourceChangedPriority(request_id,
                                          ResourcePriorityJSON(load_priority),
                                          MonotonicallyIncreasingTime());
 }
 
 void InspectorNetworkAgent::WillSendRequestInternal(
-    LocalFrame* frame,
+    ExecutionContext* execution_context,
     unsigned long identifier,
     DocumentLoader* loader,
     const ResourceRequest& request,
     const ResourceResponse& redirect_response,
     const FetchInitiatorInfo& initiator_info) {
   String request_id = IdentifiersFactory::RequestId(identifier);
-  String loader_id = IdentifiersFactory::LoaderId(loader);
+  String loader_id = loader ? IdentifiersFactory::LoaderId(loader) : "";
   resources_data_->ResourceCreated(request_id, loader_id, request.Url());
 
   InspectorPageAgent::ResourceType type = InspectorPageAgent::kOtherResource;
   if (initiator_info.name == FetchInitiatorTypeNames::xmlhttprequest) {
     type = InspectorPageAgent::kXHRResource;
     resources_data_->SetResourceType(request_id, type);
   } else if (initiator_info.name == FetchInitiatorTypeNames::document) {
     type = InspectorPageAgent::kDocumentResource;
     resources_data_->SetResourceType(request_id, type);
   }
 
-  String frame_id =
-      loader->GetFrame() ? IdentifiersFactory::FrameId(loader->GetFrame()) : "";
+  String frame_id = loader && loader->GetFrame()
+                        ? IdentifiersFactory::FrameId(loader->GetFrame())
+                        : "";
   std::unique_ptr<protocol::Network::Initiator> initiator_object =
-      BuildInitiatorObject(
-          loader->GetFrame() ? loader->GetFrame()->GetDocument() : 0,
-          initiator_info);
+      BuildInitiatorObject(loader && loader->GetFrame()
+                               ? loader->GetFrame()->GetDocument()
+                               : nullptr,
+                           initiator_info);
   if (initiator_info.name == FetchInitiatorTypeNames::document) {
     FrameNavigationInitiatorMap::iterator it =
         frame_navigation_initiator_map_.find(frame_id);
     if (it != frame_navigation_initiator_map_.end())
       initiator_object = it->value->clone();
   }
 
   std::unique_ptr<protocol::Network::Request> request_info(
       BuildObjectForResourceRequest(request));
 
-  request_info->setMixedContentType(MixedContentTypeForContextType(
-      MixedContentChecker::ContextTypeForInspector(frame, request)));
+  // |loader| is null while inspecting worker if off-main-thread-fetch is
+  // enabled. TODO(horo): Refactor MixedContentChecker and set mixed content
+  // type even if |loader| is null.
+  if (loader) {
+    request_info->setMixedContentType(MixedContentTypeForContextType(
+        MixedContentChecker::ContextTypeForInspector(loader->GetFrame(),
+                                                     request)));
+  }
 
   request_info->setReferrerPolicy(
       GetReferrerPolicy(request.GetReferrerPolicy()));
   if (initiator_info.is_link_preload)
     request_info->setIsLinkPreload(true);
 
   String resource_type = InspectorPageAgent::ResourceTypeJson(type);
+  String documentURL =
+      loader ? UrlWithoutFragment(loader->Url()).GetString()
+             : UrlWithoutFragment(execution_context->Url()).GetString();
+  Maybe<String> maybe_frame_id;
+  if (!frame_id.IsEmpty())
+    maybe_frame_id = frame_id;
   GetFrontend()->requestWillBeSent(
-      request_id, frame_id, loader_id,
-      UrlWithoutFragment(loader->Url()).GetString(), std::move(request_info),
+      request_id, loader_id, documentURL, std::move(request_info),
       MonotonicallyIncreasingTime(), CurrentTime(), std::move(initiator_object),
-      BuildObjectForResourceResponse(redirect_response), resource_type);
+      BuildObjectForResourceResponse(redirect_response), resource_type,
+      std::move(maybe_frame_id));
   if (pending_xhr_replay_data_ && !pending_xhr_replay_data_->Async())
     GetFrontend()->flush();
 }
 
 void InspectorNetworkAgent::WillSendRequest(
-    LocalFrame* frame,
+    ExecutionContext* execution_context,
     unsigned long identifier,
     DocumentLoader* loader,
     ResourceRequest& request,
     const ResourceResponse& redirect_response,
     const FetchInitiatorInfo& initiator_info) {
   // Ignore the request initiated internally.
   if (initiator_info.name == FetchInitiatorTypeNames::internal)
     return;
 
   if (initiator_info.name == FetchInitiatorTypeNames::document &&
@@ skipping 19 matching lines @@
         request.GetRequestContext() != WebURLRequest::kRequestContextInternal) {
       request.SetCachePolicy(WebCachePolicy::kBypassCacheLoadOnlyFromCache);
     } else {
       request.SetCachePolicy(WebCachePolicy::kBypassingCache);
     }
     request.SetShouldResetAppCache(true);
   }
   if (state_->booleanProperty(NetworkAgentState::kBypassServiceWorker, false))
     request.SetServiceWorkerMode(WebURLRequest::ServiceWorkerMode::kNone);
 
-  WillSendRequestInternal(frame, identifier, loader, request, redirect_response,
-                          initiator_info);
+  WillSendRequestInternal(execution_context, identifier, loader, request,
+                          redirect_response, initiator_info);
 
   if (!host_id_.IsEmpty())
     request.AddHTTPHeaderField(
         HTTPNames::X_DevTools_Emulate_Network_Conditions_Client_Id,
         AtomicString(host_id_));
 }
 
 void InspectorNetworkAgent::MarkResourceAsCached(unsigned long identifier) {
   GetFrontend()->requestServedFromCache(
       IdentifiersFactory::RequestId(identifier));
 }
 
 void InspectorNetworkAgent::DidReceiveResourceResponse(
-    LocalFrame* frame,
     unsigned long identifier,
     DocumentLoader* loader,
     const ResourceResponse& response,
     Resource* cached_resource) {
   String request_id = IdentifiersFactory::RequestId(identifier);
   bool is_not_modified = response.HttpStatusCode() == 304;
 
   bool resource_is_empty = true;
   std::unique_ptr<protocol::Network::Response> resource_response =
       BuildObjectForResourceResponse(response, cached_resource,
@@ skipping 15 matching lines @@
   if (type == InspectorPageAgent::kDocumentResource && loader &&
       loader->GetSubstituteData().IsValid())
     return;
 
   // Resources are added to NetworkResourcesData as a WeakMember here and
   // removed in willDestroyResource() called in the prefinalizer of Resource.
   // Because NetworkResourceData retains weak references only, it
   // doesn't affect Resource lifetime.
   if (cached_resource)
     resources_data_->AddResource(request_id, cached_resource);
-  String frame_id = IdentifiersFactory::FrameId(frame);
+  String frame_id = loader && loader->GetFrame()
+                        ? IdentifiersFactory::FrameId(loader->GetFrame())
+                        : "";
   String loader_id = loader ? IdentifiersFactory::LoaderId(loader) : "";
   resources_data_->ResponseReceived(request_id, frame_id, response);
   resources_data_->SetResourceType(request_id, type);
 
   if (response.GetSecurityStyle() != ResourceResponse::kSecurityStyleUnknown &&
       response.GetSecurityStyle() !=
           ResourceResponse::kSecurityStyleUnauthenticated) {
     const ResourceResponse::SecurityDetails* response_security_details =
         response.GetSecurityDetails();
     resources_data_->SetCertificate(request_id,
                                     response_security_details->certificate);
   }
 
-  if (resource_response && !resource_is_empty)
-    GetFrontend()->responseReceived(request_id, frame_id, loader_id,
-                                    MonotonicallyIncreasingTime(),
-                                    InspectorPageAgent::ResourceTypeJson(type),
-                                    std::move(resource_response));
+  if (resource_response && !resource_is_empty) {
+    Maybe<String> maybe_frame_id;
+    if (!frame_id.IsEmpty())
+      maybe_frame_id = frame_id;
+    GetFrontend()->responseReceived(
+        request_id, loader_id, MonotonicallyIncreasingTime(),
+        InspectorPageAgent::ResourceTypeJson(type),
+        std::move(resource_response), std::move(maybe_frame_id));
+  }
   // If we revalidated the resource and got Not modified, send content length
   // following didReceiveResponse as there will be no calls to didReceiveData
   // from the network stack.
   if (is_not_modified && cached_resource && cached_resource->EncodedSize())
-    DidReceiveData(frame, identifier, 0, cached_resource->EncodedSize());
+    DidReceiveData(identifier, loader, 0, cached_resource->EncodedSize());
 }
 
 static bool IsErrorStatusCode(int status_code) {
   return status_code >= 400;
 }
 
-void InspectorNetworkAgent::DidReceiveData(LocalFrame*,
-                                           unsigned long identifier,
+void InspectorNetworkAgent::DidReceiveData(unsigned long identifier,
+                                           DocumentLoader* loader,
                                            const char* data,
                                            int data_length) {
   String request_id = IdentifiersFactory::RequestId(identifier);
 
   if (data) {
     NetworkResourcesData::ResourceData const* resource_data =
         resources_data_->Data(request_id);
     if (resource_data &&
         (!resource_data->CachedResource() ||
          resource_data->CachedResource()->GetDataBufferingPolicy() ==
              kDoNotBufferData ||
          IsErrorStatusCode(resource_data->HttpStatusCode())))
       resources_data_->MaybeAddResourceData(request_id, data, data_length);
   }
 
   GetFrontend()->dataReceived(
       request_id, MonotonicallyIncreasingTime(), data_length,
       resources_data_->GetAndClearPendingEncodedDataLength(request_id));
 }
 
 void InspectorNetworkAgent::DidReceiveEncodedDataLength(
-    LocalFrame*,
     unsigned long identifier,
     int encoded_data_length) {
   String request_id = IdentifiersFactory::RequestId(identifier);
   resources_data_->AddPendingEncodedDataLength(request_id, encoded_data_length);
 }
 
-void InspectorNetworkAgent::DidFinishLoading(LocalFrame*,
-                                             unsigned long identifier,
+void InspectorNetworkAgent::DidFinishLoading(unsigned long identifier,
+                                             DocumentLoader*,
                                              double monotonic_finish_time,
                                              int64_t encoded_data_length,
                                              int64_t decoded_body_length) {
   String request_id = IdentifiersFactory::RequestId(identifier);
   NetworkResourcesData::ResourceData const* resource_data =
       resources_data_->Data(request_id);
 
   int pending_encoded_data_length =
       resources_data_->GetAndClearPendingEncodedDataLength(request_id);
   if (pending_encoded_data_length > 0) {
@@ skipping 16 matching lines @@
                                  encoded_data_length);
 }
 
 void InspectorNetworkAgent::DidReceiveCORSRedirectResponse(
     LocalFrame* frame,
     unsigned long identifier,
     DocumentLoader* loader,
     const ResourceResponse& response,
     Resource* resource) {
   // Update the response and finish loading
-  DidReceiveResourceResponse(frame, identifier, loader, response, resource);
-  DidFinishLoading(frame, identifier, 0,
+  DidReceiveResourceResponse(identifier, loader, response, resource);
+  DidFinishLoading(identifier, loader, 0,
                    WebURLLoaderClient::kUnknownEncodedDataLength, 0);
 }
 
 void InspectorNetworkAgent::DidFailLoading(unsigned long identifier,
                                            const ResourceError& error) {
   String request_id = IdentifiersFactory::RequestId(identifier);
   bool canceled = error.IsCancellation();
   GetFrontend()->loadingFailed(
       request_id, MonotonicallyIncreasingTime(),
       InspectorPageAgent::ResourceTypeJson(
@@ skipping 392 matching lines @@
   return Response::OK();
 }
 
 bool InspectorNetworkAgent::CanGetResponseBodyBlob(const String& request_id) {
   NetworkResourcesData::ResourceData const* resource_data =
       resources_data_->Data(request_id);
   BlobDataHandle* blob =
       resource_data ? resource_data->DownloadedFileBlob() : nullptr;
   if (!blob)
     return false;
+  if (worker_global_scope_)
+    return true;
   LocalFrame* frame = IdentifiersFactory::FrameById(inspected_frames_,
                                                     resource_data->FrameId());
   return frame && frame->GetDocument();
 }
 
 void InspectorNetworkAgent::GetResponseBodyBlob(
     const String& request_id,
     std::unique_ptr<GetResponseBodyCallback> callback) {
   NetworkResourcesData::ResourceData const* resource_data =
       resources_data_->Data(request_id);
   BlobDataHandle* blob = resource_data->DownloadedFileBlob();
+  InspectorFileReaderLoaderClient* client = new InspectorFileReaderLoaderClient(
+      blob, resource_data->MimeType(), resource_data->TextEncodingName(),
+      std::move(callback));
+  if (worker_global_scope_) {
+    client->Start(worker_global_scope_);
+    return;
+  }
+  DCHECK(inspected_frames_);
   LocalFrame* frame = IdentifiersFactory::FrameById(inspected_frames_,
                                                     resource_data->FrameId());
   Document* document = frame->GetDocument();
-  InspectorFileReaderLoaderClient* client = new InspectorFileReaderLoaderClient(
-      blob, resource_data->MimeType(), resource_data->TextEncodingName(),
-      std::move(callback));
   client->Start(document);
 }
 
 void InspectorNetworkAgent::getResponseBody(
     const String& request_id,
     std::unique_ptr<GetResponseBodyCallback> pass_callback) {
   std::unique_ptr<GetResponseBodyCallback> callback = std::move(pass_callback);
   NetworkResourcesData::ResourceData const* resource_data =
       resources_data_->Data(request_id);
   if (!resource_data) {
@@ skipping 95 matching lines @@
   *result = true;
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::emulateNetworkConditions(
     bool offline,
     double latency,
     double download_throughput,
     double upload_throughput,
     Maybe<String> connection_type) {
+  if (!IsMainThread())
+    return Response::Error("Not supported");
+
   WebConnectionType type = kWebConnectionTypeUnknown;
   if (connection_type.isJust()) {
     type = ToWebConnectionType(connection_type.fromJust());
     if (type == kWebConnectionTypeUnknown)
       return Response::Error("Unknown connection type");
   }
   // TODO(dgozman): networkStateNotifier is per-process. It would be nice to
   // have per-frame override instead.
   if (offline || latency || download_throughput || upload_throughput)
     GetNetworkStateNotifier().SetNetworkConnectionInfoOverride(
         !offline, type, download_throughput / (1024 * 1024 / 8));
   else
     GetNetworkStateNotifier().ClearOverride();
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setCacheDisabled(bool cache_disabled) {
   // TODO(ananta)
   // We should extract network cache state into a global entity which can be
   // queried from FrameLoader and other places.
   state_->setBoolean(NetworkAgentState::kCacheDisabled, cache_disabled);
-  if (cache_disabled)
+  if (cache_disabled && IsMainThread())
     GetMemoryCache()->EvictResources();
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setBypassServiceWorker(bool bypass) {
   state_->setBoolean(NetworkAgentState::kBypassServiceWorker, bypass);
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setDataSizeLimitsForTest(int max_total,
@@ skipping 16 matching lines @@
       for (auto& cert : resource->Certificate())
         certificate->get()->addItem(Base64Encode(cert.Latin1()));
       return Response::OK();
     }
   }
   return Response::OK();
 }
 
 void InspectorNetworkAgent::DidCommitLoad(LocalFrame* frame,
                                           DocumentLoader* loader) {
+  DCHECK(inspected_frames_);
+  DCHECK(IsMainThread());
   if (loader->GetFrame() != inspected_frames_->Root())
     return;
 
   if (state_->booleanProperty(NetworkAgentState::kCacheDisabled, false))
     GetMemoryCache()->EvictResources(MemoryCache::kDoNotEvictUnusedPreloads);
 
   resources_data_->Clear(IdentifiersFactory::LoaderId(loader));
 }
 
 void InspectorNetworkAgent::FrameScheduledNavigation(LocalFrame* frame,
@@ skipping 33 matching lines @@
 }
 
 void InspectorNetworkAgent::SetHostId(const String& host_id) {
   host_id_ = host_id;
 }
 
 bool InspectorNetworkAgent::FetchResourceContent(Document* document,
                                                  const KURL& url,
                                                  String* content,
                                                  bool* base64_encoded) {
+  DCHECK(document);
+  DCHECK(IsMainThread());
   // First try to fetch content from the cached resource.
   Resource* cached_resource = document->Fetcher()->CachedResource(url);
-  if (!cached_resource)
+  if (!cached_resource) {
     cached_resource = GetMemoryCache()->ResourceForURL(
         url, document->Fetcher()->GetCacheIdentifier());
+  }
   if (cached_resource && InspectorPageAgent::CachedResourceContent(
                              cached_resource, content, base64_encoded))
     return true;
 
   // Then fall back to resource data.
   for (auto& resource : resources_data_->Resources()) {
     if (resource->RequestedURL() == url) {
       *content = resource->Content();
       *base64_encoded = resource->Base64Encoded();
       return true;
     }
   }
   return false;
 }
 
 bool InspectorNetworkAgent::CacheDisabled() {
   return state_->booleanProperty(NetworkAgentState::kNetworkAgentEnabled,
                                  false) &&
          state_->booleanProperty(NetworkAgentState::kCacheDisabled, false);
 }
 
 void InspectorNetworkAgent::RemoveFinishedReplayXHRFired(TimerBase*) {
   replay_xhrs_to_be_deleted_.clear();
 }
 
-InspectorNetworkAgent::InspectorNetworkAgent(InspectedFrames* inspected_frames)
+InspectorNetworkAgent::InspectorNetworkAgent(
+    InspectedFrames* inspected_frames,
+    WorkerGlobalScope* worker_global_scope)
     : inspected_frames_(inspected_frames),
+      worker_global_scope_(worker_global_scope),
       resources_data_(
           NetworkResourcesData::Create(g_maximum_total_buffer_size,
                                        g_maximum_resource_buffer_size)),
       pending_request_(nullptr),
       remove_finished_replay_xhr_timer_(
-          TaskRunnerHelper::Get(TaskType::kUnspecedLoading,
-                                inspected_frames->Root()),
+          inspected_frames ? TaskRunnerHelper::Get(TaskType::kUnspecedLoading,
+                                                   inspected_frames->Root())
+                           : TaskRunnerHelper::Get(TaskType::kUnspecedLoading,
+                                                   worker_global_scope),
           this,
-          &InspectorNetworkAgent::RemoveFinishedReplayXHRFired) {}
+          &InspectorNetworkAgent::RemoveFinishedReplayXHRFired) {
+  DCHECK((IsMainThread() && inspected_frames_ && !worker_global_scope_) ||
+         (!IsMainThread() && !inspected_frames_ && worker_global_scope_));
+}
 
 void InspectorNetworkAgent::ShouldForceCORSPreflight(bool* result) {
   if (state_->booleanProperty(NetworkAgentState::kCacheDisabled, false))
     *result = true;
 }
 
 }  // namespace blink