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,
                                      bool shared) override;
   void CreateConfiguration(base::DictionaryValue* shill_properties,
                            bool shared) override;
   void SetTetherDelegate(TetherDelegate* tether_delegate) override;
 
  private:
   void ActivateCellular(const std::string& network_id);
   void HandleUnconfiguredNetwork(const std::string& network_id);
   void OnConnectFailed(const std::string& network_id,
                        const std::string& error_name,
                        std::unique_ptr<base::DictionaryValue> error_data);
   bool MaybeShowConfigureUIImpl(const std::string& network_id,
                                 const std::string& connect_error);
   bool GetNetworkProfilePath(bool shared, std::string* profile_path);
   void OnConnectSucceeded(const std::string& network_id);
   void CallConnectToNetwork(const std::string& network_id,
                             bool check_error_state);
+  void CallDisconnectFromNetwork(const std::string& network_id);

[stevenjb, 2017/03/23 21:43:43]

We don't really need this. CallConnectToNetwork exists because it has multiple
entry points.

[varkha, 2017/03/23 22:46:55]

Done.

   void OnActivateFailed(const std::string& network_id,
                         const std::string& error_name,
                         std::unique_ptr<base::DictionaryValue> error_data);
   void OnActivateSucceeded(const std::string& network_id);
   void OnConfigureFailed(const std::string& error_name,
                          std::unique_ptr<base::DictionaryValue> error_data);
   void OnConfigureSucceeded(bool connect_on_configure,
                             const std::string& service_path,
                             const std::string& network_id);
   void CallCreateConfiguration(base::DictionaryValue* properties,
@@ skipping 165 matching lines @@
   }
 
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       network->path(), base::Bind(&NetworkConnectImpl::OnConnectSucceeded,
                                   weak_factory_.GetWeakPtr(), network_id),
       base::Bind(&NetworkConnectImpl::OnConnectFailed,
                  weak_factory_.GetWeakPtr(), network_id),
       check_error_state);
 }
 
+void NetworkConnectImpl::CallDisconnectFromNetwork(
+    const std::string& 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));
+}
+
 void NetworkConnectImpl::OnActivateFailed(
     const std::string& network_id,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to activate network", network_id);
   delegate_->ShowNetworkConnectError(
       NetworkConnectionHandler::kErrorActivateFailed, network_id);
 }
 
 void NetworkConnectImpl::OnActivateSucceeded(const std::string& network_id) {
@@ skipping 122 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);
+  CallDisconnectFromNetwork(network_id);
+}
+
 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