Clean up wake on wifi handling

chromeos/dbus/shill_device_client.cc

 // Copyright (c) 2012 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/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/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 {
 
 // The ShillDeviceClient implementation.
 class ShillDeviceClientImpl : public ShillDeviceClient {
  public:
-  explicit ShillDeviceClientImpl()
+  ShillDeviceClientImpl()
       : bus_(NULL) {
   }
 
   virtual ~ShillDeviceClientImpl() {
     for (HelperMap::iterator iter = helpers_.begin();
          iter != helpers_.end(); ++iter) {
       // This *should* never happen, yet we're getting crash reports that
       // seem to imply that it does happen sometimes.  Adding CHECKs here
       // so we can determine more accurately where the problem lies.
       // See: http://crbug.com/170541
@@ skipping 162 matching lines @@
       const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
                                  shill::kPerformTDLSOperationFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(operation);
     writer.AppendString(peer);
     GetHelper(device_path)->CallStringMethodWithErrorCallback(
         &method_call, callback, error_callback);
   }
 
+  void AddWakeOnPacketConnection(
+      const dbus::ObjectPath& device_path,
+      const net::IPEndPoint& ip_endpoint,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) override {
+    if (ip_endpoint.address().empty()) {
+      LOG(ERROR) << "AddWakeOnPacketConnection: null address";
+      return;
+    }
+    dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
+                                 shill::kAddWakeOnPacketConnectionFunction);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(ip_endpoint.ToStringWithoutPort());
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call,
+                                                            callback,
+                                                            error_callback);
+  }
+
+  void RemoveWakeOnPacketConnection(
+      const dbus::ObjectPath& device_path,
+      const net::IPEndPoint& ip_endpoint,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) override {
+    if (ip_endpoint.address().empty()) {
+      LOG(ERROR) << "RemoveWakeOnPacketConnection: null address";
+      return;
+    }
+    dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
+                                 shill::kRemoveWakeOnPacketConnectionFunction);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(ip_endpoint.ToStringWithoutPort());
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call,
+                                                            callback,
+                                                            error_callback);
+  }
+
+  void RemoveAllWakeOnPacketConnections(
+      const dbus::ObjectPath& device_path,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) override {
+    dbus::MethodCall method_call(
+        shill::kFlimflamDeviceInterface,
+        shill::kRemoveAllWakeOnPacketConnectionsFunction);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call,
+                                                            callback,
+                                                            error_callback);
+  }
+
   virtual TestInterface* GetTestInterface() override {
     return NULL;
   }
 
  protected:
   virtual void Init(dbus::Bus* bus) override {
     bus_ = bus;
   }
 
  private:
@@ skipping 28 matching lines @@
 ShillDeviceClient::ShillDeviceClient() {}
 
 ShillDeviceClient::~ShillDeviceClient() {}
 
 // static
 ShillDeviceClient* ShillDeviceClient::Create() {
   return new ShillDeviceClientImpl();
 }
 
 }  // namespace chromeos