TaskScheduler: Set the IO allowed bit in TaskTracker::RunTask().

components/task_scheduler_util/initialization_util.cc

 // Copyright 2016 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 "components/task_scheduler_util/initialization_util.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 106 matching lines @@
   return variation_params;
 }
 
 // Converts a browser-based |variation_params| to
 // std::vector<base::SchedulerWorkerPoolParams>. Returns an empty vector on
 // failure.
 std::vector<base::SchedulerWorkerPoolParams>
 VariationsParamsToBrowserSchedulerWorkerPoolParams(
     const std::map<std::string, std::string>& variation_params) {
   using ThreadPriority = base::ThreadPriority;
-  using IORestriction = base::SchedulerWorkerPoolParams::IORestriction;
   struct SchedulerWorkerPoolPredefinedParams {
     const char* name;
     ThreadPriority priority_hint;
-    IORestriction io_restriction;
   };
   static const SchedulerWorkerPoolPredefinedParams kAllPredefinedParams[] = {
-    {"Background", ThreadPriority::BACKGROUND, IORestriction::DISALLOWED},
-    {"BackgroundFileIO", ThreadPriority::BACKGROUND, IORestriction::ALLOWED},
-    {"Foreground", ThreadPriority::NORMAL, IORestriction::DISALLOWED},
-    {"ForegroundFileIO", ThreadPriority::NORMAL, IORestriction::ALLOWED},
+      {"Background", ThreadPriority::BACKGROUND},
+      {"BackgroundFileIO", ThreadPriority::BACKGROUND},
+      {"Foreground", ThreadPriority::NORMAL},
+      {"ForegroundFileIO", ThreadPriority::NORMAL},
   };
   static_assert(arraysize(kAllPredefinedParams) == WORKER_POOL_COUNT,
                 "Mismatched Worker Pool Types and Predefined Parameters");
   std::vector<base::SchedulerWorkerPoolParams> params_vector;
   for (const auto& predefined_params : kAllPredefinedParams) {
     const auto pair = variation_params.find(predefined_params.name);
     if (pair == variation_params.end()) {
       DLOG(ERROR) << "Missing Worker Pool Configuration: "
                   << predefined_params.name;
       return std::vector<base::SchedulerWorkerPoolParams>();
     }
 
     const WorkerPoolVariationValues variation_values =
         StringToWorkerPoolVariationValues(pair->second);
 
     if (variation_values.threads <= 0 ||
         variation_values.detach_period.is_zero()) {
       DLOG(ERROR) << "Invalid Worker Pool Configuration: " <<
           predefined_params.name << " [" << pair->second << "]";
       return std::vector<base::SchedulerWorkerPoolParams>();
     }
 
     params_vector.emplace_back(predefined_params.name,
                                predefined_params.priority_hint,
-                               predefined_params.io_restriction,
                                variation_values.standby_thread_policy,
                                variation_values.threads,
                                variation_values.detach_period);
   }
   DCHECK_EQ(WORKER_POOL_COUNT, params_vector.size());
   return params_vector;
 }
 
 }  // namespace
 
@@ skipping 21 matching lines @@
           switches::kDisableBrowserTaskScheduler) &&
       sequenced_worker_pool_param != variation_params.end() &&
       sequenced_worker_pool_param->second == "true") {
     base::SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess();
   } else {
     base::SequencedWorkerPool::EnableForProcess();
   }
 }
 
 }  // namespace task_scheduler_util