Use TaskScheduler instead of WorkerPool in debug_daemon_client.cc.

chromeos/dbus/debug_daemon_client.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 "chromeos/dbus/debug_daemon_client.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <unistd.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_util.h"
-#include "base/task_runner_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/threading/worker_pool.h"
 #include "chromeos/dbus/pipe_reader.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 10 matching lines @@
     const scoped_refptr<base::RefCountedString>& unused_result) {}
 
 // A self-deleting object that wraps the pipe reader operations for reading the
 // big feedback logs. It will delete itself once the pipe stream has been
 // terminated. Once the data has been completely read from the pipe, it invokes
 // the GetLogsCallback |callback| passing the deserialized logs data back to
 // the requester.
 class PipeReaderWrapper : public base::SupportsWeakPtr<PipeReaderWrapper> {
  public:
   explicit PipeReaderWrapper(const DebugDaemonClient::GetLogsCallback& callback)
-      : task_runner_(
-            base::WorkerPool::GetTaskRunner(true /** tasks_are_slow */)),
-        pipe_reader_(task_runner_,
+      : pipe_reader_(base::CreateTaskRunnerWithTraits(
+                         base::TaskTraits().WithFileIO().WithShutdownBehavior(

[hashimoto, 2016/12/09 10:54:37]

This task runner is used not to read a file, but to read a pipe which may wait
for the debug daemon on the other end of the pipe.

Which suits better for this use case, WithFileIO or WithWait?

[fdoray, 2016/12/09 16:49:14]

The WithFileIO() trait is appropriate for tasks that wait on synchronous file
I/O (file = file on disk, pipe, network socket...). I will improve the comment
in task_traits.h in a separate CL.

[hashimoto, 2016/12/10 01:13:55]

Thanks, improved comments would be appreciated.

Even if read() is the syscall used to interact with the file descriptor, pipe IO
doesn't wait for the disk to complete IO, but waits for another process to feed
data.
So IMHO WithWait() suits slightly better in this case, but if WithFileIO is
preferred and it's going to be clearly written in task_traits.h, I'll be OK with
it.

+                             base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)),

[hashimoto, 2016/12/09 10:54:37]

PipeReader uses the task runner to provide it to net::FileStream.
Is net::FileStream safe to use with a task runner whose shutdown behavior is
CONTINUE_ON_SHUTDOWN?

[fdoray, 2016/12/09 16:49:14]

WorkerPool tasks are handled the same way as TaskScheduler CONTINUE_ON_SHUTDOWN
tasks on shutdown. Since the task ran in WorkerPool before this CL, it shouldn't
be a problem to run it in TaskScheduler with CONTINUE_ON_SHUTDOWN.

                      base::Bind(&PipeReaderWrapper::OnIOComplete, AsWeakPtr())),
         callback_(callback) {}
 
   base::ScopedFD Initialize() { return pipe_reader_.StartIO(); }
 
   void OnIOComplete() {
     std::string pipe_data;
     pipe_reader_.GetData(&pipe_data);
     JSONStringValueDeserializer json_reader(pipe_data);
 
@@ skipping 15 matching lines @@
       data[itr.key()] = value;
     }
 
     callback_.Run(true, data);
     delete this;
   }
 
   void TerminateStream() { pipe_reader_.OnDataReady(-1); }
 
  private:
   scoped_refptr<base::TaskRunner> task_runner_;

[hashimoto, 2016/12/09 10:54:37]

Please remove task_runner_.

[fdoray, 2016/12/09 16:49:14]

Done.

   PipeReaderForString pipe_reader_;
   DebugDaemonClient::GetLogsCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PipeReaderWrapper);
 };
 
 }  // namespace
 
 // The DebugDaemonClient implementation used in production.
 class DebugDaemonClientImpl : public DebugDaemonClient {
@@ skipping 652 matching lines @@
 DebugDaemonClient::EmptyStopAgentTracingCallback() {
   return base::Bind(&EmptyStopAgentTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create() {
   return new DebugDaemonClientImpl();
 }
 
 }  // namespace chromeos