[CrOS Tether] Create TetherConnector, which attempts to connect to a nearby tether host.

chromeos/components/tether/connect_tethering_operation_unittest.cc

 // Copyright 2016 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/connect_tethering_operation.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 namespace {
 
 const char kTestSsid[] = "testSsid";
 const char kTestPassword[] = "testPassword";
 
 class TestObserver : public ConnectTetheringOperation::Observer {
  public:
   TestObserver() : has_received_failure(false) {}
 
   void OnSuccessfulConnectTetheringResponse(
+      const cryptauth::RemoteDevice& remote_device,
       const std::string& ssid,
       const std::string& password) override {
+    this->remote_device = remote_device;
     this->ssid = ssid;
     this->password = password;
   }
 
   void OnConnectTetheringFailure(
+      const cryptauth::RemoteDevice& remote_device,
       ConnectTetheringResponse_ResponseCode error_code) override {
     has_received_failure = true;
+    this->remote_device = remote_device;
     this->error_code = error_code;
   }
 
+  cryptauth::RemoteDevice remote_device;
   std::string ssid;
   std::string password;
 
   bool has_received_failure;
   ConnectTetheringResponse_ResponseCode error_code;
 };
 
 std::string CreateConnectTetheringRequestString() {
   ConnectTetheringRequest request;
   return MessageWrapper(request).ToRawMessage();
@@ skipping 86 matching lines @@
     } else if (is_success_response && !use_proto_without_ssid_and_password) {
       expected_response_code = ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_SUCCESS;
     } else {
       expected_response_code = response_code;
     }
 
     if (expected_response_code ==
         ConnectTetheringResponse_ResponseCode::
             ConnectTetheringResponse_ResponseCode_SUCCESS) {
+      EXPECT_EQ(test_device_, test_observer_->remote_device);
       EXPECT_EQ(std::string(kTestSsid), test_observer_->ssid);
       EXPECT_EQ(std::string(kTestPassword), test_observer_->password);
     } else {
       EXPECT_TRUE(test_observer_->has_received_failure);
       EXPECT_EQ(expected_response_code, test_observer_->error_code);
     }
   }
 
   const std::string connect_tethering_request_string_;
   const cryptauth::RemoteDevice test_device_;
@@ skipping 77 matching lines @@
   // The maximum number of connection failures has occurred.
   EXPECT_TRUE(test_observer_->has_received_failure);
   EXPECT_EQ(ConnectTetheringResponse_ResponseCode::
                 ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR,
             test_observer_->error_code);
 }
 
 }  // namespace tether
 
 }  // namespace cryptauth