Use constexpr TaskTraits constructor in extensions.

extensions/browser/extension_protocols.cc

 // Copyright 2014 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 "extensions/browser/extension_protocols.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 163 matching lines @@
                          const base::FilePath& relative_path,
                          const std::string& content_security_policy,
                          bool send_cors_header,
                          bool follow_symlinks_anywhere,
                          ContentVerifyJob* verify_job)
       : net::URLRequestFileJob(
             request,
             network_delegate,
             base::FilePath(),
             base::CreateTaskRunnerWithTraits(
-                base::TaskTraits()
-                    .MayBlock()
-                    .WithPriority(base::TaskPriority::BACKGROUND)
-                    .WithShutdownBehavior(
-                        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN))),
+                {base::MayBlock(), base::TaskPriority::BACKGROUND,
+                 base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
         verify_job_(verify_job),
         seek_position_(0),
         bytes_read_(0),
         directory_path_(directory_path),
         // TODO(tc): Move all of these files into resources.pak so we don't
         // break when updating on Linux.
         resource_(extension_id, directory_path, relative_path),
         content_security_policy_(content_security_policy),
         send_cors_header_(send_cors_header),
         weak_factory_(this) {
     if (follow_symlinks_anywhere) {
       resource_.set_follow_symlinks_anywhere();
     }
   }
 
   void GetResponseInfo(net::HttpResponseInfo* info) override {
     *info = response_info_;
   }
 
   void Start() override {
     request_timer_.reset(new base::ElapsedTimer());
     base::FilePath* read_file_path = new base::FilePath;
     base::Time* last_modified_time = new base::Time();
 
     // Inherit task priority from the calling context.
     base::PostTaskWithTraitsAndReply(
-        FROM_HERE, base::TaskTraits().MayBlock(),
+        FROM_HERE, {base::MayBlock()},
         base::Bind(&ReadResourceFilePathAndLastModifiedTime, resource_,
                    directory_path_, base::Unretained(read_file_path),
                    base::Unretained(last_modified_time)),
         base::Bind(&URLRequestExtensionJob::OnFilePathAndLastModifiedTimeRead,
                    weak_factory_.GetWeakPtr(), base::Owned(read_file_path),
                    base::Owned(last_modified_time)));
   }
 
   bool IsRedirectResponse(GURL* location, int* http_status_code) override {
     return false;
@@ skipping 387 matching lines @@
                                extensions::InfoMap* extension_info_map) {
   return base::MakeUnique<ExtensionProtocolHandler>(is_incognito,
                                                     extension_info_map);
 }
 
 void SetExtensionProtocolTestHandler(ExtensionProtocolTestHandler* handler) {
   g_test_handler = handler;
 }
 
 }  // namespace extensions