Add an experiment to redirect DOMStorageTaskRunner to TaskScheduler.

content/browser/dom_storage/dom_storage_context_wrapper.cc

 // Copyright 2013 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 "content/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/leveldb_wrapper_impl.h"
 #include "content/browser/memory/memory_coordinator.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_features.h"
 #include "mojo/common/common_type_converters.h"
 #include "services/file/public/interfaces/constants.mojom.h"
 #include "services/file/public/interfaces/file_system.mojom.h"
 #include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 namespace content {
 namespace {
 
@@ skipping 226 matching lines @@
     const base::FilePath& local_partition_path,
     storage::SpecialStoragePolicy* special_storage_policy) {
   base::FilePath storage_dir;
   if (!profile_path.empty())
     storage_dir = local_partition_path.AppendASCII(kLocalStorageDirectory);
   mojo_state_.reset(new MojoState(connector, storage_dir));
 
   base::FilePath data_path;
   if (!profile_path.empty())
     data_path = profile_path.Append(local_partition_path);
-  base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
+
+  scoped_refptr<base::SequencedTaskRunner> primary_sequence;
+  scoped_refptr<base::SequencedTaskRunner> commit_sequence;
+  if (GetContentClient()->browser()->ShouldRedirectDOMStorageTaskRunner()) {
+    // TaskPriority::USER_BLOCKING as an experiment because this is currently
+    // believed to be blocking synchronous IPCs from the renderers:
+    // http://crbug.com/665588 (yes we want to fix that bug, but are taking it
+    // as an opportunity to experiment with the scheduler).
+    base::TaskTraits dom_storage_traits =
+        base::TaskTraits()
+            .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN)
+            .WithFileIO()
+            .WithPriority(base::TaskPriority::USER_BLOCKING);
+    primary_sequence =
+        base::CreateSequencedTaskRunnerWithTraits(dom_storage_traits);
+    commit_sequence =
+        base::CreateSequencedTaskRunnerWithTraits(dom_storage_traits);
+  } else {
+    base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
+    primary_sequence = worker_pool->GetSequencedTaskRunner(
+        worker_pool->GetNamedSequenceToken("dom_storage_primary"));
+    commit_sequence = worker_pool->GetSequencedTaskRunner(
+        worker_pool->GetNamedSequenceToken("dom_storage_commit"));
+  }
+  DCHECK(primary_sequence);
+  DCHECK(commit_sequence);
+
   context_ = new DOMStorageContextImpl(
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kLocalStorageDirectory),
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kSessionStorageDirectory),
       special_storage_policy,
-      new DOMStorageWorkerPoolTaskRunner(
-          worker_pool,
-          worker_pool->GetNamedSequenceToken("dom_storage_primary"),
-          worker_pool->GetNamedSequenceToken("dom_storage_commit"),
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO).get()));
+      new DOMStorageWorkerPoolTaskRunner(std::move(primary_sequence),
+                                         std::move(commit_sequence)));
 
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {
     base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
   } else {
     memory_pressure_listener_.reset(new base::MemoryPressureListener(
         base::Bind(&DOMStorageContextWrapper::OnMemoryPressure, this)));
   }
 }
 
 DOMStorageContextWrapper::~DOMStorageContextWrapper() {}
@@ skipping 137 matching lines @@
 }
 
 void DOMStorageContextWrapper::PurgeMemory(DOMStorageContextImpl::PurgeOption
     purge_option) {
   context_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DOMStorageContextImpl::PurgeMemory, context_, purge_option));
 }
 
 }  // namespace content