[wip]devtools

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/WorkerFetchContext.h"
 
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "core/loader/MixedContentChecker.h"
+#include "core/probe/CoreProbes.h"
 #include "core/timing/WorkerGlobalScopePerformance.h"
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerGlobalScope.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/Supplementable.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/scheduler/child/web_scheduler.h"
+#include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMixedContent.h"
 #include "public/platform/WebMixedContentContextType.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebWorkerFetchContext.h"
 
 namespace blink {
 
 namespace {
@@ skipping 90 matching lines @@
 SecurityContext* WorkerFetchContext::GetParentSecurityContext() const {
   // This method was introduced to check the parent frame's security context
   // while loading iframe document resources. So this method is not suitable for
   // workers.
   NOTREACHED();
   return nullptr;
 }
 
 bool WorkerFetchContext::ShouldBlockRequestByInspector(
     const ResourceRequest& resource_request) const {
-  // TODO(horo): Implement this.
-  return false;
+  bool should_block_request = false;
+  probe::shouldBlockRequest(worker_global_scope_, resource_request,
+                            &should_block_request);
+  return should_block_request;
 }
 
 void WorkerFetchContext::DispatchDidBlockRequest(
     const ResourceRequest& resource_request,
     const FetchInitiatorInfo& fetch_initiator_info,
     ResourceRequestBlockedReason blocked_reason) const {
-  // TODO(horo): Implement this.
+  probe::didBlockRequest(worker_global_scope_, resource_request, nullptr,
+                         fetch_initiator_info, blocked_reason);
 }
 
 void WorkerFetchContext::ReportLocalLoadFailed(const KURL&) const {
   // Threre is no way to load local files from worker thread.
   NOTREACHED();
 }
 
 bool WorkerFetchContext::ShouldBypassMainWorldCSP() const {
   // This method was introduced to bypass the page's CSP while running the
   // script from an isolated world (ex: Chrome extensions). But worker threads
@@ skipping 26 matching lines @@
 std::unique_ptr<WebURLLoader> WorkerFetchContext::CreateURLLoader() {
   return web_context_->CreateURLLoader();
 }
 
 bool WorkerFetchContext::IsControlledByServiceWorker() const {
   return web_context_->IsControlledByServiceWorker();
 }
 
 void WorkerFetchContext::PrepareRequest(ResourceRequest& request,
                                         RedirectType) {
+  String user_agent = worker_global_scope_->UserAgent();
+  probe::applyUserAgentOverride(worker_global_scope_, &user_agent);
+  DCHECK(!user_agent.IsNull());
+  request.SetHTTPUserAgent(AtomicString(user_agent));
+
   request.OverrideLoadingIPCType(WebURLRequest::LoadingIPCType::kMojo);
   WrappedResourceRequest webreq(request);
   web_context_->WillSendRequest(webreq);
 }
 
 RefPtr<WebTaskRunner> WorkerFetchContext::LoadingTaskRunner() const {
   return loading_task_runner_;
 }
 
 void WorkerFetchContext::AddAdditionalRequestHeaders(ResourceRequest& request,
                                                      FetchResourceType type) {
   BaseFetchContext::AddAdditionalRequestHeaders(request, type);
 
   // The remaining modifications are only necessary for HTTP and HTTPS.
   if (!request.Url().IsEmpty() && !request.Url().ProtocolIsInHTTPFamily())
     return;
 
   if (web_context_->IsDataSaverEnabled())
     request.SetHTTPHeaderField("Save-Data", "on");
 }
 
+void WorkerFetchContext::DispatchWillSendRequest(
+    unsigned long identifier,
+    ResourceRequest& request,
+    const ResourceResponse& redirect_response,
+    const FetchInitiatorInfo& initiator_info) {
+  probe::willSendRequest(worker_global_scope_, identifier, nullptr, request,
+                         redirect_response, initiator_info);
+}
+
 void WorkerFetchContext::DispatchDidReceiveResponse(
     unsigned long identifier,
     const ResourceResponse& response,
     WebURLRequest::FrameType frame_type,
     WebURLRequest::RequestContext request_context,
     Resource* resource,
     ResourceResponseType) {
   if (response.HasMajorCertificateErrors()) {
     WebMixedContentContextType context_type =
         WebMixedContent::ContextTypeFromRequestContext(
             request_context, false /* strictMixedContentCheckingForPlugin */);
     if (context_type == WebMixedContentContextType::kBlockable) {
       web_context_->DidRunContentWithCertificateErrors(response.Url());
     } else {
       web_context_->DidDisplayContentWithCertificateErrors(response.Url());
     }
   }
+  probe::didReceiveResourceResponse(worker_global_scope_, identifier, nullptr,
+                                    response, resource);
+}
+
+void WorkerFetchContext::DispatchDidReceiveData(unsigned long identifier,
+                                                const char* data,
+                                                int data_length) {
+  probe::didReceiveData(worker_global_scope_, identifier, nullptr, data,
+                        data_length);
+}
+
+void WorkerFetchContext::DispatchDidReceiveEncodedData(
+    unsigned long identifier,
+    int encoded_data_length) {
+  probe::didReceiveEncodedDataLength(worker_global_scope_, identifier,
+                                     encoded_data_length);
+}
+
+void WorkerFetchContext::DispatchDidFinishLoading(unsigned long identifier,
+                                                  double finish_time,
+                                                  int64_t encoded_data_length,
+                                                  int64_t decoded_body_length) {
+  probe::didFinishLoading(worker_global_scope_, identifier, nullptr,
+                          finish_time, encoded_data_length,
+                          decoded_body_length);
+}
+
+void WorkerFetchContext::DispatchDidFail(unsigned long identifier,
+                                         const ResourceError& error,
+                                         int64_t encoded_data_length,
+                                         bool is_internal_request) {
+  probe::didFailLoading(worker_global_scope_, identifier, error);
 }
 
 void WorkerFetchContext::AddResourceTiming(const ResourceTimingInfo& info) {
   WorkerGlobalScopePerformance::performance(*worker_global_scope_)
       ->AddResourceTiming(info);
 }
 
 void WorkerFetchContext::PopulateResourceRequest(
     const KURL& url,
     Resource::Type type,
@@ skipping 25 matching lines @@
 void ProvideWorkerFetchContextToWorker(
     WorkerClients* clients,
     std::unique_ptr<WebWorkerFetchContext> web_context) {
   DCHECK(clients);
   WorkerFetchContextHolder::ProvideTo(
       *clients, WorkerFetchContextHolder::SupplementName(),
       new WorkerFetchContextHolder(std::move(web_context)));
 }
 
 }  // namespace blink