tools/battor_agent: Adds a tool to find connected BattOrs

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..
 
 #include <stdint.h>
 
 #include <iostream>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/threading/thread.h"
 #include "tools/battor_agent/battor_agent.h"
 #include "tools/battor_agent/battor_error.h"
+#include "tools/battor_agent/battor_finder.h"
 
 using std::cout;
 using std::endl;
 
 namespace {
 
 const char kIoThreadName[] = "BattOr IO Thread";
 const char kFileThreadName[] = "BattOr File Thread";
 const char kUiThreadName[] = "BattOr UI Thread";
 const int32_t kBattOrCommandTimeoutSeconds = 10;
 
 void PrintUsage() {
   cout << "Usage: battor_agent <command> <arguments>" << endl
        << endl
        << "Commands:" << endl
        << endl
        << "  StartTracing <path>" << endl
        << "  StopTracing <path>" << endl
        << "  SupportsExplicitClockSync" << endl
        << "  RecordClockSyncMarker <path> <marker>" << endl
        << "  IssueClockSyncMarker <path>" << endl
        << "  Help" << endl;
 }
 
 void PrintSupportsExplicitClockSync() {
   cout << battor::BattOrAgent::SupportsExplicitClockSync() << endl;
 }
 
-// Retrieves argument argnum from the argument list, printing the usage
-// guidelines and exiting with an error code if the argument doesn't exist.
+// Retrieves argument argnum from the argument list, or an empty string if the
+// argument doesn't exist.
 std::string GetArg(int argnum, int argc, char* argv[]) {
   if (argnum >= argc) {
-    PrintUsage();
-    exit(1);
+    return std::string();
   }
 
   return argv[argnum];
 }
 
 // Checks if an error occurred and, if it did, prints the error and exits
 // with an error code.
 void CheckError(battor::BattOrError error) {
   if (error != battor::BATTOR_ERROR_NONE)
     LOG(FATAL) << "Fatal error when communicating with the BattOr: " << error;
@@ skipping 16 matching lines @@
       : done_(false, false),
         io_thread_(kIoThreadName),
         file_thread_(kFileThreadName),
         ui_thread_(kUiThreadName) {}
 
   ~BattOrAgentBin() { DCHECK(!agent_); }
 
   // Runs the BattOr binary and returns the exit code.
   int Run(int argc, char* argv[]) {
     std::string cmd = GetArg(1, argc, argv);
+    if (cmd.empty()) {
+      PrintUsage();
+      exit(1);
+    }
 
     // SupportsExplicitClockSync doesn't need to use the serial connection, so
     // handle it separately.
     if (cmd == "SupportsExplicitClockSync") {
       PrintSupportsExplicitClockSync();
       return 0;
     }
 
     std::string path = GetArg(2, argc, argv);
+    // If no path is specified, see if we can find a BattOr and use that.
+    if (path.empty())
+      path = BattOrFinder::FindBattOr();
+
+    // If we don't have any BattOr to use, exit.
+    if (path.empty()) {
+      cout << "Unable to find a BattOr, and no explicit BattOr path was "
+              "specified."
+           << endl;
+      exit(1);
+    }
+
     SetUp(path);
 
     if (cmd == "StartTracing") {
       StartTracing();
     } else if (cmd == "StopTracing") {
       StopTracing();
     } else if (cmd == "RecordClockSyncMarker") {
       // TODO(charliea): Write RecordClockSyncMarker.
     } else if (cmd == "IssueClockSyncMarker") {
       // TODO(charliea): Write IssueClockSyncMarker.
@@ skipping 115 matching lines @@
   scoped_ptr<BattOrAgent> agent_;
 };
 
 }  // namespace battor
 
 int main(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
   battor::BattOrAgentBin bin;
   return bin.Run(argc, argv);
 }