Scheduler: Infrastructure to support using resource fetch priorities.

Provide support for experimenting with using resource fetch priorities
for resource loading tasks in blink.

Bug: 860545
Change-Id: I064f287ea2c96d67f532ba7dc03abb45875947c3
Reviewed-on: https://chromium-review.googlesource.com/1128857
Commit-Queue: Farah Charab <farahcharab@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#575821}

third_party/blink/public/BUILD.gn

@@ -194,6 +194,7 @@ source_set("blink_headers") {
     "platform/scheduler/single_thread_idle_task_runner.h",
     "platform/scheduler/web_main_thread_scheduler.h",
     "platform/scheduler/web_render_widget_scheduling_state.h",
+    "platform/scheduler/web_resource_loading_task_runner_handle.h",
     "platform/scheduler/web_thread_scheduler.h",
     "platform/scoped_web_callbacks.h",
     "platform/shape_properties.h",

third_party/blink/public/platform/scheduler/DEPS

@@ -13,3 +13,9 @@ include_rules = [
     "+build/build_config.h",
     "+v8/include/v8.h",
 ]
+
+specific_include_rules = {
+  "web_resource_loading_task_runner_handle.h": [
+    "+net/base/request_priority.h",
+  ]
+}

third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_WEB_RESOURCE_LOADING_TASK_RUNNER_HANDLE_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_SCHEDULER_WEB_RESOURCE_LOADING_TASK_RUNNER_HANDLE_H_
+
+#include "base/memory/scoped_refptr.h"
+#include "base/single_thread_task_runner.h"
+#include "net/base/request_priority.h"
+#include "third_party/blink/public/platform/web_common.h"
+
+namespace blink {
+namespace scheduler {
+
+// Provides an interface to the loading stack (i.e. WebURLLoader) to post
+// resource loading tasks and to notify the appropriate entities when a
+// resource's fetch priority changes.
+//
+// For tasks that are bound to a frame, a handle for a prioritizable task runner
+// can be obtained from the frame scheduler's exposed interface
+// CreateResourceLoadingTaskRunnerHandle.
+//
+// For the remaining tasks, the static function CreateUnprioritized (provided in
+// this API) can be used to get a handle for an unprioritizeable task runner.
+class BLINK_PLATFORM_EXPORT WebResourceLoadingTaskRunnerHandle {
+ public:
+  static std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
+  CreateUnprioritized(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+  virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const = 0;
+
+  virtual void DidChangeRequestPriority(net::RequestPriority priority) = 0;
+
+  virtual ~WebResourceLoadingTaskRunnerHandle() = default;
+};
+
+}  // namespace scheduler
+}  // namespace blink
+
+#endif

third_party/blink/public/platform/task_type.h

@@ -36,9 +36,15 @@ enum class TaskType : unsigned {
   // (e.g. click events) must be fired using tasks queued with the user
   // interaction task source.
   kUserInteraction = 2,
+  // TODO(altimin) Fix the networking task source related namings once it is
+  // clear how
+  // all loading tasks are annotated.
   // This task source is used for features that trigger in response to network
   // activity.
   kNetworking = 3,
+  // This is a part of Networking task source used to annotate tasks which are
+  // posted from the loading stack (i.e. WebURLLoader).
+  kNetworkingWithURLLoaderAnnotation = 50,
   // This task source is used for control messages between kNetworking tasks.
   kNetworkingControl = 4,
   // This task source is used to queue calls to history.back() and similar APIs.
@@ -188,7 +194,7 @@ enum class TaskType : unsigned {
   kWorkerThreadTaskQueueV8 = 47,
   kWorkerThreadTaskQueueCompositor = 48,
 
-  kCount = 50,
+  kCount = 51,
 };
 
 }  // namespace blink

third_party/blink/renderer/core/frame/local_frame.cc

@@ -36,6 +36,7 @@
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/blink/public/platform/interface_provider.h"
 #include "third_party/blink/public/platform/interface_registry.h"
+#include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
 #include "third_party/blink/public/platform/web_url_request.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_controller.h"
 #include "third_party/blink/renderer/core/CoreProbeSink.h"
@@ -152,6 +153,12 @@ class EmptyFrameScheduler final : public FrameScheduler {
     return Platform::Current()->MainThread()->GetTaskRunner();
   }
 
+  std::unique_ptr<scheduler::WebResourceLoadingTaskRunnerHandle>
+  CreateResourceLoadingTaskRunnerHandle() override {
+    return scheduler::WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
+        GetTaskRunner(TaskType::kNetworkingWithURLLoaderAnnotation));
+  }
+
   void SetFrameVisible(bool) override {}
   bool IsFrameVisible() const override { return false; }
   bool IsPageVisible() const override { return false; }

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -46,6 +46,9 @@ blink_platform_sources("scheduler") {
     "common/throttling/wake_up_budget_pool.h",
     "common/total_duration_metric_reporter.cc",
     "common/total_duration_metric_reporter.h",
+    "common/unprioritized_resource_loading_task_runner_handle.cc",
+    "common/unprioritized_resource_loading_task_runner_handle.h",
+    "common/web_resource_loading_task_runner_handle.cc",
     "common/web_thread_scheduler.cc",
     "main_thread/auto_advancing_virtual_time_domain.cc",
     "main_thread/auto_advancing_virtual_time_domain.h",
@@ -75,6 +78,8 @@ blink_platform_sources("scheduler") {
     "main_thread/queueing_time_estimator.h",
     "main_thread/render_widget_signals.cc",
     "main_thread/render_widget_signals.h",
+    "main_thread/resource_loading_task_runner_handle_impl.cc",
+    "main_thread/resource_loading_task_runner_handle_impl.h",
     "main_thread/task_cost_estimator.cc",
     "main_thread/task_cost_estimator.h",
     "main_thread/use_case.h",

third_party/blink/renderer/platform/scheduler/child/features.h

@@ -95,6 +95,11 @@ const base::Feature kBestEffortPriorityForAdFrame{
     "BlinkSchedulerBestEffortPriorityForAdFrame",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Enables using a resource's fetch priority to determine the priority of the
+// resource's loading tasks posted to blink's scheduler.
+const base::Feature kUseResourceFetchPriority{
+    "BlinkSchedulerResourceFetchPriority", base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Enables a chosen experiments only during the load use case.
 const base::Feature kExperimentOnlyWhenLoading{
     "BlinkSchedulerExperimentOnlyWhenLoading",

third_party/blink/renderer/platform/scheduler/common/unprioritized_resource_loading_task_runner_handle.cc

+#include "third_party/blink/renderer/platform/scheduler/common/unprioritized_resource_loading_task_runner_handle.h"
+
+#include "base/memory/ptr_util.h"
+
+namespace blink {
+namespace scheduler {
+
+std::unique_ptr<UnprioritizedResourceLoadingTaskRunnerHandle>
+UnprioritizedResourceLoadingTaskRunnerHandle::WrapTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(task_runner);
+  return base::WrapUnique(
+      new UnprioritizedResourceLoadingTaskRunnerHandle(std::move(task_runner)));
+}
+
+UnprioritizedResourceLoadingTaskRunnerHandle::
+    UnprioritizedResourceLoadingTaskRunnerHandle(
+        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : task_runner_(std::move(task_runner)){};
+
+scoped_refptr<base::SingleThreadTaskRunner>
+UnprioritizedResourceLoadingTaskRunnerHandle::GetTaskRunner() const {
+  return task_runner_;
+}
+
+void UnprioritizedResourceLoadingTaskRunnerHandle::DidChangeRequestPriority(
+    net::RequestPriority priority) {}
+
+}  // namespace scheduler
+}  // namespace blink

third_party/blink/renderer/platform/scheduler/common/unprioritized_resource_loading_task_runner_handle.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_COMMON_UNPRIORITIZED_RESOURCE_LOADING_TASK_RUNNER_HANDLE_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_COMMON_UNPRIORITIZED_RESOURCE_LOADING_TASK_RUNNER_HANDLE_H_
+
+#include <memory>
+
+#include "base/memory/scoped_refptr.h"
+#include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+
+namespace blink {
+namespace scheduler {
+
+// Provides a wrapper around task runners that do not support priorities.
+// Intended to be used by WebURLLoader for posting tasks that are not bound to a
+// frame.
+class PLATFORM_EXPORT UnprioritizedResourceLoadingTaskRunnerHandle
+    : public WebResourceLoadingTaskRunnerHandle {
+ public:
+  static std::unique_ptr<UnprioritizedResourceLoadingTaskRunnerHandle>
+  WrapTaskRunner(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override;
+
+  void DidChangeRequestPriority(net::RequestPriority priority) override;
+
+  ~UnprioritizedResourceLoadingTaskRunnerHandle() override = default;
+
+ protected:
+  explicit UnprioritizedResourceLoadingTaskRunnerHandle(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(UnprioritizedResourceLoadingTaskRunnerHandle);
+};
+
+}  // namespace scheduler
+}  // namespace blink
+
+#endif

third_party/blink/renderer/platform/scheduler/common/web_resource_loading_task_runner_handle.cc

+#include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
+
+#include "third_party/blink/renderer/platform/scheduler/common/unprioritized_resource_loading_task_runner_handle.h"
+
+namespace blink {
+namespace scheduler {
+
+std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
+WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(task_runner);
+  return UnprioritizedResourceLoadingTaskRunnerHandle::WrapTaskRunner(
+      std::move(task_runner));
+}
+
+}  // namespace scheduler
+}  // namespace blink

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc

@@ -5,6 +5,7 @@
 #include "third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.h"
 
 #include <memory>
+
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/blame_context.h"
 #include "third_party/blink/public/platform/blame_context.h"
@@ -17,6 +18,7 @@
 #include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/page_visibility_state.h"
+#include "third_party/blink/renderer/platform/scheduler/main_thread/resource_loading_task_runner_handle_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/util/tracing_helper.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/worker_scheduler_proxy.h"
 
@@ -207,6 +209,10 @@ FrameSchedulerImpl::~FrameSchedulerImpl() {
   CleanUpQueue(pausable_task_queue_.get());
   CleanUpQueue(unpausable_task_queue_.get());
 
+  for (const auto& pair : resource_loading_task_queues_) {
+    CleanUpQueue(pair.key.get());
+  }
+
   if (parent_page_scheduler_) {
     parent_page_scheduler_->Unregister(this);
 
@@ -247,7 +253,6 @@ void FrameSchedulerImpl::SetFrameVisible(bool frame_visible) {
   UMA_HISTOGRAM_BOOLEAN("RendererScheduler.IPC.FrameVisibility", frame_visible);
   frame_visible_ = frame_visible;
   UpdatePolicy();
-  UpdateQueuePriorities();
 }
 
 bool FrameSchedulerImpl::IsFrameVisible() const {
@@ -270,7 +275,7 @@ void FrameSchedulerImpl::SetCrossOrigin(bool cross_origin) {
 
 void FrameSchedulerImpl::SetIsAdFrame() {
   is_ad_frame_ = true;
-  UpdateQueuePriorities();
+  UpdatePolicy();
 }
 
 bool FrameSchedulerImpl::IsAdFrame() const {
@@ -297,6 +302,7 @@ scoped_refptr<base::SingleThreadTaskRunner> FrameSchedulerImpl::GetTaskRunner(
       return TaskQueueWithTaskType::Create(ThrottleableTaskQueue(), type);
     case TaskType::kInternalLoading:
     case TaskType::kNetworking:
+    case TaskType::kNetworkingWithURLLoaderAnnotation:
       return TaskQueueWithTaskType::Create(LoadingTaskQueue(), type);
     case TaskType::kNetworkingControl:
       return TaskQueueWithTaskType::Create(LoadingControlTaskQueue(), type);
@@ -370,20 +376,82 @@ scoped_refptr<base::SingleThreadTaskRunner> FrameSchedulerImpl::GetTaskRunner(
   return nullptr;
 }
 
+std::pair<scoped_refptr<MainThreadTaskQueue>,
+          std::unique_ptr<TaskQueue::QueueEnabledVoter>>
+FrameSchedulerImpl::CreateNewLoadingTaskQueue() {
+  // TODO(panicker): Avoid adding this queue in RS task_runners_.
+  scoped_refptr<MainThreadTaskQueue> loading_task_queue =
+      main_thread_scheduler_->NewLoadingTaskQueue(
+          MainThreadTaskQueue::QueueType::kFrameLoading, this);
+  loading_task_queue->SetBlameContext(blame_context_);
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+      loading_task_queue->CreateQueueEnabledVoter();
+  voter->SetQueueEnabled(!frame_paused_);
+  return std::make_pair(loading_task_queue, std::move(voter));
+}
+
 scoped_refptr<TaskQueue> FrameSchedulerImpl::LoadingTaskQueue() {
   DCHECK(parent_page_scheduler_);
   if (!loading_task_queue_) {
-    // TODO(panicker): Avoid adding this queue in RS task_runners_.
-    loading_task_queue_ = main_thread_scheduler_->NewLoadingTaskQueue(
-        MainThreadTaskQueue::QueueType::kFrameLoading, this);
-    loading_task_queue_->SetBlameContext(blame_context_);
-    loading_queue_enabled_voter_ =
-        loading_task_queue_->CreateQueueEnabledVoter();
-    loading_queue_enabled_voter_->SetQueueEnabled(!frame_paused_);
+    auto queue_voter_pair = CreateNewLoadingTaskQueue();
+    loading_task_queue_ = queue_voter_pair.first;
+    loading_queue_enabled_voter_ = std::move(queue_voter_pair.second);
   }
   return loading_task_queue_;
 }
 
+std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
+FrameSchedulerImpl::CreateResourceLoadingTaskRunnerHandle() {
+  return CreateResourceLoadingTaskRunnerHandleImpl();
+}
+
+std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl>
+FrameSchedulerImpl::CreateResourceLoadingTaskRunnerHandleImpl() {
+  if (main_thread_scheduler_->scheduling_settings()
+          .use_resource_fetch_priority) {
+    auto queue_voter_pair = CreateNewLoadingTaskQueue();
+
+    resource_loading_task_queues_.insert(
+        queue_voter_pair.first, ResourceLoadingTaskQueueMetadata(
+                                    queue_voter_pair.first->GetQueuePriority(),
+                                    std::move(queue_voter_pair.second)));
+
+    return ResourceLoadingTaskRunnerHandleImpl::WrapTaskRunner(
+        queue_voter_pair.first);
+  }
+
+  // Make sure the loading task queue exists.
+  LoadingTaskQueue();
+  return ResourceLoadingTaskRunnerHandleImpl::WrapTaskRunner(
+      loading_task_queue_);
+}
+
+void FrameSchedulerImpl::DidChangeResourceLoadingPriority(
+    scoped_refptr<MainThreadTaskQueue> task_queue,
+    TaskQueue::QueuePriority priority) {
+  // This check is done since in some cases (when kUseResourceFetchPriority
+  // feature isn't enabled) we use |loading_task_queue_| for resource loading
+  // and the priority of this queue shouldn't be affected by resource
+  // priorities.
+  auto queue_metadata_pair = resource_loading_task_queues_.find(task_queue);
+  if (queue_metadata_pair != resource_loading_task_queues_.end()) {
+    queue_metadata_pair->value.priority = priority;
+    UpdateQueuePolicy(task_queue.get(), queue_metadata_pair->value.voter.get());
+  }
+}
+
+void FrameSchedulerImpl::OnShutdownResourceLoadingTaskQueue(
+    scoped_refptr<MainThreadTaskQueue> task_queue) {
+  // This check is done since in some cases (when kUseResourceFetchPriority
+  // feature isn't enabled) we use |loading_task_queue_| for resource loading,
+  // and the lifetime of this queue isn't bound to one resource.
+  auto iter = resource_loading_task_queues_.find(task_queue);
+  if (iter != resource_loading_task_queues_.end()) {
+    resource_loading_task_queues_.erase(iter);
+    CleanUpQueue(task_queue.get());
+  }
+}
+
 scoped_refptr<TaskQueue> FrameSchedulerImpl::LoadingControlTaskQueue() {
   DCHECK(parent_page_scheduler_);
   if (!loading_control_task_queue_) {
@@ -519,15 +587,6 @@ void FrameSchedulerImpl::DidCloseActiveConnection() {
     parent_page_scheduler_->OnConnectionUpdated();
 }
 
-void FrameSchedulerImpl::UpdateQueuePriorities() {
-  UpdatePriority(loading_task_queue_.get());
-  UpdatePriority(loading_control_task_queue_.get());
-  UpdatePriority(throttleable_task_queue_.get());
-  UpdatePriority(deferrable_task_queue_.get());
-  UpdatePriority(pausable_task_queue_.get());
-  UpdatePriority(unpausable_task_queue_.get());
-}
-
 void FrameSchedulerImpl::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetBoolean("frame_visible", frame_visible_);
@@ -564,6 +623,13 @@ void FrameSchedulerImpl::AsValueInto(
     state->SetString("unpausable_task_queue",
                      PointerToString(unpausable_task_queue_.get()));
   }
+
+  state->BeginArray("resource_loading_task_queues");
+  for (const auto& queue : resource_loading_task_queues_) {
+    state->AppendString(PointerToString(queue.key.get()));
+  }
+  state->EndArray();
+
   if (blame_context_) {
     state->BeginDictionary("blame_context");
     state->SetString(
@@ -617,6 +683,11 @@ void FrameSchedulerImpl::UpdatePolicy() {
   UpdateQueuePolicy(deferrable_task_queue_,
                     deferrable_queue_enabled_voter_.get());
   UpdateQueuePolicy(pausable_task_queue_, pausable_queue_enabled_voter_.get());
+  UpdateQueuePolicy(unpausable_task_queue_, nullptr);
+
+  for (const auto& pair : resource_loading_task_queues_) {
+    UpdateQueuePolicy(pair.key, pair.value.voter.get());
+  }
 
   UpdateThrottling();
 
@@ -626,7 +697,10 @@ void FrameSchedulerImpl::UpdatePolicy() {
 void FrameSchedulerImpl::UpdateQueuePolicy(
     const scoped_refptr<MainThreadTaskQueue>& queue,
     TaskQueue::QueueEnabledVoter* voter) {
-  if (!queue || !voter)
+  if (!queue)
+    return;
+  UpdatePriority(queue.get());
+  if (!voter)
     return;
   DCHECK(parent_page_scheduler_);
   bool queue_paused = frame_paused_ && queue->CanBePaused();
@@ -717,6 +791,12 @@ TaskQueue::QueuePriority FrameSchedulerImpl::ComputePriority(
   // Checks the task queue is associated with this frame scheduler.
   DCHECK_EQ(frame_scheduler, this);
 
+  auto queue_metadata_pair =
+      resource_loading_task_queues_.find(base::WrapRefCounted(task_queue));
+  if (queue_metadata_pair != resource_loading_task_queues_.end()) {
+    return queue_metadata_pair->value.priority;
+  }
+
   base::Optional<TaskQueue::QueuePriority> fixed_priority =
       task_queue->FixedPriority();
 
@@ -778,8 +858,6 @@ TaskQueue::QueuePriority FrameSchedulerImpl::ComputePriority(
     }
   }
 
-  // TODO(farahcharab) Change highest priority to high priority for frame
-  // loading control.
   return task_queue->queue_type() ==
                  MainThreadTaskQueue::QueueType::kFrameLoadingControl
              ? TaskQueue::QueuePriority::kHighPriority

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_FRAME_SCHEDULER_IMPL_H_
 
 #include <memory>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
@@ -19,6 +20,7 @@
 #include "third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h"
 #include "third_party/blink/renderer/platform/scheduler/util/tracing_helper.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/worker_scheduler_proxy.h"
+#include "third_party/blink/renderer/platform/wtf/hash_map.h"
 
 namespace base {
 namespace sequence_manager {
@@ -36,6 +38,7 @@ namespace scheduler {
 class MainThreadSchedulerImpl;
 class MainThreadTaskQueue;
 class PageSchedulerImpl;
+class ResourceLoadingTaskRunnerHandleImpl;
 
 namespace main_thread_scheduler_impl_unittest {
 class MainThreadSchedulerImplTest;
@@ -75,6 +78,14 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
   void TraceUrlChange(const String& url) override;
   FrameScheduler::FrameType GetFrameType() const override;
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner(TaskType) override;
+
+  // Returns a wrapper around an instance of MainThreadTaskQueue which is
+  // maintained in |resource_loading_task_queues_| map. The main thread task
+  // queue is removed from the map and detached from both the main thread and
+  // the frame schedulers when the wrapper instance goes out of scope.
+  std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
+  CreateResourceLoadingTaskRunnerHandle() override;
+
   PageScheduler* GetPageScheduler() const override;
   void DidStartProvisionalLoad(bool is_main_frame) override;
   void DidCommitProvisionalLoad(bool is_web_history_inert_commit,
@@ -118,11 +129,19 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
   // page scheduler. Should be used only for testing purposes.
   FrameSchedulerImpl();
 
+  void OnShutdownResourceLoadingTaskQueue(
+      scoped_refptr<MainThreadTaskQueue> task_queue);
+
+  void DidChangeResourceLoadingPriority(
+      scoped_refptr<MainThreadTaskQueue> task_queue,
+      base::sequence_manager::TaskQueue::QueuePriority priority);
+
  private:
   friend class PageSchedulerImpl;
   friend class main_thread_scheduler_impl_unittest::MainThreadSchedulerImplTest;
   friend class frame_scheduler_impl_unittest::FrameSchedulerImplTest;
   friend class page_scheduler_impl_unittest::PageSchedulerImplTest;
+  friend class ResourceLoadingTaskRunnerHandleImpl;
 
   class ActiveConnectionHandleImpl : public ActiveConnectionHandle {
    public:
@@ -152,6 +171,19 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
     DISALLOW_COPY_AND_ASSIGN(PauseSubresourceLoadingHandleImpl);
   };
 
+  struct ResourceLoadingTaskQueueMetadata {
+    ResourceLoadingTaskQueueMetadata(){};
+
+    ResourceLoadingTaskQueueMetadata(
+        base::sequence_manager::TaskQueue::QueuePriority queue_priority,
+        std::unique_ptr<base::sequence_manager::TaskQueue::QueueEnabledVoter>
+            queue_voter)
+        : priority(queue_priority), voter(std::move(queue_voter)) {}
+
+    base::sequence_manager::TaskQueue::QueuePriority priority;
+    std::unique_ptr<base::sequence_manager::TaskQueue::QueueEnabledVoter> voter;
+  };
+
   void DetachFromPageScheduler();
   void RemoveThrottleableQueueFromBackgroundCPUTimeBudgetPool();
   void ApplyPolicyToThrottleableQueue();
@@ -166,13 +198,17 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
   void DidOpenActiveConnection();
   void DidCloseActiveConnection();
 
-  // Updates the priorities of all the task queues associated with this
-  // frame scheduler.
-  void UpdateQueuePriorities();
-
   void AddPauseSubresourceLoadingHandle();
   void RemovePauseSubresourceLoadingHandle();
 
+  std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl>
+  CreateResourceLoadingTaskRunnerHandleImpl();
+
+  std::pair<
+      scoped_refptr<MainThreadTaskQueue>,
+      std::unique_ptr<base::sequence_manager::TaskQueue::QueueEnabledVoter>>
+  CreateNewLoadingTaskQueue();
+
   scoped_refptr<base::sequence_manager::TaskQueue> LoadingTaskQueue();
   scoped_refptr<base::sequence_manager::TaskQueue> LoadingControlTaskQueue();
   scoped_refptr<base::sequence_manager::TaskQueue> ThrottleableTaskQueue();
@@ -201,6 +237,14 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
       deferrable_queue_enabled_voter_;
   std::unique_ptr<base::sequence_manager::TaskQueue::QueueEnabledVoter>
       pausable_queue_enabled_voter_;
+
+  using ResourceLoadingTaskQueueMetadataMap =
+      WTF::HashMap<scoped_refptr<MainThreadTaskQueue>,
+                   ResourceLoadingTaskQueueMetadata>;
+
+  // Holds queues created by CreateResourceLoadingTaskRunnerHandle.
+  ResourceLoadingTaskQueueMetadataMap resource_loading_task_queues_;
+
   MainThreadSchedulerImpl* main_thread_scheduler_;  // NOT OWNED
   PageSchedulerImpl* parent_page_scheduler_;        // NOT OWNED
   base::trace_event::BlameContext* blame_context_;  // NOT OWNED

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl_unittest.cc

@@ -18,6 +18,7 @@
 #include "third_party/blink/renderer/platform/scheduler/child/features.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h"
+#include "third_party/blink/renderer/platform/scheduler/main_thread/resource_loading_task_runner_handle_impl.h"
 #include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h"
 #include "third_party/blink/renderer/platform/web_task_runner.h"
 
@@ -100,6 +101,11 @@ class FrameSchedulerImplTest : public testing::Test {
     return frame_scheduler_->UnpausableTaskQueue();
   }
 
+  std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl>
+  GetResourceLoadingTaskRunnerHandleImpl() {
+    return frame_scheduler_->CreateResourceLoadingTaskRunnerHandleImpl();
+  }
+
   bool IsThrottled() {
     EXPECT_TRUE(throttleable_task_queue());
     return scheduler_->task_queue_throttler()->IsThrottled(
@@ -111,6 +117,12 @@ class FrameSchedulerImplTest : public testing::Test {
     return frame_scheduler_->CalculateLifecycleState(type);
   }
 
+  void DidChangeResourceLoadingPriority(
+      scoped_refptr<MainThreadTaskQueue> task_queue,
+      TaskQueue::QueuePriority priority) {
+    frame_scheduler_->DidChangeResourceLoadingPriority(task_queue, priority);
+  }
+
   base::test::ScopedFeatureList feature_list_;
   base::test::ScopedTaskEnvironment task_environment_;
   std::unique_ptr<MainThreadSchedulerImpl> scheduler_;
@@ -1319,6 +1331,52 @@ TEST_F(BestEffortPriorityAdFrameDuringLoadingExperimentTest,
             TaskQueue::QueuePriority::kNormalPriority);
 }
 
+class ResourceFetchPriorityExperimentTest : public FrameSchedulerImplTest {
+ public:
+  ResourceFetchPriorityExperimentTest()
+      : FrameSchedulerImplTest({kUseResourceFetchPriority}, {}) {}
+};
+
+TEST_F(ResourceFetchPriorityExperimentTest, DidChangePriority) {
+  std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl> handle =
+      GetResourceLoadingTaskRunnerHandleImpl();
+  scoped_refptr<MainThreadTaskQueue> task_queue = handle->task_queue();
+
+  TaskQueue::QueuePriority priority = task_queue->GetQueuePriority();
+  EXPECT_EQ(priority, TaskQueue::QueuePriority::kNormalPriority);
+
+  DidChangeResourceLoadingPriority(task_queue,
+                                   TaskQueue::QueuePriority::kLowPriority);
+  EXPECT_EQ(task_queue->GetQueuePriority(),
+            TaskQueue::QueuePriority::kLowPriority);
+
+  DidChangeResourceLoadingPriority(task_queue,
+                                   TaskQueue::QueuePriority::kHighPriority);
+  EXPECT_EQ(task_queue->GetQueuePriority(),
+            TaskQueue::QueuePriority::kHighPriority);
+}
+
+TEST_F(
+    FrameSchedulerImplTest,
+    DidChangeResourceLoadingPriority_ResourceFecthPriorityExperimentDisabled) {
+  // If the experiment is disabled, we use |loading_task_queue_| for resource
+  // loading tasks and we don't want the priority of this queue to be affected
+  // by individual resources.
+  std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl> handle =
+      GetResourceLoadingTaskRunnerHandleImpl();
+  scoped_refptr<MainThreadTaskQueue> task_queue = handle->task_queue();
+
+  TaskQueue::QueuePriority priority = task_queue->GetQueuePriority();
+
+  DidChangeResourceLoadingPriority(task_queue,
+                                   TaskQueue::QueuePriority::kLowPriority);
+  EXPECT_EQ(task_queue->GetQueuePriority(), priority);
+
+  DidChangeResourceLoadingPriority(task_queue,
+                                   TaskQueue::QueuePriority::kHighPriority);
+  EXPECT_EQ(task_queue->GetQueuePriority(), priority);
+}
+
 }  // namespace frame_scheduler_impl_unittest
 }  // namespace scheduler
 }  // namespace blink

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -126,6 +126,8 @@ const char* TaskTypeToString(TaskType task_type) {
       return "UserInteraction";
     case TaskType::kNetworking:
       return "Networking";
+    case TaskType::kNetworkingWithURLLoaderAnnotation:
+      return "NetworkingWithURLLoaderAnnotation";
     case TaskType::kNetworkingControl:
       return "NetworkingControl";
     case TaskType::kHistoryTraversal:
@@ -659,6 +661,9 @@ MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {
   best_effort_ad_frame =
       base::FeatureList::IsEnabled(kBestEffortPriorityForAdFrame);
 
+  use_resource_fetch_priority =
+      base::FeatureList::IsEnabled(kUseResourceFetchPriority);
+
   experiment_only_when_loading =
       base::FeatureList::IsEnabled(kExperimentOnlyWhenLoading);
 }

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -94,16 +94,20 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
     bool low_priority_background_page;
     bool best_effort_background_page;
 
-    // Task and subframe priority experiment (crbug.com/852380)
+    // Task and subframe priority experiment (crbug.com/852380).
     bool low_priority_subframe;
     bool low_priority_throttleable;
     bool low_priority_subframe_throttleable;
     bool low_priority_hidden_frame;
 
-    // Ads priority experiment (crbug.com/856150)
+    // Ads priority experiment (crbug.com/856150).
     bool low_priority_ad_frame;
     bool best_effort_ad_frame;
 
+    // Use resource fetch priority for resource loading tasks
+    // (crbug.com/860545).
+    bool use_resource_fetch_priority;
+
     // Turn on relevant experiments during the loading phase.
     bool experiment_only_when_loading;
   };

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.cc

@@ -544,7 +544,6 @@ void PageSchedulerImpl::UpdateBackgroundBudgetPoolSchedulingLifecycleState() {
 void PageSchedulerImpl::NotifyFrames() {
   for (FrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
     frame_scheduler->UpdatePolicy();
-    frame_scheduler->UpdateQueuePriorities();
   }
 }
 

third_party/blink/renderer/platform/scheduler/main_thread/resource_loading_task_runner_handle_impl.cc

+#include "third_party/blink/renderer/platform/scheduler/main_thread/resource_loading_task_runner_handle_impl.h"
+
+#include <iostream>
+
+#include "base/memory/ptr_util.h"
+#include "base/task/sequence_manager/task_queue.h"
+#include "third_party/blink/public/platform/task_type.h"
+#include "third_party/blink/renderer/platform/scheduler/child/task_queue_with_task_type.h"
+#include "third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.h"
+
+namespace blink {
+namespace scheduler {
+
+using base::sequence_manager::TaskQueue;
+
+namespace {
+
+TaskQueue::QueuePriority NetPriorityToBlinkSchedulerPriority(
+    const net::RequestPriority priority) {
+  switch (priority) {
+    case net::RequestPriority::HIGHEST:
+      return TaskQueue::QueuePriority::kHighPriority;
+    case net::RequestPriority::MEDIUM:
+    case net::RequestPriority::LOW:
+      return TaskQueue::QueuePriority::kNormalPriority;
+    case net::RequestPriority::LOWEST:
+    case net::RequestPriority::IDLE:
+    case net::RequestPriority::THROTTLED:
+    default:
+      return TaskQueue::QueuePriority::kLowPriority;
+  }
+}
+
+}  // namespace
+
+std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl>
+ResourceLoadingTaskRunnerHandleImpl::WrapTaskRunner(
+    scoped_refptr<MainThreadTaskQueue> task_queue) {
+  DCHECK(task_queue);
+  return base::WrapUnique(
+      new ResourceLoadingTaskRunnerHandleImpl(std::move(task_queue)));
+}
+
+ResourceLoadingTaskRunnerHandleImpl::ResourceLoadingTaskRunnerHandleImpl(
+    scoped_refptr<MainThreadTaskQueue> task_queue)
+    : task_queue_(std::move(task_queue)),
+      task_runner_(TaskQueueWithTaskType::Create(
+          task_queue_,
+          TaskType::kNetworkingWithURLLoaderAnnotation)){};
+
+ResourceLoadingTaskRunnerHandleImpl::~ResourceLoadingTaskRunnerHandleImpl() {
+  if (task_queue_->GetFrameScheduler()) {
+    task_queue_->GetFrameScheduler()->OnShutdownResourceLoadingTaskQueue(
+        task_queue_);
+  }
+}
+
+void ResourceLoadingTaskRunnerHandleImpl::DidChangeRequestPriority(
+    net::RequestPriority priority) {
+  FrameSchedulerImpl* frame_scheduler = task_queue_->GetFrameScheduler();
+  if (frame_scheduler) {
+    frame_scheduler->DidChangeResourceLoadingPriority(
+        task_queue_, NetPriorityToBlinkSchedulerPriority(priority));
+  }
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+ResourceLoadingTaskRunnerHandleImpl::GetTaskRunner() const {
+  return task_runner_;
+}
+
+const scoped_refptr<MainThreadTaskQueue>&
+ResourceLoadingTaskRunnerHandleImpl::task_queue() {
+  return task_queue_;
+}
+
+}  // namespace scheduler
+}  // namespace blink

third_party/blink/renderer/platform/scheduler/main_thread/resource_loading_task_runner_handle_impl.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_RESOURCE_LOADING_TASK_RUNNER_HANDLE_IMPL_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_RESOURCE_LOADING_TASK_RUNNER_HANDLE_IMPL_H_
+
+#include <memory>
+
+#include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+#include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h"
+
+namespace blink {
+namespace scheduler {
+
+// Provides an interface to the loading stack (i.e. WebURLLoader) to post
+// resource loading tasks and to notify blink's scheduler when a resource's
+// fetch priority changes.
+class PLATFORM_EXPORT ResourceLoadingTaskRunnerHandleImpl
+    : public WebResourceLoadingTaskRunnerHandle {
+ public:
+  static std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl> WrapTaskRunner(
+      scoped_refptr<MainThreadTaskQueue> task_runner);
+
+  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override;
+
+  void DidChangeRequestPriority(net::RequestPriority priority) override;
+
+  const scoped_refptr<MainThreadTaskQueue>& task_queue();
+
+  ~ResourceLoadingTaskRunnerHandleImpl() override;
+
+ protected:
+  explicit ResourceLoadingTaskRunnerHandleImpl(
+      scoped_refptr<MainThreadTaskQueue> task_queue);
+
+ private:
+  scoped_refptr<MainThreadTaskQueue> task_queue_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceLoadingTaskRunnerHandleImpl);
+};
+
+}  // namespace scheduler
+}  // namespace blink
+
+#endif

third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h

@@ -10,6 +10,7 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/single_thread_task_runner.h"
 #include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom-blink.h"
+#include "third_party/blink/public/platform/scheduler/web_resource_loading_task_runner_handle.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/public/platform/web_scoped_virtual_time_pauser.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
@@ -91,6 +92,13 @@ class FrameScheduler : public FrameOrWorkerScheduler {
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner(
       TaskType) = 0;
 
+  // Returns a WebResourceLoadingTaskRunnerHandle which is intended to be used
+  // by the loading stack to post resource loading tasks to the renderer's main
+  // thread and to notify the main thread of any change in the resource's fetch
+  // (net) priority.
+  virtual std::unique_ptr<scheduler::WebResourceLoadingTaskRunnerHandle>
+  CreateResourceLoadingTaskRunnerHandle() = 0;
+
   // Returns the parent PageScheduler.
   virtual PageScheduler* GetPageScheduler() const = 0;
 

third_party/blink/renderer/platform/scheduler/worker/worker_scheduler.cc

@@ -97,6 +97,7 @@ scoped_refptr<base::SingleThreadTaskRunner> WorkerScheduler::GetTaskRunner(
     case TaskType::kDOMManipulation:
     case TaskType::kUserInteraction:
     case TaskType::kNetworking:
+    case TaskType::kNetworkingWithURLLoaderAnnotation:
     case TaskType::kNetworkingControl:
     case TaskType::kHistoryTraversal:
     case TaskType::kEmbed: