[scheduler] Add resource loading queues to FrameTaskQueueController

This CL adds another queue type (resource loading) that
FrameTaskQueueController will be responsible for controlling.
FrameTaskQueueController provides methods for creating these queues and
accessing the related voters.

Bug: 859963
Change-Id: I61b10986a68f87b1c4428b1b3926ecd821ee36fa
Reviewed-on: https://chromium-review.googlesource.com/1137099
Commit-Queue: Scott Haseley <shaseley@google.com>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#576090}

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

@@ -71,6 +71,16 @@ FrameTaskQueueController::NewLoadingControlTaskQueue() {
   return loading_control_task_queue_;
 }
 
+scoped_refptr<MainThreadTaskQueue>
+FrameTaskQueueController::NewResourceLoadingTaskQueue() {
+  scoped_refptr<MainThreadTaskQueue> task_queue =
+      main_thread_scheduler_impl_->NewLoadingTaskQueue(
+          MainThreadTaskQueue::QueueType::kFrameLoading, frame_scheduler_impl_);
+  TaskQueueCreated(task_queue);
+  resource_loading_task_queues_.insert(task_queue);
+  return task_queue;
+}
+
 scoped_refptr<MainThreadTaskQueue>
 FrameTaskQueueController::NewNonLoadingTaskQueue(QueueTraits queue_traits) {
   DCHECK(!GetNonLoadingTaskQueue(queue_traits));
@@ -120,6 +130,29 @@ FrameTaskQueueController::GetQueueEnabledVoter(
   return it->value.get();
 }
 
+bool FrameTaskQueueController::RemoveResourceLoadingTaskQueue(
+    const scoped_refptr<MainThreadTaskQueue>& task_queue) {
+  DCHECK(task_queue);
+
+  if (!resource_loading_task_queues_.Contains(task_queue))
+    return false;
+  resource_loading_task_queues_.erase(task_queue);
+  DCHECK(task_queue_enabled_voters_.Contains(task_queue));
+  task_queue_enabled_voters_.erase(task_queue);
+
+  bool found_task_queue = false;
+  for (auto it = all_task_queues_and_voters_.begin();
+       it != all_task_queues_and_voters_.end(); ++it) {
+    if (it->first == task_queue.get()) {
+      found_task_queue = true;
+      all_task_queues_and_voters_.erase(it);
+      break;
+    }
+  }
+  DCHECK(found_task_queue);
+  return true;
+}
+
 // static
 MainThreadTaskQueue::QueueType
 FrameTaskQueueController::QueueTypeFromQueueTraits(QueueTraits queue_traits) {

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

@@ -15,6 +15,7 @@
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h"
 #include "third_party/blink/renderer/platform/wtf/hash_map.h"
+#include "third_party/blink/renderer/platform/wtf/hash_set.h"
 
 namespace base {
 namespace sequence_manager {
@@ -68,6 +69,17 @@ class PLATFORM_EXPORT FrameTaskQueueController {
   base::sequence_manager::TaskQueue::QueueEnabledVoter* GetQueueEnabledVoter(
       const scoped_refptr<MainThreadTaskQueue>&);
 
+  scoped_refptr<MainThreadTaskQueue> NewResourceLoadingTaskQueue();
+
+  // Remove a resource loading task queue that FrameTaskQueueController created,
+  // along with its QueueEnabledVoter, if one exists. Returns true if the task
+  // queue was found and erased and false otherwise.
+  //
+  // Removes are linear in the total number of task queues since
+  // |all_task_queues_and_voters_| needs to be updated.
+  bool RemoveResourceLoadingTaskQueue(
+      const scoped_refptr<MainThreadTaskQueue>&);
+
  private:
   friend class FrameTaskQueueControllerTest;
 
@@ -107,6 +119,10 @@ class PLATFORM_EXPORT FrameTaskQueueController {
   // Map of all non-loading TaskQueues, indexed by QueueTraits.
   NonLoadingTaskQueueMap non_loading_task_queues_;
 
+  // Set of all resource loading task queues.
+  WTF::HashSet<scoped_refptr<MainThreadTaskQueue>>
+      resource_loading_task_queues_;
+
   using TaskQueueEnabledVoterMap = WTF::HashMap<
       scoped_refptr<MainThreadTaskQueue>,
       std::unique_ptr<base::sequence_manager::TaskQueue::QueueEnabledVoter>>;

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

@@ -82,6 +82,10 @@ class FrameTaskQueueControllerTest : public testing::Test,
     return frame_task_queue_controller_->NewNonLoadingTaskQueue(queue_traits);
   }
 
+  scoped_refptr<MainThreadTaskQueue> NewResourceLoadingTaskQueue() const {
+    return frame_task_queue_controller_->NewResourceLoadingTaskQueue();
+  }
+
   size_t task_queue_created_count() const { return task_queue_created_count_; }
 
  protected:
@@ -139,6 +143,17 @@ TEST_F(FrameTaskQueueControllerTest, CreateAllTaskQueues) {
   all_task_queues.insert(task_queue.get(), QueueCheckResult::kDidNotSeeQueue);
   EXPECT_EQ(all_task_queues.size(), task_queue_created_count());
 
+  // Add a couple resource loading task queues.
+  task_queue = NewResourceLoadingTaskQueue();
+  EXPECT_FALSE(all_task_queues.Contains(task_queue));
+  all_task_queues.insert(task_queue.get(), QueueCheckResult::kDidNotSeeQueue);
+  EXPECT_EQ(all_task_queues.size(), task_queue_created_count());
+
+  task_queue = NewResourceLoadingTaskQueue();
+  EXPECT_FALSE(all_task_queues.Contains(task_queue));
+  all_task_queues.insert(task_queue.get(), QueueCheckResult::kDidNotSeeQueue);
+  EXPECT_EQ(all_task_queues.size(), task_queue_created_count());
+
   // Verify that we get all of the queues that we added, and only those queues.
   EXPECT_EQ(all_task_queues.size(),
             frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
@@ -168,5 +183,53 @@ TEST_F(FrameTaskQueueControllerTest, CreateAllTaskQueues) {
   }
 }
 
+TEST_F(FrameTaskQueueControllerTest, RemoveResourceLoadingTaskQueues) {
+  scoped_refptr<MainThreadTaskQueue> resource_loading_queue1 =
+      NewResourceLoadingTaskQueue();
+  EXPECT_EQ(1u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+  scoped_refptr<MainThreadTaskQueue> resource_loading_queue2 =
+      NewResourceLoadingTaskQueue();
+  EXPECT_EQ(2u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+
+  // Check that we can remove the resource loading queues.
+  bool was_removed =
+      frame_task_queue_controller_->RemoveResourceLoadingTaskQueue(
+          resource_loading_queue1);
+  EXPECT_TRUE(was_removed);
+  EXPECT_EQ(1u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+  // Can't delete twice.
+  was_removed = frame_task_queue_controller_->RemoveResourceLoadingTaskQueue(
+      resource_loading_queue1);
+  EXPECT_FALSE(was_removed);
+  EXPECT_EQ(1u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+
+  was_removed = frame_task_queue_controller_->RemoveResourceLoadingTaskQueue(
+      resource_loading_queue2);
+  EXPECT_TRUE(was_removed);
+  EXPECT_EQ(0u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+  // Can't delete twice.
+  was_removed = frame_task_queue_controller_->RemoveResourceLoadingTaskQueue(
+      resource_loading_queue2);
+  EXPECT_FALSE(was_removed);
+  EXPECT_EQ(0u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+}
+
+TEST_F(FrameTaskQueueControllerTest, CannotRemoveNonResourceLoadingTaskQueues) {
+  scoped_refptr<MainThreadTaskQueue> task_queue = NewLoadingTaskQueue();
+  EXPECT_EQ(1u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+  bool was_removed =
+      frame_task_queue_controller_->RemoveResourceLoadingTaskQueue(task_queue);
+  EXPECT_FALSE(was_removed);
+  EXPECT_EQ(1u,
+            frame_task_queue_controller_->GetAllTaskQueuesAndVoters().size());
+}
+
 }  // namespace scheduler
 }  // namespace blink