[reference - do not submit] Always create four pools in TaskSchedulerImpl.

components/task_scheduler_util/common/variations_util.cc

Index: components/task_scheduler_util/common/variations_util.cc
diff --git a/components/task_scheduler_util/common/variations_util.cc b/components/task_scheduler_util/common/variations_util.cc
index bdca8c8f961f025eac9e127ec26046f29f324424..562ad9e0e396a7dfd60635c7570ee244672017ee 100644
--- a/components/task_scheduler_util/common/variations_util.cc
+++ b/components/task_scheduler_util/common/variations_util.cc
@@ -7,7 +7,6 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task_scheduler/initialization_util.h"
@@ -18,12 +17,6 @@ namespace task_scheduler_util {
 
 namespace {
 
-struct SchedulerCustomizableWorkerPoolParams {
-  base::SchedulerWorkerPoolParams::StandbyThreadPolicy standby_thread_policy;
-  int max_threads = 0;
-  base::TimeDelta detach_period;
-};
-
 #if !defined(OS_IOS)
 constexpr char kTaskSchedulerVariationParamsSwitch[] =
     "task-scheduler-variation-params";
@@ -35,20 +28,11 @@ bool ContainsSeparator(const std::string& str) {
 }
 #endif  // !defined(OS_IOS)
 
-// Converts |pool_descriptor| to a SchedulerWorkerPoolVariableParams. Returns a
-// default SchedulerWorkerPoolVariableParams on failure.
-//
-// |pool_descriptor| is a semi-colon separated value string with the following
-// items:
-// 0. Minimum Thread Count (int)
-// 1. Maximum Thread Count (int)
-// 2. Thread Count Multiplier (double)
-// 3. Thread Count Offset (int)
-// 4. Detach Time in Milliseconds (int)
-// 5. Standby Thread Policy (string)
-// Additional values may appear as necessary and will be ignored.
-SchedulerCustomizableWorkerPoolParams StringToVariableWorkerPoolParams(
-    const base::StringPiece pool_descriptor) {
+}  // namespace
+
+base::SchedulerWorkerPoolParams StringToVariableWorkerPoolParams(
+    const base::StringPiece pool_descriptor,
+    base::SchedulerBackwardCompatibility backward_compatibility) {
   using StandbyThreadPolicy =
       base::SchedulerWorkerPoolParams::StandbyThreadPolicy;
   const std::vector<base::StringPiece> tokens = SplitStringPiece(
@@ -68,60 +52,16 @@ SchedulerCustomizableWorkerPoolParams StringToVariableWorkerPoolParams(
       base::StringToDouble(tokens[2].as_string(), &cores_multiplier) &&
       base::StringToInt(tokens[3], &offset) &&
       base::StringToInt(tokens[4], &detach_milliseconds)) {
-    SchedulerCustomizableWorkerPoolParams params;
-    params.max_threads = base::RecommendedMaxNumberOfThreadsInPool(
-        min, max, cores_multiplier, offset);
-    params.detach_period =
-        base::TimeDelta::FromMilliseconds(detach_milliseconds);
-    params.standby_thread_policy = (tokens.size() >= 6 && tokens[5] == "lazy")
-                                       ? StandbyThreadPolicy::LAZY
-                                       : StandbyThreadPolicy::ONE;
-    return params;
+    return base::SchedulerWorkerPoolParams(
+        (tokens.size() >= 6 && tokens[5] == "lazy") ? StandbyThreadPolicy::LAZY
+                                                    : StandbyThreadPolicy::ONE,
+        base::RecommendedMaxNumberOfThreadsInPool(min, max, cores_multiplier,
+                                                  offset),
+        base::TimeDelta::FromMilliseconds(detach_milliseconds),
+        backward_compatibility);
   }
   DLOG(ERROR) << "Invalid Worker Pool Descriptor: " << pool_descriptor;
-  return SchedulerCustomizableWorkerPoolParams();
-}
-
-}  // namespace
-
-SchedulerImmutableWorkerPoolParams::SchedulerImmutableWorkerPoolParams(
-    const char* name,
-    base::ThreadPriority priority_hint,
-    base::SchedulerBackwardCompatibility backward_compatibility)
-    : name_(name),
-      priority_hint_(priority_hint),
-      backward_compatibility_(backward_compatibility) {}
-
-std::vector<base::SchedulerWorkerPoolParams> GetWorkerPoolParams(
-    const std::vector<SchedulerImmutableWorkerPoolParams>&
-        constant_worker_pool_params_vector,
-    const std::map<std::string, std::string>& variation_params) {
-  std::vector<base::SchedulerWorkerPoolParams> worker_pool_params_vector;
-  for (const auto& constant_worker_pool_params :
-       constant_worker_pool_params_vector) {
-    const char* const worker_pool_name = constant_worker_pool_params.name();
-    auto it = variation_params.find(worker_pool_name);
-    if (it == variation_params.end()) {
-      // Non-branded builds don't have access to external worker pool
-      // configurations.
-      return std::vector<base::SchedulerWorkerPoolParams>();
-    }
-    const auto variable_worker_pool_params =
-        StringToVariableWorkerPoolParams(it->second);
-    if (variable_worker_pool_params.max_threads <= 0 ||
-        variable_worker_pool_params.detach_period <= base::TimeDelta()) {
-      DLOG(ERROR) << "Invalid Worker Pool Configuration: " << worker_pool_name
-                  << " [" << it->second << "]";
-      return std::vector<base::SchedulerWorkerPoolParams>();
-    }
-    worker_pool_params_vector.emplace_back(
-        worker_pool_name, constant_worker_pool_params.priority_hint(),
-        variable_worker_pool_params.standby_thread_policy,
-        variable_worker_pool_params.max_threads,
-        variable_worker_pool_params.detach_period,
-        constant_worker_pool_params.backward_compatibility());
-  }
-  return worker_pool_params_vector;
+  return base::SchedulerWorkerPoolParams();
 }
 
 #if !defined(OS_IOS)