[CrOS Tether] Update the KeepAliveTickle code to receive DeviceStatus updates.

chromeos/components/tether/keep_alive_operation.cc

 // Copyright 2017 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/components/tether/keep_alive_operation.h"
 
 #include "chromeos/components/tether/message_wrapper.h"
 #include "chromeos/components/tether/proto/tether.pb.h"
 #include "components/proximity_auth/logging/logging.h"
 
@@ skipping 26 matching lines @@
     BleConnectionManager* connection_manager) {
   return base::MakeUnique<KeepAliveOperation>(device_to_connect,
                                               connection_manager);
 }
 
 KeepAliveOperation::KeepAliveOperation(
     const cryptauth::RemoteDevice& device_to_connect,
     BleConnectionManager* connection_manager)
     : MessageTransferOperation(
           std::vector<cryptauth::RemoteDevice>{device_to_connect},
-          connection_manager) {}
+          connection_manager),
+      remote_device_(device_to_connect) {}
 
 KeepAliveOperation::~KeepAliveOperation() {}
 
 void KeepAliveOperation::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void KeepAliveOperation::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void KeepAliveOperation::OnDeviceAuthenticated(
     const cryptauth::RemoteDevice& remote_device) {
   DCHECK(remote_devices().size() == 1u && remote_devices()[0] == remote_device);
 
   SendMessageToDevice(remote_device,
                       base::MakeUnique<MessageWrapper>(KeepAliveTickle()));
+}
+
+void KeepAliveOperation::OnMessageReceived(
+    std::unique_ptr<MessageWrapper> message_wrapper,
+    const cryptauth::RemoteDevice& remote_device) {
+  if (message_wrapper->GetMessageType() !=
+      MessageType::KEEP_ALIVE_TICKLE_RESPONSE) {
+    // If another type of message has been received, ignore it.
+    return;
+  }
+
+  if (!(remote_device == remote_device_)) {
+    // If the message came from another device, ignore it.
+    return;
+  }
+
+  KeepAliveTickleResponse* response =
+      static_cast<KeepAliveTickleResponse*>(message_wrapper->GetProto().get());
+  device_status_ = base::MakeUnique<DeviceStatus>(response->device_status());
+
+  // Now that a response has been received, the device can be unregistered.
   UnregisterDevice(remote_device);
 }
 
 void KeepAliveOperation::OnOperationFinished() {
   for (auto& observer : observer_list_) {
-    observer.OnOperationFinished();
+    // Note: If the operation did not complete successfully, |device_status_|
+    // will still be null.
+    observer.OnOperationFinished(
+        remote_device_, device_status_
+                            ? base::MakeUnique<DeviceStatus>(*device_status_)
+                            : nullptr);
   }
 }
 
 MessageType KeepAliveOperation::GetMessageTypeForConnection() {
   return MessageType::KEEP_ALIVE_TICKLE;
 }
 
 }  // namespace tether
 
 }  // namespace chromeos