Implement networkingPrivate.setWifiTDLSEnabledState

chromeos/dbus/fake_shill_device_client.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/dbus/fake_shill_device_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 14 matching lines @@
 
 void ErrorFunction(const std::string& device_path,
                    const std::string& error_name,
                    const std::string& error_message) {
   LOG(ERROR) << "Shill Error for: " << device_path
              << ": " << error_name << " : " << error_message;
 }
 
 void PostDeviceNotFoundError(
     const ShillDeviceClient::ErrorCallback& error_callback) {
-  std::string error_name("org.chromium.flimflam.Error.Failure");
   std::string error_message("Failed");
   base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(error_callback, error_name, error_message));
+      FROM_HERE,
+      base::Bind(error_callback, shill::kErrorResultNotFound, error_message));
 }
 
 }  // namespace
 
-FakeShillDeviceClient::FakeShillDeviceClient() : weak_ptr_factory_(this) {
+FakeShillDeviceClient::FakeShillDeviceClient()
+    : tdls_busy_count_(0),
+      weak_ptr_factory_(this) {
 }
 
 FakeShillDeviceClient::~FakeShillDeviceClient() {
   STLDeleteContainerPairSecondPointers(
       observer_list_.begin(), observer_list_.end());
 }
 
 // ShillDeviceClient overrides.
 
 void FakeShillDeviceClient::Init(dbus::Bus* bus) {}
@@ skipping 141 matching lines @@
 void FakeShillDeviceClient::Reset(const dbus::ObjectPath& device_path,
                                   const base::Closure& callback,
                                   const ErrorCallback& error_callback) {
   if (!stub_devices_.HasKey(device_path.value())) {
     PostDeviceNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
+void FakeShillDeviceClient::PerformTDLSOperation(
+    const dbus::ObjectPath& device_path,
+    const std::string& operation,
+    const std::string& peer,
+    const StringCallback& callback,
+    const ErrorCallback& error_callback) {
+  if (!stub_devices_.HasKey(device_path.value())) {
+    PostDeviceNotFoundError(error_callback);
+    return;
+  }
+  if (tdls_busy_count_) {
+    --tdls_busy_count_;
+    std::string error_message("In-Progress");
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(error_callback,
+                   shill::kErrorResultInProgress, error_message));
+    return;
+  }
+  std::string result;
+  if (operation == shill::kTDLSStatusOperation)
+    result = shill::kTDLSConnectedState;
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, result));
+}
+
 ShillDeviceClient::TestInterface* FakeShillDeviceClient::GetTestInterface() {
   return this;
 }
 
 // ShillDeviceClient::TestInterface overrides.
 
 void FakeShillDeviceClient::AddDevice(const std::string& device_path,
                                       const std::string& type,
                                       const std::string& object_path) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
@@ skipping 111 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos