Adds NetworkConnect::ConnectToNetworkId(), uses it in detailed VPN page

chromeos/network/network_connect.cc

 // Copyright (c) 2013 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_connect.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
+void IgnoreDisconnectError(const std::string& error_name,
+                           std::unique_ptr<base::DictionaryValue> error_data) {}
+
 // Returns true for carriers that can be activated through Shill instead of
 // through a WebUI dialog.
 bool IsDirectActivatedCarrier(const std::string& carrier) {
   if (carrier == shill::kCarrierSprint)
     return true;
   return false;
 }
 
 const NetworkState* GetNetworkStateFromId(const std::string& network_id) {
   // Note: network_id === NetworkState::guid.
   return NetworkHandler::Get()
       ->network_state_handler()
       ->GetNetworkStateFromGuid(network_id);
 }
 
 class NetworkConnectImpl : public NetworkConnect {
  public:
   explicit NetworkConnectImpl(Delegate* delegate);
   ~NetworkConnectImpl() override;
 
   // NetworkConnect
   void ConnectToNetworkId(const std::string& network_id) override;
+  void DisconnectFromNetworkId(const std::string& network_id) override;
   bool MaybeShowConfigureUI(const std::string& network_id,
                             const std::string& connect_error) override;
   void SetTechnologyEnabled(const NetworkTypePattern& technology,
                             bool enabled_state) override;
   void ShowMobileSetup(const std::string& network_id) override;
   void ConfigureNetworkIdAndConnect(
       const std::string& network_id,
       const base::DictionaryValue& shill_properties,
       bool shared) override;
   void CreateConfigurationAndConnect(base::DictionaryValue* shill_properties,
@@ skipping 334 matching lines @@
       return;
     } else if (network->RequiresActivation()) {
       ActivateCellular(network_id);
       return;
     }
   }
   const bool check_error_state = true;
   CallConnectToNetwork(network_id, check_error_state);
 }
 
+void NetworkConnectImpl::DisconnectFromNetworkId(
+    const std::string& network_id) {
+  NET_LOG_USER("DisconnectFromNetwork", network_id);
+  const NetworkState* network = GetNetworkStateFromId(network_id);
+  if (!network)
+    return;
+  NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
+      network->path(), base::Bind(&base::DoNothing),
+      base::Bind(&IgnoreDisconnectError));
+}
+
 bool NetworkConnectImpl::MaybeShowConfigureUI(
     const std::string& network_id,
     const std::string& connect_error) {
   return MaybeShowConfigureUIImpl(network_id, connect_error);
 }
 
 void NetworkConnectImpl::SetTechnologyEnabled(
     const NetworkTypePattern& technology,
     bool enabled_state) {
   std::string log_string = base::StringPrintf(
@@ skipping 162 matching lines @@
 NetworkConnect* NetworkConnect::Get() {
   CHECK(g_network_connect);
   return g_network_connect;
 }
 
 NetworkConnect::NetworkConnect() {}
 
 NetworkConnect::~NetworkConnect() {}
 
 }  // namespace chromeos