Implement the infrastructure of creating WorkerFetchContext in worker global scope.

content/child/resource_dispatcher.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include <utility>
 
+#include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 39 matching lines @@
   base::debug::Alias(&last_err);
 #endif
   CHECK(false);
 }
 
 // Each resource request is assigned an ID scoped to this process.
 int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
-  static int next_request_id = 0;
-  return next_request_id++;
+  static base::StaticAtomicSequenceNumber sequence;
+  return sequence.GetNext();  // We start at zero.
 }
 
 void CheckSchemeForReferrerPolicy(const ResourceRequest& request) {
   if ((request.referrer_policy == blink::kWebReferrerPolicyDefault ||
        request.referrer_policy ==
            blink::kWebReferrerPolicyNoReferrerWhenDowngrade) &&
       request.referrer.SchemeIsCryptographic() &&
       !request.url.SchemeIsCryptographic()) {
     LOG(FATAL) << "Trying to send secure referrer for insecure request "
                << "without an appropriate referrer policy.\n"
                << "URL = " << request.url << "\n"
                << "Referrer = " << request.referrer;
   }
 }
 
 }  // namespace
 
 ResourceDispatcher::ResourceDispatcher(
     IPC::Sender* sender,
-    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner)
     : message_sender_(sender),
       delegate_(NULL),
       io_timestamp_(base::TimeTicks()),
-      main_thread_task_runner_(main_thread_task_runner),
-      weak_factory_(this) {
-}
+      thread_task_runner_(thread_task_runner),
+      weak_factory_(this) {}
 
 ResourceDispatcher::~ResourceDispatcher() {
 }
 
 bool ResourceDispatcher::OnMessageReceived(const IPC::Message& message) {
   if (!IsResourceDispatcherMessage(message)) {
     return false;
   }
 
   int request_id;
@@ skipping 286 matching lines @@
 
   // Cancel loading.
   it->second->url_loader = nullptr;
   // Clear URLLoaderClient to stop receiving further Mojo IPC from the browser
   // process.
   it->second->url_loader_client = nullptr;
 
   // Always delete the pending_request asyncly so that cancelling the request
   // doesn't delete the request context info while its response is still being
   // handled.
-  main_thread_task_runner_->DeleteSoon(FROM_HERE, it->second.release());
+  thread_task_runner_->DeleteSoon(FROM_HERE, it->second.release());
   pending_requests_.erase(it);
 
   if (release_downloaded_file) {
     message_sender_->Send(
         new ResourceHostMsg_ReleaseDownloadedFile(request_id));
   }
 
   if (resource_scheduling_filter_.get())
     resource_scheduling_filter_->ClearRequestIdTaskRunner(request_id);
 
@@ skipping 48 matching lines @@
     if (request_info->url_loader_client)
       request_info->url_loader_client->SetDefersLoading();
   } else if (request_info->is_deferred) {
     request_info->is_deferred = false;
 
     if (request_info->url_loader_client)
       request_info->url_loader_client->UnsetDefersLoading();
 
     FollowPendingRedirect(request_id, request_info);
 
-    main_thread_task_runner_->PostTask(
+    thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ResourceDispatcher::FlushDeferredMessages,
                               weak_factory_.GetWeakPtr(), request_id));
   }
 }
 
 void ResourceDispatcher::DidChangePriority(int request_id,
                                            net::RequestPriority new_priority,
                                            int intra_priority_value) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   DCHECK(request_info);
@@ skipping 148 matching lines @@
   pending_requests_[request_id] = base::MakeUnique<PendingRequestInfo>(
       std::move(peer), request->resource_type, request->origin_pid,
       frame_origin, request->url, request->download_to_file);
 
   if (resource_scheduling_filter_.get() && loading_task_runner) {
     resource_scheduling_filter_->SetRequestIdTaskRunner(request_id,
                                                         loading_task_runner);
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      loading_task_runner ? loading_task_runner : main_thread_task_runner_;
+      loading_task_runner ? loading_task_runner : thread_task_runner_;
 
   if (consumer_handle.is_valid()) {
     pending_requests_[request_id]->url_loader_client =
         base::MakeUnique<URLLoaderClientImpl>(request_id, this, task_runner);
 
     task_runner->PostTask(FROM_HERE,
                           base::Bind(&ResourceDispatcher::ContinueForNavigation,
                                      weak_factory_.GetWeakPtr(), request_id,
                                      base::Passed(std::move(consumer_handle))));
 
     return request_id;
   }
 
   if (ipc_type == blink::WebURLRequest::LoadingIPCType::kMojo) {
     scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-        loading_task_runner ? loading_task_runner : main_thread_task_runner_;
+        loading_task_runner ? loading_task_runner : thread_task_runner_;
     std::unique_ptr<URLLoaderClientImpl> client(
         new URLLoaderClientImpl(request_id, this, std::move(task_runner)));
     mojom::URLLoaderAssociatedPtr url_loader;
     mojom::URLLoaderClientPtr client_ptr;
     client->Bind(&client_ptr);
     url_loader_factory->CreateLoaderAndStart(
         MakeRequest(&url_loader), routing_id, request_id,
         mojom::kURLLoadOptionNone, *request, std::move(client_ptr));
     pending_requests_[request_id]->url_loader = std::move(url_loader);
     pending_requests_[request_id]->url_loader_client = std::move(client);
@@ skipping 168 matching lines @@
     delete message;
   }
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content