[CrOS Tether] Add disconnect handling to NetworkConnectionHandler::TetherDelegate.

chromeos/network/network_connection_handler_impl_unittest.cc

 // Copyright (c) 2012 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/network/network_connection_handler_impl.h"
 
 #include <map>
 #include <memory>
 #include <set>
 
@@ skipping 69 matching lines @@
 
  private:
   std::set<std::string> requests_;
   std::map<std::string, std::string> results_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkConnectionObserver);
 };
 
 class FakeTetherDelegate : public NetworkConnectionHandler::TetherDelegate {
  public:
-  FakeTetherDelegate() {}
+  FakeTetherDelegate()
+      : last_delegate_function_type_(DelegateFunctionType::NONE) {}
   ~FakeTetherDelegate() override {}
 
+  enum class DelegateFunctionType { NONE, CONNECT, DISCONNECT };
+
+  DelegateFunctionType last_delegate_function_type() {
+    return last_delegate_function_type_;
+  }
+
   void ConnectToNetwork(
       const std::string& service_path,
       const base::Closure& success_callback,
       const network_handler::StringResultCallback& error_callback) override {
+    last_delegate_function_type_ = DelegateFunctionType::CONNECT;
     last_service_path_ = service_path;
     last_success_callback_ = success_callback;
     last_error_callback_ = error_callback;
+  }
+
+  void DisconnectFromNetwork(
+      const std::string& service_path,
+      const base::Closure& success_callback,
+      const network_handler::StringResultCallback& error_callback) override {
+    last_delegate_function_type_ = DelegateFunctionType::DISCONNECT;
+    last_service_path_ = service_path;
+    last_success_callback_ = success_callback;
+    last_error_callback_ = error_callback;
   }
 
   std::string& last_service_path() { return last_service_path_; }
 
   base::Closure& last_success_callback() { return last_success_callback_; }
 
   network_handler::StringResultCallback& last_error_callback() {
     return last_error_callback_;
   }
 
  private:
   std::string last_service_path_;
   base::Closure last_success_callback_;
   network_handler::StringResultCallback last_error_callback_;
+  DelegateFunctionType last_delegate_function_type_;
 };
 
 }  // namespace
 
