Support disconnecting from wireless networks.

chrome/browser/extensions/api/networking_private/networking_private_linux.cc

 // Copyright 2014 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 "chrome/browser/extensions/api/networking_private/networking_private_linux.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 85 matching lines @@
 
 // Logs that the method is not implemented and reports |kErrorNotSupported|
 // to the failure callback.
 void ReportNotSupported(
     const std::string& method_name,
     const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
   LOG(WARNING) << method_name << " is not supported";
   failure_callback.Run(extensions::networking_private::kErrorNotSupported);
 }
 
-// Fires the appropriate callback when the network connection succeeds or fails.
-void OnNetworkConnected(
+// Fires the appropriate callback when the network connect operation succeeds
+// or fails.
+void OnNetworkConnectOperationCompleted(
     scoped_ptr<std::string> error,
     const NetworkingPrivateDelegate::VoidCallback& success_callback,
     const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
   if (!error->empty()) {
     failure_callback.Run(*error);
     return;
   }
   success_callback.Run();
 }
 
@@ skipping 214 matching lines @@
   if (!reader.PopObjectPath(&active_connection_path)) {
     LOG(ERROR) << "Unexpected response for connection path "
                << ": " << response->ToString();
     *error = "Failed to connect.";
     return;
   }
 
   return;
 }
 
+void NetworkingPrivateLinux::DisconnectFromNetwork(const std::string& guid,
+                                                   std::string* error) {
+  AssertOnDBusThread();
+  std::string device_path_str;
+  std::string access_point_path_str;
+  std::string ssid;
+  DVLOG(1) << "Disconnecting from network GUID " << guid;
+
+  if (!ParseNetworkGuid(guid, &device_path_str, &access_point_path_str,
+                        &ssid)) {
+    *error = "Invalid Network GUID format";
+    return;
+  }
+
+  scoped_ptr<NetworkMap> network_map(new NetworkMap);
+  GetAllWiFiAccessPoints(false /* configured_only */, false /* visible_only */,
+                         0 /* limit */, network_map.get());
+
+  NetworkMap::const_iterator network_iter =
+      network_map->find(base::UTF8ToUTF16(ssid));
+  if (network_iter == network_map->end()) {
+    // This network doesn't exist so there's nothing to do.
+    return;
+  }
+
+  std::string connection_state;
+  network_iter->second->GetString(kAccessPointInfoConnectionState,
+                                  &connection_state);
+  if (connection_state == ::onc::connection_state::kNotConnected) {
+    // Already disconnected so nothing to do.
+    return;
+  }
+
+  // It's not disconnected so disconnect it.
+  dbus::ObjectProxy* device_proxy =
+      dbus_->GetObjectProxy(networking_private::kNetworkManagerNamespace,
+                            dbus::ObjectPath(device_path_str));
+  dbus::MethodCall method_call(
+      networking_private::kNetworkManagerDeviceNamespace,
+      networking_private::kNetworkManagerDisconnectMethod);
+  scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+
+  if (!response) {
+    LOG(WARNING) << "Failed to disconnect network on device "
+                 << device_path_str;
+    *error = "Failed to disconnect network";
+  }
+}
+
 void NetworkingPrivateLinux::StartConnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!CheckNetworkManagerSupported(failure_callback))
     return;
 
   scoped_ptr<std::string> error(new std::string);
 
   // Runs ConnectToNetwork on |dbus_thread|.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::ConnectToNetwork,
-                 base::Unretained(this),
-                 guid,
-                 base::Unretained(error.get())),
-      base::Bind(&OnNetworkConnected,
-                 base::Passed(&error),
-                 success_callback,
-                 failure_callback));
+                 base::Unretained(this), guid, base::Unretained(error.get())),
+      base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
+                 success_callback, failure_callback));
 }
 
 void NetworkingPrivateLinux::StartDisconnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
-  ReportNotSupported("StartDisconnect", failure_callback);
+  if (!CheckNetworkManagerSupported(failure_callback))
+    return;
+
+  scoped_ptr<std::string> error(new std::string);
+
+  // Runs DisconnectFromNetwork on |dbus_thread|.
+  dbus_thread_.task_runner()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateLinux::DisconnectFromNetwork,
+                 base::Unretained(this), guid, base::Unretained(error.get())),
+      base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
+                 success_callback, failure_callback));
 }
 
 void NetworkingPrivateLinux::SetWifiTDLSEnabledState(
     const std::string& ip_or_mac_address,
     bool enabled,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   ReportNotSupported("SetWifiTDLSEnabledState", failure_callback);
 }
 
@@ skipping 495 matching lines @@
 
   if (!variant_reader.PopObjectPath(access_point_path)) {
     LOG(ERROR) << "Unexpected response: " << response->ToString();
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions