[WIP] off-main-thread loading

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 556 matching lines @@
     auto entry = blockedURLs->at(i);
     if (matches(url, entry.first)) {
       *result = true;
       return;
     }
   }
   return;
 }
 
 void InspectorNetworkAgent::didBlockRequest(
-    LocalFrame* frame,
     const ResourceRequest& request,
     DocumentLoader* loader,
     const FetchInitiatorInfo& initiatorInfo,
     ResourceRequestBlockedReason reason) {
   unsigned long identifier = createUniqueIdentifier();
-  willSendRequestInternal(frame, identifier, loader, request,
-                          ResourceResponse(), initiatorInfo);
+  willSendRequestInternal(identifier, loader, request, ResourceResponse(),
+                          initiatorInfo);
 
   String requestId = IdentifiersFactory::requestId(identifier);
   String protocolReason = buildBlockedReason(reason);
   frontend()->loadingFailed(requestId, monotonicallyIncreasingTime(),
                             InspectorPageAgent::resourceTypeJson(
                                 m_resourcesData->resourceType(requestId)),
                             String(), false, protocolReason);
 }
 
 void InspectorNetworkAgent::didChangeResourcePriority(
     unsigned long identifier,
     ResourceLoadPriority loadPriority) {
   String requestId = IdentifiersFactory::requestId(identifier);
   frontend()->resourceChangedPriority(requestId,
                                       resourcePriorityJSON(loadPriority),
                                       monotonicallyIncreasingTime());
 }
 
 void InspectorNetworkAgent::willSendRequestInternal(
-    LocalFrame* frame,
     unsigned long identifier,
     DocumentLoader* loader,
     const ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo& initiatorInfo) {
   String requestId = IdentifiersFactory::requestId(identifier);
-  String loaderId = IdentifiersFactory::loaderId(loader);
+  String loaderId = loader ? IdentifiersFactory::loaderId(loader) : "";
   m_resourcesData->resourceCreated(requestId, loaderId, request.url());
 
   InspectorPageAgent::ResourceType type = InspectorPageAgent::OtherResource;
   if (initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest) {
     type = InspectorPageAgent::XHRResource;
     m_resourcesData->setResourceType(requestId, type);
   } else if (initiatorInfo.name == FetchInitiatorTypeNames::document) {
     type = InspectorPageAgent::DocumentResource;
     m_resourcesData->setResourceType(requestId, type);
   }
-
-  String frameId =
-      loader->frame() ? IdentifiersFactory::frameId(loader->frame()) : "";
+  String frameId = loader && loader->frame()
+                       ? IdentifiersFactory::frameId(loader->frame())
+                       : "";
   std::unique_ptr<protocol::Network::Initiator> initiatorObject =
-      buildInitiatorObject(loader->frame() ? loader->frame()->document() : 0,
-                           initiatorInfo);
+      buildInitiatorObject(
+          loader && loader->frame() ? loader->frame()->document() : 0,
+          initiatorInfo);
   if (initiatorInfo.name == FetchInitiatorTypeNames::document) {
     FrameNavigationInitiatorMap::iterator it =
         m_frameNavigationInitiatorMap.find(frameId);
     if (it != m_frameNavigationInitiatorMap.end())
       initiatorObject = it->value->clone();
   }
 
   std::unique_ptr<protocol::Network::Request> requestInfo(
       buildObjectForResourceRequest(request));
 
-  requestInfo->setMixedContentType(mixedContentTypeForContextType(
-      MixedContentChecker::contextTypeForInspector(frame, request)));
+  if (loader) {
+    requestInfo->setMixedContentType(mixedContentTypeForContextType(
+        MixedContentChecker::contextTypeForInspector(loader->frame(),
+                                                     request)));
+  }
 
   requestInfo->setReferrerPolicy(referrerPolicy(request.getReferrerPolicy()));
   if (initiatorInfo.isLinkPreload)
     requestInfo->setIsLinkPreload(true);
 
   String resourceType = InspectorPageAgent::resourceTypeJson(type);
   frontend()->requestWillBeSent(
       requestId, frameId, loaderId,
-      urlWithoutFragment(loader->url()).getString(), std::move(requestInfo),
-      monotonicallyIncreasingTime(), currentTime(), std::move(initiatorObject),
+      loader ? urlWithoutFragment(loader->url()).getString() : "",
+      std::move(requestInfo), monotonicallyIncreasingTime(), currentTime(),
+      std::move(initiatorObject),
       buildObjectForResourceResponse(redirectResponse), resourceType);
   if (m_pendingXHRReplayData && !m_pendingXHRReplayData->async())
     frontend()->flush();
 }
 
 void InspectorNetworkAgent::willSendRequest(
-    LocalFrame* frame,
     unsigned long identifier,
     DocumentLoader* loader,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo& initiatorInfo) {
   // Ignore the request initiated internally.
   if (initiatorInfo.name == FetchInitiatorTypeNames::internal)
     return;
 
   if (initiatorInfo.name == FetchInitiatorTypeNames::document &&
@@ skipping 19 matching lines @@
         request.requestContext() != WebURLRequest::RequestContextInternal) {
       request.setCachePolicy(WebCachePolicy::BypassCacheLoadOnlyFromCache);
     } else {
       request.setCachePolicy(WebCachePolicy::BypassingCache);
     }
     request.setShouldResetAppCache(true);
   }
   if (m_state->booleanProperty(NetworkAgentState::bypassServiceWorker, false))
     request.setServiceWorkerMode(WebURLRequest::ServiceWorkerMode::None);
 