-class NetworkConnectionHandlerTest : public NetworkStateTest {
+class NetworkConnectionHandlerImplTest : public NetworkStateTest {
  public:
-  NetworkConnectionHandlerTest() : scoped_task_scheduler_(&message_loop_) {}
+  NetworkConnectionHandlerImplTest() : scoped_task_scheduler_(&message_loop_) {}
 
-  ~NetworkConnectionHandlerTest() override {}
+  ~NetworkConnectionHandlerImplTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(test_nssdb_.is_open());
 
     // Use the same DB for public and private slot.
     test_nsscertdb_.reset(new net::NSSCertDatabaseChromeOS(
         crypto::ScopedPK11Slot(PK11_ReferenceSlot(test_nssdb_.slot())),
         crypto::ScopedPK11Slot(PK11_ReferenceSlot(test_nssdb_.slot()))));
     test_nsscertdb_->SetSlowTaskRunnerForTest(message_loop_.task_runner());
 
@@ skipping 51 matching lines @@
 
     DBusThreadManager::Shutdown();
     CertLoader::Shutdown();
   }
 
  protected:
   void Connect(const std::string& service_path) {
     const bool check_error_state = true;
     network_connection_handler_->ConnectToNetwork(
         service_path,
-        base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
+        base::Bind(&NetworkConnectionHandlerImplTest::SuccessCallback,
                    base::Unretained(this)),
-        base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
+        base::Bind(&NetworkConnectionHandlerImplTest::ErrorCallback,
                    base::Unretained(this)),
         check_error_state);
     base::RunLoop().RunUntilIdle();
   }
 
   void Disconnect(const std::string& service_path) {
     network_connection_handler_->DisconnectNetwork(
         service_path,
-        base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
+        base::Bind(&NetworkConnectionHandlerImplTest::SuccessCallback,
                    base::Unretained(this)),
-        base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
+        base::Bind(&NetworkConnectionHandlerImplTest::ErrorCallback,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void SuccessCallback() { result_ = kSuccessResult; }
 
   void ErrorCallback(const std::string& error_name,
                      std::unique_ptr<base::DictionaryValue> error_data) {
     result_ = error_name;
   }
@@ skipping 72 matching lines @@
   std::unique_ptr<NetworkProfileHandler> network_profile_handler_;
   crypto::ScopedTestNSSDB test_nssdb_;
   std::unique_ptr<net::NSSCertDatabaseChromeOS> test_nsscertdb_;
   base::MessageLoopForUI message_loop_;
   std::string result_;
   std::unique_ptr<FakeTetherDelegate> fake_tether_delegate_;
 
  private:
   base::test::ScopedTaskScheduler scoped_task_scheduler_;
 
-  DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerTest);
+  DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerImplTest);
 };
 
 namespace {
 
 const char* kNoNetwork = "no-network";
 const char* kWifi0 = "wifi0";
 const char* kWifi1 = "wifi1";
 const char* kWifi2 = "wifi2";
 const char* kWifi3 = "wifi3";
 
 const char* kConfigConnectable =
     "{ \"GUID\": \"wifi0\", \"Type\": \"wifi\", \"State\": \"idle\", "
     "  \"Connectable\": true }";
 const char* kConfigConnected =
     "{ \"GUID\": \"wifi1\", \"Type\": \"wifi\", \"State\": \"online\" }";
 const char* kConfigConnecting =
     "{ \"GUID\": \"wifi2\", \"Type\": \"wifi\", \"State\": \"association\" }";
 const char* kConfigRequiresPassphrase =
     "{ \"GUID\": \"wifi3\", \"Type\": \"wifi\", "
     "  \"PassphraseRequired\": true }";
 
 const char* kPolicyWifi0 =
     "[{ \"GUID\": \"wifi0\",  \"IPAddressConfigType\": \"DHCP\", "
     "   \"Type\": \"WiFi\", \"Name\": \"My WiFi Network\","
     "   \"WiFi\": { \"SSID\": \"wifi0\"}}]";
 
 }  // namespace
 
-TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectSuccess) {
+TEST_F(NetworkConnectionHandlerImplTest,
+       NetworkConnectionHandlerConnectSuccess) {
   EXPECT_FALSE(ConfigureService(kConfigConnectable).empty());
   Connect(kWifi0);
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
   EXPECT_EQ(shill::kStateOnline,
             GetServiceStringProperty(kWifi0, shill::kStateProperty));
   // Observer expectations
   EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi0));
   EXPECT_EQ(kSuccessResult, network_connection_observer_->GetResult(kWifi0));
 }
 
-TEST_F(NetworkConnectionHandlerTest,
+TEST_F(NetworkConnectionHandlerImplTest,
        NetworkConnectionHandlerConnectProhibited) {
   EXPECT_FALSE(ConfigureService(kConfigConnectable).empty());
   base::DictionaryValue global_config;
   global_config.SetBooleanWithoutPathExpansion(
       ::onc::global_network_config::kAllowOnlyPolicyNetworksToConnect, true);
   SetupPolicy("[]", global_config, false /* load as device policy */);
   LoginToRegularUser();
   Connect(kWifi0);
   EXPECT_EQ(NetworkConnectionHandler::kErrorUnmanagedNetwork,
             GetResultAndReset());
 
   SetupPolicy(kPolicyWifi0, global_config, false /* load as device policy */);
   Connect(kWifi0);
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 // Handles basic failure cases.
-TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectFailure) {
+TEST_F(NetworkConnectionHandlerImplTest,
+       NetworkConnectionHandlerConnectFailure) {
   Connect(kNoNetwork);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
             GetResultAndReset());
   EXPECT_TRUE(network_connection_observer_->GetRequested(kNoNetwork));
   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
             network_connection_observer_->GetResult(kNoNetwork));
 
   EXPECT_FALSE(ConfigureService(kConfigConnected).empty());
   Connect(kWifi1);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnected, GetResultAndReset());
@@ skipping 34 matching lines @@
     "            \"CommonName\" : \"%s\""
     "          }"
     "        }"
     "      }"
     "    }"
     "} ]";
 
 }  // namespace
 
 // Handle certificates.
-TEST_F(NetworkConnectionHandlerTest, ConnectCertificateMissing) {
+TEST_F(NetworkConnectionHandlerImplTest, ConnectCertificateMissing) {
   StartCertLoader();
   SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate, "unknown"),
               base::DictionaryValue(),  // no global config
               true);                    // load as user policy
 
   Connect("wifi4");
   EXPECT_EQ(NetworkConnectionHandler::kErrorCertificateRequired,
             GetResultAndReset());
 }
 
