Generate TaskScheduler::InitParams from components/task_scheduler_util/.

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 2b3a2194a6d40b0b5d576a2470bcf3348bd8f92f..5e027c94b0e46e453d8c489104efc407fb216205 100644
--- a/components/task_scheduler_util/common/variations_util.cc
+++ b/components/task_scheduler_util/common/variations_util.cc
@@ -6,6 +6,7 @@
 
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ -17,12 +18,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";
@@ -34,20 +29,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
+
+std::unique_ptr<base::SchedulerWorkerPoolParams> StringToWorkerPoolParams(
+    const base::StringPiece pool_descriptor,
+    base::SchedulerBackwardCompatibility backward_compatibility) {
   using StandbyThreadPolicy =
       base::SchedulerWorkerPoolParams::StandbyThreadPolicy;
   const std::vector<base::StringPiece> tokens = SplitStringPiece(
@@ -62,65 +48,31 @@ SchedulerCustomizableWorkerPoolParams StringToVariableWorkerPoolParams(
   int detach_milliseconds = 0;
   // Checking for a size greater than the expected amount allows us to be
   // forward compatible if we add more variation values.
-  if (tokens.size() >= 5 && base::StringToInt(tokens[0], &min) &&
-      base::StringToInt(tokens[1], &max) &&
-      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;
+  if (tokens.size() < 5 || !base::StringToInt(tokens[0], &min) ||
+      !base::StringToInt(tokens[1], &max) ||
+      !base::StringToDouble(tokens[2].as_string(), &cores_multiplier) ||
+      !base::StringToInt(tokens[3], &offset) ||
+      !base::StringToInt(tokens[4], &detach_milliseconds)) {
+    DLOG(ERROR) << "Invalid Worker Pool Descriptor Format: " << pool_descriptor;
+    return nullptr;
   }
-  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());
+  auto params = base::MakeUnique<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);
+
+  if (params->max_threads() < 0 ||

[robliao, 2017/04/03 17:42:36]

Break this into the individual failure cases:

if (params->max_threads() < 0) {
  DLOG(ERROR) << "Invalid max threads in the Worker Pool Descriptor: "
              << params->max_threads();
}

if (params->suggested...) {
  DLOG(ERROR) << "Invalid suggested reclaim time in the Worker Pool Descriptor:
"
              << params->suggested_reclaim_time();
}

[fdoray, 2017/04/03 19:01:44]

Done.

+      params->suggested_reclaim_time() > base::TimeDelta()) {

[robliao, 2017/04/03 17:42:35]

Shouldn't this be
params->suggested_reclaim_time() < base::TimeDelta()?

[fdoray, 2017/04/03 19:01:44]

Done.

+    DLOG(ERROR) << "Invalid Values in Worker Pool Descriptor: "
+                << pool_descriptor;
+    return nullptr;
   }
-  return worker_pool_params_vector;
+
+  return params;
 }
 
 #if !defined(OS_IOS)