-  willSendRequestInternal(frame, identifier, loader, request, redirectResponse,
+  willSendRequestInternal(identifier, loader, request, redirectResponse,
                           initiatorInfo);
 
   if (!m_hostId.isEmpty())
     request.addHTTPHeaderField(
         HTTPNames::X_DevTools_Emulate_Network_Conditions_Client_Id,
         AtomicString(m_hostId));
 
   request.setHTTPHeaderField(
       HTTPNames::X_DevTools_Request_Id,
       AtomicString(IdentifiersFactory::requestId(identifier)));
 }
 
 void InspectorNetworkAgent::markResourceAsCached(unsigned long identifier) {
   frontend()->requestServedFromCache(IdentifiersFactory::requestId(identifier));
 }
 
 void InspectorNetworkAgent::didReceiveResourceResponse(
-    LocalFrame* frame,
     unsigned long identifier,
     DocumentLoader* loader,
     const ResourceResponse& response,
     Resource* cachedResource) {
   String requestId = IdentifiersFactory::requestId(identifier);
   bool isNotModified = response.httpStatusCode() == 304;
 
   bool resourceIsEmpty = true;
   std::unique_ptr<protocol::Network::Response> resourceResponse =
       buildObjectForResourceResponse(response, cachedResource,
@@ skipping 15 matching lines @@
   if (type == InspectorPageAgent::DocumentResource && loader &&
       loader->substituteData().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 (cachedResource)
     m_resourcesData->addResource(requestId, cachedResource);
-  String frameId = IdentifiersFactory::frameId(frame);
+  String frameId = loader && loader->frame()
+                       ? IdentifiersFactory::frameId(loader->frame())
+                       : "";
   String loaderId = loader ? IdentifiersFactory::loaderId(loader) : "";
   m_resourcesData->responseReceived(requestId, frameId, response);
   m_resourcesData->setResourceType(requestId, type);
 
   if (response.getSecurityStyle() != ResourceResponse::SecurityStyleUnknown &&
       response.getSecurityStyle() !=
           ResourceResponse::SecurityStyleUnauthenticated) {
     const ResourceResponse::SecurityDetails* responseSecurityDetails =
         response.getSecurityDetails();
     m_resourcesData->setCertificate(requestId,
                                     responseSecurityDetails->certificate);
   }
 
   if (resourceResponse && !resourceIsEmpty)
     frontend()->responseReceived(requestId, frameId, loaderId,
                                  monotonicallyIncreasingTime(),
                                  InspectorPageAgent::resourceTypeJson(type),
                                  std::move(resourceResponse));
   // 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 (isNotModified && cachedResource && cachedResource->encodedSize())
-    didReceiveData(frame, identifier, 0, cachedResource->encodedSize());
+    didReceiveData(identifier, loader, 0, cachedResource->encodedSize());
 }
 
 static bool isErrorStatusCode(int statusCode) {
   return statusCode >= 400;
 }
 
-void InspectorNetworkAgent::didReceiveData(LocalFrame*,
-                                           unsigned long identifier,
+void InspectorNetworkAgent::didReceiveData(unsigned long identifier,
+                                           DocumentLoader* loader,
                                            const char* data,
                                            int dataLength) {
   String requestId = IdentifiersFactory::requestId(identifier);
 
   if (data) {
     NetworkResourcesData::ResourceData const* resourceData =
         m_resourcesData->data(requestId);
     if (resourceData &&
         (!resourceData->cachedResource() ||
          resourceData->cachedResource()->getDataBufferingPolicy() ==
              DoNotBufferData ||
          isErrorStatusCode(resourceData->httpStatusCode())))
       m_resourcesData->maybeAddResourceData(requestId, data, dataLength);
   }
 
   frontend()->dataReceived(
       requestId, monotonicallyIncreasingTime(), dataLength,
       m_resourcesData->getAndClearPendingEncodedDataLength(requestId));
 }
 
 void InspectorNetworkAgent::didReceiveEncodedDataLength(
-    LocalFrame*,
     unsigned long identifier,
     int encodedDataLength) {
   String requestId = IdentifiersFactory::requestId(identifier);
   m_resourcesData->addPendingEncodedDataLength(requestId, encodedDataLength);
 }
 
-void InspectorNetworkAgent::didFinishLoading(LocalFrame*,
-                                             unsigned long identifier,
+void InspectorNetworkAgent::didFinishLoading(unsigned long identifier,
+                                             DocumentLoader*,
                                              double monotonicFinishTime,
                                              int64_t encodedDataLength,
                                              int64_t decodedBodyLength) {
   String requestId = IdentifiersFactory::requestId(identifier);
   NetworkResourcesData::ResourceData const* resourceData =
       m_resourcesData->data(requestId);
 
   int pendingEncodedDataLength =
       m_resourcesData->getAndClearPendingEncodedDataLength(requestId);
   if (pendingEncodedDataLength > 0) {
@@ skipping 16 matching lines @@
                               encodedDataLength);
 }
 
 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 requestId = IdentifiersFactory::requestId(identifier);
   bool canceled = error.isCancellation();
   frontend()->loadingFailed(requestId, monotonicallyIncreasingTime(),
                             InspectorPageAgent::resourceTypeJson(
                                 m_resourcesData->resourceType(requestId)),
@@ skipping 65 matching lines @@
   m_pendingXHRReplayData = XHRReplayData::create(
       xhr->getExecutionContext(), method, urlWithoutFragment(url), async,
       formData.get(), includeCredentials);
   for (const auto& header : headers)
     m_pendingXHRReplayData->addHeader(header.key, header.value);
 }
 
 void InspectorNetworkAgent::delayedRemoveReplayXHR(XMLHttpRequest* xhr) {
   if (!m_replayXHRs.contains(xhr))
     return;
+  // TODO(horo): |m_removeFinishedReplayXHRTimer| is null on workers.
+  DCHECK(m_removeFinishedReplayXHRTimer);
   m_replayXHRsToBeDeleted.insert(xhr);
   m_replayXHRs.erase(xhr);
-  m_removeFinishedReplayXHRTimer.startOneShot(0, BLINK_FROM_HERE);
+  m_removeFinishedReplayXHRTimer->startOneShot(0, BLINK_FROM_HERE);
 }
 
 void InspectorNetworkAgent::didFailXHRLoading(ExecutionContext* context,
                                               XMLHttpRequest* xhr,
                                               ThreadableLoaderClient* client,
                                               const AtomicString& method,
                                               const String& url) {
   didFinishXHRInternal(context, xhr, client, method, url, false);
 }
 
@@ skipping 468 matching lines @@
   else
     networkStateNotifier().clearOverride();
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setCacheDisabled(bool cacheDisabled) {
   // TODO(ananta)
   // We should extract network cache state into a global entity which can be
   // queried from FrameLoader and other places.
   m_state->setBoolean(NetworkAgentState::cacheDisabled, cacheDisabled);
-  if (cacheDisabled)
+  if (cacheDisabled && isMainThread())
     memoryCache()->evictResources();
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setBypassServiceWorker(bool bypass) {
   m_state->setBoolean(NetworkAgentState::bypassServiceWorker, bypass);
   return Response::OK();
 }
 
 Response InspectorNetworkAgent::setDataSizeLimitsForTest(int maxTotal,
@@ skipping 19 matching lines @@
     }
   }
   return Response::OK();
 }
 
 void InspectorNetworkAgent::didCommitLoad(LocalFrame* frame,
                                           DocumentLoader* loader) {
   if (loader->frame() != m_inspectedFrames->root())
     return;
 
-  if (m_state->booleanProperty(NetworkAgentState::cacheDisabled, false))
+  if (m_state->booleanProperty(NetworkAgentState::cacheDisabled, false) &&
+      isMainThread())
     memoryCache()->evictResources(MemoryCache::DoNotEvictUnusedPreloads);
 
   m_resourcesData->clear(IdentifiersFactory::loaderId(loader));
 }
 
 void InspectorNetworkAgent::frameScheduledNavigation(LocalFrame* frame,
                                                      double) {
   String frameId = IdentifiersFactory::frameId(frame);
   m_framesWithScheduledNavigation.insert(frameId);
   if (!m_framesWithScheduledClientNavigation.contains(frameId)) {
@@ skipping 29 matching lines @@
 void InspectorNetworkAgent::setHostId(const String& hostId) {
   m_hostId = hostId;
 }
 
 bool InspectorNetworkAgent::fetchResourceContent(Document* document,
                                                  const KURL& url,
                                                  String* content,
                                                  bool* base64Encoded) {
   // First try to fetch content from the cached resource.
   Resource* cachedResource = document->fetcher()->cachedResource(url);
-  if (!cachedResource)
+  if (!cachedResource && isMainThread()) {
     cachedResource = memoryCache()->resourceForURL(
         url, document->fetcher()->getCacheIdentifier());
+  }
   if (cachedResource && InspectorPageAgent::cachedResourceContent(
                             cachedResource, content, base64Encoded))
     return true;
 
   // Then fall back to resource data.
   for (auto& resource : m_resourcesData->resources()) {
     if (resource->requestedURL() == url) {
       *content = resource->content();
       *base64Encoded = resource->base64Encoded();
       return true;
@@ skipping 11 matching lines @@
 void InspectorNetworkAgent::removeFinishedReplayXHRFired(TimerBase*) {
   m_replayXHRsToBeDeleted.clear();
 }
 
 InspectorNetworkAgent::InspectorNetworkAgent(InspectedFrames* inspectedFrames)
     : m_inspectedFrames(inspectedFrames),
       m_resourcesData(NetworkResourcesData::create(maximumTotalBufferSize,
                                                    maximumResourceBufferSize)),
       m_pendingRequest(nullptr),
       m_removeFinishedReplayXHRTimer(
-          TaskRunnerHelper::get(TaskType::UnspecedLoading,
-                                inspectedFrames->root()),
-          this,
-          &InspectorNetworkAgent::removeFinishedReplayXHRFired) {}
+          inspectedFrames
+              ? new TaskRunnerTimer<InspectorNetworkAgent>(
+                    TaskRunnerHelper::get(TaskType::UnspecedLoading,
+                                          inspectedFrames->root()),
+                    this,
+                    &InspectorNetworkAgent::removeFinishedReplayXHRFired)
+              : nullptr) {}
 
 void InspectorNetworkAgent::shouldForceCORSPreflight(bool* result) {
   if (m_state->booleanProperty(NetworkAgentState::cacheDisabled, false))
     *result = true;
 }
 
 }  // namespace blink