Disallow posting tasks to SequencedWorkerPools by default.

chrome/browser/chrome_browser_main.cc

 // Copyright (c) 2012 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 "chrome/browser/chrome_browser_main.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 296 matching lines @@
 void AddFirstRunNewTabs(StartupBrowserCreator* browser_creator,
                         const std::vector<GURL>& new_tabs) {
   for (std::vector<GURL>::const_iterator it = new_tabs.begin();
        it != new_tabs.end(); ++it) {
     if (it->is_valid())
       browser_creator->AddFirstRunTab(*it);
   }
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 
-void MaybeInitializeTaskScheduler() {
+// Initializes TaskScheduler if enabled via field trial or command line flag.
+// The function returns true if it enables redirection of SequencedWorkerPool to
+// TaskScheduler.
+bool MaybeInitializeTaskScheduler() {
+  bool sequenced_worker_pool_redirected = false;
+
   static constexpr char kFieldTrialName[] = "BrowserScheduler";
   std::map<std::string, std::string> variation_params;
   if (!variations::GetVariationParams(kFieldTrialName, &variation_params)) {
     DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableBrowserTaskScheduler))
         << "The Browser Task Scheduler remains disabled with "
         << switches::kEnableBrowserTaskScheduler
         << " because there is no available variation param for this build or "
            " the task scheduler is disabled in chrome://flags.";
-    return;
+    return sequenced_worker_pool_redirected;

[gab, 2016/11/02 13:29:55]

No var, just return false on each failure and return true if reaching the end of
the method.

[fdoray, 2016/11/02 20:02:16]

We may reach the end of the method without having enabled redirection of
SequencedWorkerPool to TaskScheduler.

I don't want to "return true;" right after line 344 either because this early
termination would prevent us from adding new code at the end of this function
(e.g. I have a pending CL which enables redirection of HistoryService to
TaskScheduler at the end of this function). 

Returning false instead of |sequenced_worker_pool_redirected| above would work
but IMO would be less clear.

   }
 
   if (!task_scheduler_util::InitializeDefaultTaskScheduler(variation_params))
-    return;
+    return sequenced_worker_pool_redirected;
 
   // TODO(gab): Remove this when http://crbug.com/622400 concludes.
   const auto sequenced_worker_pool_param =
       variation_params.find("RedirectSequencedWorkerPools");
   if (sequenced_worker_pool_param != variation_params.end() &&
       sequenced_worker_pool_param->second == "true") {
-    base::SequencedWorkerPool::RedirectToTaskSchedulerForProcess();
+    sequenced_worker_pool_redirected = true;
+    base::SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess();
   }
+
+  return sequenced_worker_pool_redirected;
 }
 
 // Returns the new local state object, guaranteed non-NULL.
 // |local_state_task_runner| must be a shutdown-blocking task runner.
 PrefService* InitializeLocalState(
     base::SequencedTaskRunner* local_state_task_runner,
     const base::CommandLine& parsed_command_line) {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::InitializeLocalState")
 
   // Load local state.  This includes the application locale so we know which
@@ skipping 872 matching lines @@
   // Do not add anything below this line until you've verified your new code
   // does not interfere with the critical initialization order below. Some of
   // the calls below end up implicitly creating threads and as such new calls
   // typically either belong before them or in a later startup phase.
 
   // Now that the command line has been mutated based on about:flags, we can
   // initialize field trials and setup metrics. The field trials are needed by
   // IOThread's initialization which happens in BrowserProcess:PreCreateThreads.
   SetupFieldTrials();
 
-  // Task Scheduler initialization needs to be here for the following reasons:
+  // Initializing TaskScheduler and enabling SequencedWorkerPool needs to be
+  // here for the following reasons:
   //   * After |SetupFieldTrials()|: Initialization uses variations.
   //   * Before |SetupMetrics()|: |SetupMetrics()| uses the blocking pool. The
   //         Task Scheduler must do any necessary redirection before then.
   //   * Near the end of |PreCreateThreads()|: The TaskScheduler needs to be
   //         created before any other threads are (by contract) but it creates
   //         threads itself so instantiating it earlier is also incorrect.
   // To maintain scoping symmetry, if this line is moved, the corresponding
   // shutdown call may also need to be moved.
-  MaybeInitializeTaskScheduler();
+  const bool sequenced_worker_pool_redirected = MaybeInitializeTaskScheduler();
+
+  // If MaybeInitializeTaskScheduler() hasn't enabled SequencedWorkerPool with
+  // redirection to TaskScheduler, enable it without redirection.
+  // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
+  // redirection experiment concludes https://crbug.com/622400.
+  if (!sequenced_worker_pool_redirected)
+    base::SequencedWorkerPool::EnableForProcess();
 
   SetupMetrics();
 
   // ChromeOS needs ResourceBundle::InitSharedInstance to be called before this.
   // This also instantiates the IOThread which requests the metrics service and
   // must be after |SetupMetrics()|.
   browser_process_->PreCreateThreads();
 
   return content::RESULT_CODE_NORMAL_EXIT;
 }
@@ skipping 859 matching lines @@
   chromeos::CrosSettings::Shutdown();
 #endif  // defined(OS_CHROMEOS)
 #endif  // defined(OS_ANDROID)
 }
 
 // Public members:
 
 void ChromeBrowserMainParts::AddParts(ChromeBrowserMainExtraParts* parts) {
   chrome_extra_parts_.push_back(parts);
 }