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 97 matching lines @@
     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();
 }
 
+// Fires the appropriate callback when the network disconnection succeeds or
+// fails.

[stevenjb, 2014/12/05 20:39:43]

Since this is identical to OnNetworkConnected, maybe just rename that
OnNetworkConnectOperationCompleted?

[zentaro, 2014/12/05 21:39:33]

Done.

+void OnNetworkDisconnected(
+    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();
+}
+
 }  // namespace
 
 NetworkingPrivateLinux::NetworkingPrivateLinux(
     content::BrowserContext* browser_context,
     scoped_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(verify_delegate.Pass()),
       browser_context_(browser_context),
       dbus_thread_("Networking Private DBus"),
       network_manager_proxy_(NULL) {
   base::Thread::Options thread_options(base::MessageLoop::Type::TYPE_IO, 0);
@@ skipping 204 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;
+  }
+
+  dbus::ObjectPath device_path(device_path_str);

[stevenjb, 2014/12/05 20:39:43]

This is only used once below (the other time should just be device_path_str).
Just use dbus::ObjectPath(device_path_str) where you need it.

[zentaro, 2014/12/05 21:39:33]

It's used in the log statement on 397 too.

+
+  scoped_ptr<NetworkMap> network_map(new NetworkMap);
+  GetAllWiFiAccessPoints(/* configured_only */ false, /* visible_only */ false,

[stevenjb, 2014/12/05 20:39:43]

switch order: (false /* configured_only */, ...)

[zentaro, 2014/12/05 21:39:33]

Done.

+                         /* limit */ 0, 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) {

[stevenjb, 2014/12/05 20:39:43]

Invert + early exit

[zentaro, 2014/12/05 21:39:33]

Done.

+    // It's not disconnected so disconnect it.
+    dbus::ObjectProxy* device_proxy = dbus_->GetObjectProxy(
+        networking_private::kNetworkManagerNamespace, device_path);
+    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.value();
+      *error = "Failed to disconnect network";
+      return;
+    }
+  }
+}
+
 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));
 }
 
 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(&OnNetworkDisconnected, 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