-TEST_F(NetworkConnectionHandlerTest, ConnectWithCertificateSuccess) {
+TEST_F(NetworkConnectionHandlerImplTest, ConnectWithCertificateSuccess) {
   StartCertLoader();
   scoped_refptr<net::X509Certificate> cert = ImportTestClientCert();
   ASSERT_TRUE(cert.get());
 
   SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate,
                                  cert->subject().common_name.c_str()),
               base::DictionaryValue(),  // no global config
               true);                    // load as user policy
 
   Connect("wifi4");
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 // Disabled, see http://crbug.com/396729.
-TEST_F(NetworkConnectionHandlerTest,
+TEST_F(NetworkConnectionHandlerImplTest,
        DISABLED_ConnectWithCertificateRequestedBeforeCertsAreLoaded) {
   scoped_refptr<net::X509Certificate> cert = ImportTestClientCert();
   ASSERT_TRUE(cert.get());
 
   SetupPolicy(base::StringPrintf(kPolicyWithCertPatternTemplate,
                                  cert->subject().common_name.c_str()),
               base::DictionaryValue(),  // no global config
               true);                    // load as user policy
 
   Connect("wifi4");
 
   // Connect request came before the cert loader loaded certificates, so the
   // connect request should have been throttled until the certificates are
   // loaded.
   EXPECT_EQ("", GetResultAndReset());
 
   StartCertLoader();
 
   // |StartCertLoader| should have triggered certificate loading.
   // When the certificates got loaded, the connection request should have
   // proceeded and eventually succeeded.
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
-TEST_F(NetworkConnectionHandlerTest,
+TEST_F(NetworkConnectionHandlerImplTest,
        NetworkConnectionHandlerDisconnectSuccess) {
   EXPECT_FALSE(ConfigureService(kConfigConnected).empty());
   Disconnect(kWifi1);
   EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi1));
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
-TEST_F(NetworkConnectionHandlerTest,
+TEST_F(NetworkConnectionHandlerImplTest,
        NetworkConnectionHandlerDisconnectFailure) {
   Connect(kNoNetwork);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
             GetResultAndReset());
 
   EXPECT_FALSE(ConfigureService(kConfigConnectable).empty());
   Disconnect(kWifi0);
   EXPECT_EQ(NetworkConnectionHandler::kErrorNotConnected, GetResultAndReset());
 }
 
-TEST_F(NetworkConnectionHandlerTest, ConnectToTetherNetwork_Success) {
+TEST_F(NetworkConnectionHandlerImplTest, ConnectToTetherNetwork_Success) {
   network_state_handler()->SetTetherTechnologyState(
       NetworkStateHandler::TECHNOLOGY_ENABLED);
   network_state_handler()->AddTetherNetworkState(
       kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
       100 /* signal_strength */, true /* has_connected_to_host */);
   network_connection_handler_->SetTetherDelegate(fake_tether_delegate_.get());
 
   Connect(kTetherGuid /* service_path */);
 
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::CONNECT,
+            fake_tether_delegate_->last_delegate_function_type());
   EXPECT_EQ(kTetherGuid, fake_tether_delegate_->last_service_path());
   fake_tether_delegate_->last_success_callback().Run();
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
   EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
   EXPECT_EQ(kSuccessResult,
             network_connection_observer_->GetResult(kTetherGuid));
 }
 
-TEST_F(NetworkConnectionHandlerTest, ConnectToTetherNetwork_Failure) {
+TEST_F(NetworkConnectionHandlerImplTest, ConnectToTetherNetwork_Failure) {
   network_state_handler()->SetTetherTechnologyState(
       NetworkStateHandler::TECHNOLOGY_ENABLED);
   network_state_handler()->AddTetherNetworkState(
       kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
       100 /* signal_strength */, true /* has_connected_to_host */);
   network_connection_handler_->SetTetherDelegate(fake_tether_delegate_.get());
 
   Connect(kTetherGuid /* service_path */);
 
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::CONNECT,
+            fake_tether_delegate_->last_delegate_function_type());
   EXPECT_EQ(kTetherGuid, fake_tether_delegate_->last_service_path());
   fake_tether_delegate_->last_error_callback().Run(
       NetworkConnectionHandler::kErrorConnectFailed);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
   EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed,
             network_connection_observer_->GetResult(kTetherGuid));
 }
 
-TEST_F(NetworkConnectionHandlerTest, ConnectToTetherNetwork_NoTetherDelegate) {
+TEST_F(NetworkConnectionHandlerImplTest,
+       ConnectToTetherNetwork_NoTetherDelegate) {
   network_state_handler()->SetTetherTechnologyState(
       NetworkStateHandler::TECHNOLOGY_ENABLED);
   network_state_handler()->AddTetherNetworkState(
       kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
       100 /* signal_strength */, true /* has_connected_to_host */);
 
   // Do not set a tether delegate.
 
   Connect(kTetherGuid /* service_path */);
 
-  EXPECT_EQ(
-      NetworkConnectionHandler::kErrorTetherConnectionAttemptWithNoDelegate,
-      GetResultAndReset());
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::NONE,
+            fake_tether_delegate_->last_delegate_function_type());
+  EXPECT_EQ(NetworkConnectionHandler::kErrorTetherAttemptWithNoDelegate,
+            GetResultAndReset());
   EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
-  EXPECT_EQ(
-      NetworkConnectionHandler::kErrorTetherConnectionAttemptWithNoDelegate,
-      network_connection_observer_->GetResult(kTetherGuid));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorTetherAttemptWithNoDelegate,
+            network_connection_observer_->GetResult(kTetherGuid));
+}
+
+TEST_F(NetworkConnectionHandlerImplTest, DisconnectFromTetherNetwork_Success) {
+  network_state_handler()->SetTetherTechnologyState(
+      NetworkStateHandler::TECHNOLOGY_ENABLED);
+  network_state_handler()->AddTetherNetworkState(
+      kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
+      100 /* signal_strength */, true /* has_connected_to_host */);
+  network_state_handler()->SetTetherNetworkStateConnecting(kTetherGuid);
+  network_connection_handler_->SetTetherDelegate(fake_tether_delegate_.get());
+
+  Disconnect(kTetherGuid /* service_path */);
+
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::DISCONNECT,
+            fake_tether_delegate_->last_delegate_function_type());
+  EXPECT_EQ(kTetherGuid, fake_tether_delegate_->last_service_path());
+  fake_tether_delegate_->last_success_callback().Run();
+  EXPECT_EQ(kSuccessResult, GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
+  EXPECT_EQ(kSuccessResult,
+            network_connection_observer_->GetResult(kTetherGuid));
+}
+
+TEST_F(NetworkConnectionHandlerImplTest, DisconnectFromTetherNetwork_Failure) {
+  network_state_handler()->SetTetherTechnologyState(
+      NetworkStateHandler::TECHNOLOGY_ENABLED);
+  network_state_handler()->AddTetherNetworkState(
+      kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
+      100 /* signal_strength */, true /* has_connected_to_host */);
+  network_state_handler()->SetTetherNetworkStateConnecting(kTetherGuid);
+  network_connection_handler_->SetTetherDelegate(fake_tether_delegate_.get());
+
+  Disconnect(kTetherGuid /* service_path */);
+
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::DISCONNECT,
+            fake_tether_delegate_->last_delegate_function_type());
+  EXPECT_EQ(kTetherGuid, fake_tether_delegate_->last_service_path());
+  fake_tether_delegate_->last_error_callback().Run(
+      NetworkConnectionHandler::kErrorConnectFailed);
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed,
+            network_connection_observer_->GetResult(kTetherGuid));
+}
+
+TEST_F(NetworkConnectionHandlerImplTest,
+       DisconnectFromTetherNetwork_NoTetherDelegate) {
+  network_state_handler()->SetTetherTechnologyState(
+      NetworkStateHandler::TECHNOLOGY_ENABLED);
+  network_state_handler()->AddTetherNetworkState(
+      kTetherGuid, "TetherNetwork", "Carrier", 100 /* battery_percentage */,
+      100 /* signal_strength */, true /* has_connected_to_host */);
+  network_state_handler()->SetTetherNetworkStateConnecting(kTetherGuid);
+
+  // Do not set a tether delegate.
+
+  Disconnect(kTetherGuid /* service_path */);
+
+  EXPECT_EQ(FakeTetherDelegate::DelegateFunctionType::NONE,
+            fake_tether_delegate_->last_delegate_function_type());
+  EXPECT_EQ(NetworkConnectionHandler::kErrorTetherAttemptWithNoDelegate,
+            GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kTetherGuid));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorTetherAttemptWithNoDelegate,
+            network_connection_observer_->GetResult(kTetherGuid));
 }
 
 }  // namespace chromeos