[battor agent] Make BattOr agent block until the BattOrAgent is created

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 123 matching lines @@
   }
 
   // Performs any setup necessary for the BattOr binary to run.
   void SetUp(const std::string& path) {
     base::Thread::Options io_thread_options;
     io_thread_options.message_loop_type = base::MessageLoopForIO::TYPE_IO;
     if (!io_thread_.StartWithOptions(io_thread_options)) {
       ExitFromThreadStartFailure(kIoThreadName);
     }
 
+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);

[aschulman, 2016/06/15 14:51:03]

I'd like to see a comment explaining why this particular waitable event is
needed since this was needed to fix a particularly nasty bug that wasn't obvious
when you first wrote the code for this thread.

     io_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&BattOrAgentBin::CreateAgent, base::Unretained(this), path,
-                   base::ThreadTaskRunnerHandle::Get()));
+                   base::ThreadTaskRunnerHandle::Get(), &done));
+    done.Wait();
   }
 
   // Performs any cleanup necessary after the BattOr binary is done running.
   void TearDown() {
     base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
     io_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&BattOrAgentBin::DeleteAgent,
                               base::Unretained(this), &done));
     done.Wait();
@@ skipping 107 matching lines @@
       HandleError(error);
 
     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) {
+      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));
+    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:
@@ skipping 14 matching lines @@
 };
 
 }  // namespace battor
 
 int main(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
   base::CommandLine::Init(argc, argv);
   battor::BattOrAgentBin bin;
   return bin.Run(argc, argv);
 }