Implement networkingPrivate.setWifiTDLSEnabledState

chromeos/network/network_device_handler_impl.cc

 // Copyright 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_device_handler_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/shill_property_util.h"
 #include "dbus/object_path.h"
@@ skipping 108 matching lines @@
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetShillDeviceClient()->SetProperty(
       dbus::ObjectPath(device_path),
       property_name,
       value,
       callback,
       base::Bind(&HandleShillCallFailure, device_path, error_callback));
 }
 
+// Forward declare for PostDelayedTask.
+void CallPerformTDLSOperation(
+    const std::string& device_path,
+    const std::string& operation,
+    const std::string& ip_or_mac_address,
+    const network_handler::StringResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback);
+
+void TDLSOperationCallback(
+    const std::string& device_path,
+    const std::string& operation,
+    const std::string& ip_or_mac_address,
+    const network_handler::StringResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& result) {
+  std::string event_desc = "TDLSOperationCallback: " + operation;
+  if (!result.empty())
+    event_desc += ": " + result;
+  NET_LOG_EVENT(event_desc, device_path);
+  if (operation != shill::kTDLSSetupOperation) {
+    if (!callback.is_null())
+      callback.Run(result);
+    return;
+  }
+  // Setup operation will retry if there was an error (result is not empty),
+  // or request the status.
+  std::string next_operation;
+  base::TimeDelta request_delay;
+  if (!result.empty()) {
+    const int64 kReRequestDelayMs = 1000;
+    next_operation = shill::kTDLSSetupOperation;
+    request_delay = base::TimeDelta::FromMilliseconds(kReRequestDelayMs);

[Paul Stewart, 2014/02/06 22:58:40]

I'm not sure I understand, but:

 - Does this just retry ad-infinitum?  Two issues if that's true:
   - If the error is other than kErrorResultInProgress, you stand to just sit
here forever.
   - If the error is kErrorResultInProgress you still stand to sit here forever
if the IP address never resolves.

[stevenjb, 2014/02/12 23:22:52]

You're right, we definitely need a timeout here. I'm going to start with 5s. If
it takes longer than that, the Extension can decide to retry or fail.

+  } else {
+    next_operation =  shill::kTDLSStatusOperation;

[Paul Stewart, 2014/02/06 22:58:40]

What is request_delay set to at this point?  Does the compiler warn against
uninitialized variables below?

[Paul Stewart, 2014/02/06 23:01:43]

Just spotted this was an object, which probably is set to some zero value.  You
may not want this value to be zero since the TDLS setup in the driver / firmware
won't necessarily be instant.  Since you return a result to your callback on the
first return of operation != shill::kTDLSSetupOperation, I'd suggest a small (5
second?) delay here.

[stevenjb, 2014/02/12 23:22:52]

I will set the delay to 500ms so that there is an opportunity for early feedback
to the user. I added a getWifiTDLSStatus method so that if the status is still
other than 'Connected' or 'Nonexistent' the extension can decide to poll the
status or not.

+  }
+
+  base::MessageLoopProxy::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CallPerformTDLSOperation,
+                 device_path, next_operation, ip_or_mac_address,
+                 callback, error_callback),
+      request_delay);
+}
+
+void CallPerformTDLSOperation(
+    const std::string& device_path,
+    const std::string& operation,
+    const std::string& ip_or_mac_address,
+    const network_handler::StringResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_EVENT("CallPerformTDLSOperation: " + operation, device_path);
+  DBusThreadManager::Get()->GetShillDeviceClient()->PerformTDLSOperation(
+      dbus::ObjectPath(device_path),
+      operation,
+      ip_or_mac_address,
+      base::Bind(&TDLSOperationCallback,
+                 device_path, operation, ip_or_mac_address,
+                 callback, error_callback),
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 "Device.PerformTDLSOperation Failed: " + operation,
+                 device_path,
+                 error_callback));
+}
+
 }  // namespace
 
 NetworkDeviceHandlerImpl::~NetworkDeviceHandlerImpl() {
   network_state_handler_->RemoveObserver(this, FROM_HERE);
 }
 
 void NetworkDeviceHandlerImpl::GetDeviceProperties(
     const std::string& device_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) const {
@@ skipping 124 matching lines @@
       callback,
       base::Bind(&HandleShillCallFailure, device_path, error_callback));
 }
 
 void NetworkDeviceHandlerImpl::SetCellularAllowRoaming(
     const bool allow_roaming) {
   cellular_allow_roaming_ = allow_roaming;
   ApplyCellularAllowRoamingToShill();
 }
 
+void NetworkDeviceHandlerImpl::SetWifiTDLSEnabled(
+    const std::string& ip_or_mac_address,
+    bool enabled,
+    const network_handler::StringResultCallback& callback,
+    const network_handler::ErrorCallback& error_callback) {
+  const DeviceState* device_state =
+      network_state_handler_->GetDeviceStateByType(NetworkTypePattern::WiFi());
+  if (!device_state) {
+    if (error_callback.is_null())
+      return;
+    scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+    error_data->SetString(network_handler::kErrorName, kErrorDeviceMissing);
+    error_callback.Run(kErrorDeviceMissing, error_data.Pass());
+    return;
+  }
+  std::string operation =
+      enabled ? shill::kTDLSSetupOperation : shill::kTDLSTeardownOperation;
+  CallPerformTDLSOperation(device_state->path(),
+                           operation, ip_or_mac_address,
+                           callback, error_callback);
+}
+
 void NetworkDeviceHandlerImpl::DeviceListChanged() {
   ApplyCellularAllowRoamingToShill();
 }
 
 NetworkDeviceHandlerImpl::NetworkDeviceHandlerImpl()
     : network_state_handler_(NULL),
       cellular_allow_roaming_(false) {}
 
 void NetworkDeviceHandlerImpl::Init(
     NetworkStateHandler* network_state_handler) {
@@ skipping 35 matching lines @@
 
     SetDevicePropertyInternal(device_state->path(),
                               shill::kCellularAllowRoamingProperty,
                               base::FundamentalValue(new_device_value),
                               base::Bind(&base::DoNothing),
                               network_handler::ErrorCallback());
   }
 }
 
 }  // namespace chromeos