Use constexpr TaskTraits constructor in content.

content/browser/browser_main_loop.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 "content/browser/browser_main_loop.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 991 matching lines @@
     // thread will not be joined on shutdown, and may cause use-after-free if
     // anything tries to access objects deleted by AtExitManager, such as
     // non-leaky LazyInstance.
     base::MessageLoop* message_loop = nullptr;
     bool redirect_thread = redirect_nonUInonIO_browser_threads;
 
     // Otherwise this thread ID will be backed by a SingleThreadTaskRunner using
     // |non_ui_non_io_task_runner_traits| (which can be augmented below).
     // TODO(gab): Existing non-UI/non-IO BrowserThreads allow sync primitives so
     // the initial redirection will as well but they probably don't need to.
-    base::TaskTraits non_ui_non_io_task_runner_traits =
-        base::TaskTraits().MayBlock().WithBaseSyncPrimitives();
+    base::TaskTraits non_ui_non_io_task_runner_traits;
+
+    constexpr base::TaskTraits kUserVisibleTraits = {

[gab, 2017/05/04 14:09:02]

// Note: if you're copying these TaskTraits elsewhere, you most likely don't
need and shouldn't use base::WithBaseSyncPrimitives() -- see its documentation.

[fdoray, 2017/05/04 18:50:39]

Done.

+        base::MayBlock(), base::WithBaseSyncPrimitives(),
+        base::TaskPriority::USER_VISIBLE,
+        base::TaskShutdownBehavior::BLOCK_SHUTDOWN};
+    constexpr base::TaskTraits kUserBlockingTraits = {
+        base::MayBlock(), base::WithBaseSyncPrimitives(),
+        base::TaskPriority::USER_BLOCKING,
+        base::TaskShutdownBehavior::BLOCK_SHUTDOWN};
 
     switch (thread_id) {
       case BrowserThread::DB:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::DB");
         if (redirect_thread) {
-          non_ui_non_io_task_runner_traits
-              .WithPriority(base::TaskPriority::USER_VISIBLE)
-              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+          non_ui_non_io_task_runner_traits = kUserVisibleTraits;
         } else {
           thread_to_start = &db_thread_;
           options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         }
         break;
       case BrowserThread::FILE_USER_BLOCKING:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::FILE_USER_BLOCKING");
         if (redirect_thread) {
-          non_ui_non_io_task_runner_traits
-              .WithPriority(base::TaskPriority::USER_BLOCKING)
-              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+          non_ui_non_io_task_runner_traits = kUserBlockingTraits;
         } else {
           thread_to_start = &file_user_blocking_thread_;
         }
         break;
       case BrowserThread::FILE:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::FILE");
 
 #if defined(OS_WIN)
         // On Windows, the FILE thread needs to have a UI message loop which
         // pumps messages in such a way that Google Update can communicate back
         // to us.
         // TODO(robliao): Need to support COM in TaskScheduler before
         // redirecting the FILE thread on Windows. http://crbug.com/662122
         thread_to_start = &file_thread_;
         options = ui_message_loop_options;
         options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 #else
         if (redirect_thread) {
-          non_ui_non_io_task_runner_traits
-              .WithPriority(base::TaskPriority::USER_VISIBLE)
-              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+          non_ui_non_io_task_runner_traits = kUserVisibleTraits;
         } else {
           thread_to_start = &file_thread_;
           options = io_message_loop_options;
           options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         }
 #endif
         break;
       case BrowserThread::PROCESS_LAUNCHER:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::PROCESS_LAUNCHER");
 #if defined(OS_ANDROID)
         // Android specializes Launcher thread so it is accessible in java.
         // Note Android never does clean shutdown, so shutdown use-after-free
         // concerns are not a problem in practice.
         redirect_thread = false;
         message_loop = android::LauncherThread::GetMessageLoop();
         DCHECK(message_loop);
 #endif
         if (redirect_thread) {
-          non_ui_non_io_task_runner_traits
-              .WithPriority(base::TaskPriority::USER_BLOCKING)
-              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+          non_ui_non_io_task_runner_traits = kUserBlockingTraits;
         } else {
           thread_to_start = &process_launcher_thread_;
           options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         }
         break;
       case BrowserThread::CACHE:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::CACHE");
 #if defined(OS_WIN)
         // TaskScheduler doesn't support async I/O on Windows as CACHE thread is
         // the only user and this use case is going away in
         // https://codereview.chromium.org/2216583003/.
         // TODO(gavinp): Remove this ifdef (and thus enable redirection of the
         // CACHE thread on Windows) once that CL lands.
         thread_to_start = &cache_thread_;
         options = io_message_loop_options;
         options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 #else  // OS_WIN
         if (redirect_thread) {
-          non_ui_non_io_task_runner_traits
-              .WithPriority(base::TaskPriority::USER_BLOCKING)
-              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+          non_ui_non_io_task_runner_traits = kUserBlockingTraits;
         } else {
           thread_to_start = &cache_thread_;
           options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         }
 #endif  // OS_WIN
         break;
       case BrowserThread::IO:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::IO");
@@ skipping 652 matching lines @@
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE),
         MediaInternals::GetInstance());
   }
   CHECK(audio_manager_);
 
   audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get());
   CHECK(audio_system_);
 }
 
 }  // namespace content