Clean up wake on wifi handling

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"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/values_util.h"
+#include "net/base/ip_endpoint.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 std::string kSimPin = "1111";
 
 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(
+void PostNotFoundError(
     const ShillDeviceClient::ErrorCallback& error_callback) {
   std::string error_message("Failed");
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(error_callback, shill::kErrorResultNotFound, error_message));
 }
 
 }  // namespace
 
 FakeShillDeviceClient::FakeShillDeviceClient()
@@ skipping 39 matching lines @@
 }
 
 void FakeShillDeviceClient::SetProperty(const dbus::ObjectPath& device_path,
                                         const std::string& name,
                                         const base::Value& value,
                                         const base::Closure& callback,
                                         const ErrorCallback& error_callback) {
   base::DictionaryValue* device_properties = NULL;
   if (!stub_devices_.GetDictionaryWithoutPathExpansion(device_path.value(),
                                                        &device_properties)) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   device_properties->SetWithoutPathExpansion(name, value.DeepCopy());
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillDeviceClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), device_path, name));
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
@@ skipping 29 matching lines @@
   VLOG(1) << "RequirePin: " << device_path.value();
   if (pin != kSimPin) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback, shill::kErrorResultIncorrectPin, ""));
     return;
   }
   base::DictionaryValue* device_properties = NULL;
   if (!stub_devices_.GetDictionaryWithoutPathExpansion(device_path.value(),
                                                        &device_properties)) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::DictionaryValue* simlock_dict = NULL;
   if (!device_properties->GetDictionaryWithoutPathExpansion(
           shill::kSIMLockStatusProperty, &simlock_dict)) {
     simlock_dict = new base::DictionaryValue;
     device_properties->SetWithoutPathExpansion(
         shill::kSIMLockStatusProperty, simlock_dict);
   }
   simlock_dict->Clear();
@@ skipping 12 matching lines @@
                                      const base::Closure& callback,
                                      const ErrorCallback& error_callback) {
   VLOG(1) << "EnterPin: " << device_path.value();
   if (pin != kSimPin) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback, shill::kErrorResultIncorrectPin, ""));
     return;
   }
   if (!stub_devices_.HasKey(device_path.value())) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillDeviceClient::UnblockPin(const dbus::ObjectPath& device_path,
                                        const std::string& puk,
                                        const std::string& pin,
                                        const base::Closure& callback,
                                        const ErrorCallback& error_callback) {
   VLOG(1) << "UnblockPin: " << device_path.value();
   if (!stub_devices_.HasKey(device_path.value())) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillDeviceClient::ChangePin(const dbus::ObjectPath& device_path,
                                       const std::string& old_pin,
                                       const std::string& new_pin,
                                       const base::Closure& callback,
                                       const ErrorCallback& error_callback) {
   VLOG(1) << "ChangePin: " << device_path.value();
   if (!stub_devices_.HasKey(device_path.value())) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillDeviceClient::Register(const dbus::ObjectPath& device_path,
                                      const std::string& network_id,
                                      const base::Closure& callback,
                                      const ErrorCallback& error_callback) {
   if (!stub_devices_.HasKey(device_path.value())) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillDeviceClient::SetCarrier(const dbus::ObjectPath& device_path,
                                        const std::string& carrier,
                                        const base::Closure& callback,
                                        const ErrorCallback& error_callback) {
   if (!stub_devices_.HasKey(device_path.value())) {
-    PostDeviceNotFoundError(error_callback);
+    PostNotFoundError(error_callback);
     return;
   }
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 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);
+    PostNotFoundError(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);
+    PostNotFoundError(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));
 }
 
+void FakeShillDeviceClient::AddWakeOnPacketConnection(
+    const dbus::ObjectPath& device_path,
+    const net::IPEndPoint& ip_endpoint,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  if (!stub_devices_.HasKey(device_path.value())) {
+    PostNotFoundError(error_callback);
+    return;
+  }
+
+  wake_on_packet_connections_[device_path].insert(ip_endpoint);
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
+}
+
+void FakeShillDeviceClient::RemoveWakeOnPacketConnection(
+    const dbus::ObjectPath& device_path,
+    const net::IPEndPoint& ip_endpoint,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  const auto device_iter = wake_on_packet_connections_.find(device_path);
+  if (!stub_devices_.HasKey(device_path.value()) ||
+      device_iter == wake_on_packet_connections_.end()) {
+    PostNotFoundError(error_callback);
+    return;
+  }
+
+  const auto endpoint_iter = device_iter->second.find(ip_endpoint);
+  if (endpoint_iter == device_iter->second.end()) {
+    PostNotFoundError(error_callback);
+    return;
+  }
+
+  device_iter->second.erase(endpoint_iter);
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
+}
+
+void FakeShillDeviceClient::RemoveAllWakeOnPacketConnections(
+    const dbus::ObjectPath& device_path,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  const auto iter = wake_on_packet_connections_.find(device_path);
+  if (!stub_devices_.HasKey(device_path.value()) ||
+      iter == wake_on_packet_connections_.end()) {
+    PostNotFoundError(error_callback);
+    return;
+  }
+
+  wake_on_packet_connections_.erase(iter);
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
+}
+
 ShillDeviceClient::TestInterface* FakeShillDeviceClient::GetTestInterface() {
   return this;
 }
 
 // ShillDeviceClient::TestInterface overrides.
 
 void FakeShillDeviceClient::AddDevice(const std::string& device_path,
                                       const std::string& type,
                                       const std::string& name) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
@@ skipping 110 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