Add Thread Standby Policy SchedulerWorkerPoolImpl

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 <algorithm>
 #include <vector>
 
 #include "base/bind.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/sys_info.h"
 #include "base/task_scheduler/scheduler_worker_pool_params.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/time/time.h"
 
 namespace task_scheduler_util {
 
 namespace {
 
+using StandbyThreadPolicy =
+    base::SchedulerWorkerPoolParams::StandbyThreadPolicy;
+
 enum WorkerPoolType : size_t {
   BACKGROUND_WORKER_POOL = 0,
   BACKGROUND_FILE_IO_WORKER_POOL,
   FOREGROUND_WORKER_POOL,
   FOREGROUND_FILE_IO_WORKER_POOL,
   WORKER_POOL_COUNT  // Always last.
 };
 
 struct WorkerPoolVariationValues {
+  StandbyThreadPolicy standby_thread_policy;
   int threads = 0;
   base::TimeDelta detach_period;
 };
 
 // Converts |pool_descriptor| to a WorkerPoolVariationValues. Returns a default
 // WorkerPoolVariationValues on failure.
 //
 // |pool_descriptor| is a semi-colon separated value string with the following
 // items:
 // 1. Minimum Thread Count (int)
@@ skipping 19 matching lines @@
       base::StringToInt(tokens[1], &maximum) &&
       base::StringToDouble(tokens[2], &multiplier) &&
       base::StringToInt(tokens[3], &offset) &&
       base::StringToInt(tokens[4], &detach_milliseconds)) {
     const int num_of_cores = base::SysInfo::NumberOfProcessors();
     const int threads = std::ceil<int>(num_of_cores * multiplier) + offset;
     WorkerPoolVariationValues values;
     values.threads = std::min(maximum, std::max(minimum, threads));
     values.detach_period =
         base::TimeDelta::FromMilliseconds(detach_milliseconds);
+    values.standby_thread_policy = StandbyThreadPolicy::ONE;

[fdoray, 2016/11/15 15:27:02]

values.standby_thread_policy = 
    (tokens.size() >= 6 && tokens[5] == "lazy")
        ? StandbyThreadPolicy::LAZY
        : StandbyThreadPolicy::ONE;

[robliao, 2016/11/15 15:57:19]

Done.

+    if (tokens.size() >= 6) {
+      values.standby_thread_policy =
+          tokens[5] == "lazy"
+              ? StandbyThreadPolicy::LAZY
+              : StandbyThreadPolicy::ONE;
+    }
     return values;
   }
   DLOG(ERROR) << "Invalid Worker Pool Descriptor: " << pool_descriptor;
   return WorkerPoolVariationValues();
 }
 
 // Returns the worker pool index for |traits| defaulting to
 // FOREGROUND_WORKER_POOL or FOREGROUND_FILE_IO_WORKER_POOL on unknown
 // priorities.
 size_t WorkerPoolIndexForTraits(const base::TaskTraits& traits) {
@@ skipping 41 matching lines @@
     if (variation_values.threads <= 0 ||
         variation_values.detach_period.is_zero()) {
       DLOG(ERROR) << "Invalid Worker Pool Configuration: " <<
           predefined_params.name << " [" << pair->second << "]";
       return false;
     }
 
     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());
 
   base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
       params_vector, base::Bind(WorkerPoolIndexForTraits));
 
   return true;
 }
 
 }  // namespace task_scheduler_util