Removing file_thread_task_runner parameter from SerialIoHandler

tools/battor_agent/battor_agent_bin.cc

 // Copyright 2015 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.
 
 // This file provides a thin binary wrapper around the BattOr Agent
 // library. This binary wrapper provides a means for non-C++ tracing
 // controllers, such as Telemetry and Android Systrace, to issue high-level
 // tracing commands to the BattOr through an interactive shell.
 //
 // Example usage of how an external trace controller might use this binary:
@@ skipping 29 matching lines @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "tools/battor_agent/battor_agent.h"
 #include "tools/battor_agent/battor_error.h"
 #include "tools/battor_agent/battor_finder.h"
 
 using std::endl;
 
 namespace battor {
 
 namespace {
 
 const char kIoThreadName[] = "BattOr IO Thread";
-const char kFileThreadName[] = "BattOr File Thread";
 
 const char kUsage[] =
     "Start the battor_agent shell with:\n"
     "\n"
     "  battor_agent <switches>\n"
     "\n"
     "Switches: \n"
     "  --battor-path=<path> Uses the specified BattOr path.\n"
     "\n"
     "Once in the shell, you can issue the following commands:\n"
@@ skipping 30 matching lines @@
     tokens.push_back(tokenizer.token());
   return tokens;
 }
 
 }  // namespace
 
 // Wrapper class containing all state necessary for an independent binary to
 // use a BattOrAgent to communicate with a BattOr.
 class BattOrAgentBin : public BattOrAgent::Listener {
  public:
-  BattOrAgentBin() : io_thread_(kIoThreadName), file_thread_(kFileThreadName) {}
+  BattOrAgentBin() : io_thread_(kIoThreadName) {}
 
   ~BattOrAgentBin() { DCHECK(!agent_); }
 
   // Starts the interactive BattOr agent shell and eventually returns an exit
   // code.
   int Run(int argc, char* argv[]) {
     // If we don't have any BattOr to use, exit.
     std::string path = BattOrFinder::FindBattOr();
     if (path.empty()) {
       std::cout << "Unable to find a BattOr." << endl;
@@ skipping 173 matching lines @@
     PostRunNextCommand();
   }
 
   // Postable task for creating the BattOrAgent. Because the BattOrAgent has
   // uber thread safe dependencies, all interactions with it, including creating
   // and deleting it, MUST happen on the IO thread.
   void CreateAgent(
       const std::string& path,
       scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner,
       base::WaitableEvent* done) {
-    // In Chrome, we already have a file thread running. Because the Chrome
-    // serial library relies on having it available, we have to spin up our own.
-    if (!file_thread_.Start())
-      ExitFromThreadStartFailure(kFileThreadName);
-
-    agent_.reset(new BattOrAgent(path, this, file_thread_.task_runner(),
-                                 ui_thread_task_runner));
+    agent_.reset(new BattOrAgent(path, this, ui_thread_task_runner));
     done->Signal();
   }
 
   // Postable task for deleting the BattOrAgent. See the comment for
   // CreateAgent() above regarding why this is necessary.
   void DeleteAgent(base::WaitableEvent* done) {
     agent_.reset();
     done->Signal();
   }
 
  private:
   // NOTE: ui_thread_message_loop_ must appear before ui_thread_run_loop_ here
   // because ui_thread_run_loop_ checks for the current MessageLoop during
   // initialization.
   base::MessageLoopForUI ui_thread_message_loop_;
   base::RunLoop ui_thread_run_loop_;
 
   // Threads needed for serial communication.
   base::Thread io_thread_;
-  base::Thread file_thread_;
 
   // The agent capable of asynchronously communicating with the BattOr.
   std::unique_ptr<BattOrAgent> agent_;
 
   std::string trace_output_file_;
 };
 
 }  // namespace battor
 
 int main(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
   base::CommandLine::Init(argc, argv);
   battor::BattOrAgentBin bin;
+  base::TaskScheduler::CreateAndStartWithDefaultParams("battor_agent");
   return bin.Run(argc, argv);
 }