[BattOr] Make BattOr able to return firmware version.

tools/battor_agent/battor_agent.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.
 
 #include "tools/battor_agent/battor_agent.h"
 
 #include <iomanip>
 
 #include "base/bind.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 141 matching lines @@
 }
 
 void BattOrAgent::RecordClockSyncMarker(const std::string& marker) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   command_ = Command::RECORD_CLOCK_SYNC_MARKER;
   pending_clock_sync_marker_ = marker;
   PerformAction(Action::REQUEST_CONNECTION);
 }
 
+int BattOrAgent::Version() {
+  DCHECK(thread_checker_.CalledOnValidThread());

[charliea (OOO until 10-5), 2016/10/04 15:15:48]

So after you make this look like:

void BattOrAgent::GetVersion() {
   ...
}

I think the key thing that's not right here yet is that we need to actually
*get* the EEPROM from the BattOr before we're able to look up the version number
in it. The EEPROM is basically just a struct that we request from the BattOr and
the BattOr sends back. However, in order to even perform that request, we need
to initialize the connection with the BattOr. You can copy how to do this from
StartTracing, StopTracing, and RecordClockSyncMarker.

After the connection is initialized, OnConnectionOpened() will be called. You'll
probably want to add an additional case in the switch statement there along the
lines of:

case Command::GET_VERSION:
  PerformAction(Action::SEND_EEPROM_REQUEST);
  return;

Then, after you receive the EEPROM (in the switch() statement of
BattOrAgent::OnBytesRead, under Action::READ_EEPROM), you'll want to add some
logic along the lines of 

if (command_ == Command::GET_VERSION) {
  CompleteCommand(BATTOR_ERROR_NONE);
} else if (command_ == Command::STOP_TRACING) {
  // Existing logic...
} else {
  // Throw some error
}

Finally, you'll want to add your battor_eeprom_->version lookup logic that you
have right below into CompleteCommand under a new GET_VERSION section.
CompleteCommand is basically called to say "we have all the information that we
need from the BattOr stored in member variables of the BattOrAgent: go ahead and
call the callback with the right info".

+  return 1; // Actually return here.
+  return battor_eeprom_->version;
+}
+
 void BattOrAgent::BeginConnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   connection_->Open();
 }
 
 void BattOrAgent::OnConnectionOpened(bool success) {
   // Return immediately if opening the connection already timed out.
   if (timeout_callback_.IsCancelled())
     return;
   timeout_callback_.Cancel();
 
   if (!success) {
     CompleteCommand(BATTOR_ERROR_CONNECTION_FAILED);
     return;
   }
 
   switch (command_) {
     case Command::START_TRACING:
       num_init_attempts_ = 1;
       PerformAction(Action::SEND_INIT);
       return;
     case Command::STOP_TRACING:
       PerformAction(Action::SEND_EEPROM_REQUEST);
       return;
     case Command::RECORD_CLOCK_SYNC_MARKER:
       PerformAction(Action::SEND_CURRENT_SAMPLE_REQUEST);
       return;
+    case Command::VERSION:
+      return;
     case Command::INVALID:
       NOTREACHED();
   }
 }
 
 void BattOrAgent::OnBytesSent(bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Return immediately if whatever action we were trying to perform already
   // timed out.
@@ skipping 323 matching lines @@
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&Listener::OnStopTracingComplete,
                      base::Unretained(listener_), SamplesToString(), error));
       break;
     case Command::RECORD_CLOCK_SYNC_MARKER:
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&Listener::OnRecordClockSyncMarkerComplete,
                                 base::Unretained(listener_), error));
       break;
+    case Command::VERSION:
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&Listener::OnGetVersionComplete,
+                                base::Unretained(listener_), error));
     case Command::INVALID:
       NOTREACHED();
   }
 
   last_action_ = Action::INVALID;
   command_ = Command::INVALID;
   pending_clock_sync_marker_.clear();
   battor_eeprom_.reset();
   calibration_frame_.clear();
   samples_.clear();
@@ skipping 34 matching lines @@
     if (clock_sync_marker != clock_sync_markers_.end())
       trace_stream << " <" << clock_sync_marker->second << ">";
 
     trace_stream << std::endl;
   }
 
   return trace_stream.str();
 }
 
 }  // namespace battor