GCM: D-Bus methods for wake-on-packet

Program the NIC to wake-on-packet for packets arriving from
the GCM server.  Chrome notifies the connection manager (shill)
by calling D-Bus methods.  The return status indicates if the
operation succeeded or not (depending on hardware support and
the type of connection).

This is a resubmission of a previous patch with the same title
and functionality containing fixes and a workaround for a problem
that is independent of this patch.  Bug 415821 remains open
for that problem.

Keywords: wowlan, wake-on-lan, wake-on-wlan

BUG=360295
TEST=verified dbus methods are called, and packets are sent on the
TEST=connection passed to the methods.  Also verified that shill
TEST=programs the NIC correctly, and packets wake up the device.

Review URL: https://codereview.chromium.org/597683005

Cr-Commit-Position: refs/heads/master@{#296516}

chrome/browser/extensions/extension_gcm_app_handler_unittest.cc

@@ -56,6 +56,7 @@
 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #endif
 
 namespace extensions {
@@ -220,6 +221,10 @@ class ExtensionGCMAppHandlerTest : public testing::Test {
     // This is needed to create extension service under CrOS.
 #if defined(OS_CHROMEOS)
     test_user_manager_.reset(new chromeos::ScopedTestUserManager());
+    // Creating a DBus thread manager setter has the side effect of
+    // creating a DBusThreadManager, which is needed for testing.
+    // We don't actually need the setter so we ignore the return value.
+    chromeos::DBusThreadManager::GetSetterForTesting();
 #endif
 
     // Create a new profile.

chrome/browser/services/gcm/chromeos_gcm_connection_observer.cc

+// Copyright (c) 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/services/gcm/chromeos_gcm_connection_observer.h"
+
+#include "base/callback.h"
+#include "base/logging.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_manager_client.h"
+
+namespace gcm {
+
+ChromeOSGCMConnectionObserver::ChromeOSGCMConnectionObserver() {
+}
+
+ChromeOSGCMConnectionObserver::~ChromeOSGCMConnectionObserver() {
+}
+
+// static
+void ChromeOSGCMConnectionObserver::ErrorCallback(
+    const std::string& error_name,
+    const std::string& error) {
+  LOG(ERROR) << "GCM D-Bus method error " << error_name << ": " << error;
+}
+
+void ChromeOSGCMConnectionObserver::OnConnected(
+    const net::IPEndPoint& ip_endpoint) {
+  ip_endpoint_ = ip_endpoint;
+  chromeos::DBusThreadManager::Get()->
+      GetShillManagerClient()->
+      AddWakeOnPacketConnection(
+          ip_endpoint,
+          base::Bind(&base::DoNothing),
+          base::Bind(&ChromeOSGCMConnectionObserver::ErrorCallback));
+}
+
+void ChromeOSGCMConnectionObserver::OnDisconnected() {
+  chromeos::DBusThreadManager::Get()->
+      GetShillManagerClient()->
+      RemoveWakeOnPacketConnection(
+          ip_endpoint_,
+          base::Bind(&base::DoNothing),
+          base::Bind(&ChromeOSGCMConnectionObserver::ErrorCallback));
+}
+
+}  // namespace gcm

chrome/browser/services/gcm/chromeos_gcm_connection_observer.h

+// Copyright (c) 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.
+
+#ifndef CHROME_BROWSER_SERVICES_GCM_CHROMEOS_GCM_CONNECTION_OBSERVER_H_
+#define CHROME_BROWSER_SERVICES_GCM_CHROMEOS_GCM_CONNECTION_OBSERVER_H_
+
+#include "base/compiler_specific.h"
+#include "components/gcm_driver/gcm_connection_observer.h"
+#include "net/base/ip_endpoint.h"
+
+namespace gcm {
+
+class ChromeOSGCMConnectionObserver : public GCMConnectionObserver {
+ public:
+  ChromeOSGCMConnectionObserver();
+  virtual ~ChromeOSGCMConnectionObserver();
+  // gcm::GCMConnectionObserver implementation:
+  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
+  virtual void OnDisconnected() OVERRIDE;
+
+  static void ErrorCallback(
+      const std::string& error_name,
+      const std::string& error);
+
+ private:
+  net::IPEndPoint ip_endpoint_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeOSGCMConnectionObserver);
+};
+
+}  // namespace gcm
+
+#endif  // CHROME_BROWSER_SERVICES_GCM_CHROMEOS_GCM_CONNECTION_OBSERVER_H_

chrome/browser/services/gcm/gcm_profile_service.cc

@@ -16,6 +16,9 @@
 #include "components/gcm_driver/gcm_driver_android.h"
 #else
 #include "base/bind.h"
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/services/gcm/chromeos_gcm_connection_observer.h"
+#endif
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/services/gcm/gcm_account_tracker.h"
@@ -170,6 +173,11 @@ GCMProfileService::GCMProfileService(
       profile_->GetPath().Append(chrome::kGCMStoreDirname),
       profile_->GetRequestContext());
 
+#if defined(OS_CHROMEOS)
+  chromeos_connection_observer_.reset(new gcm::ChromeOSGCMConnectionObserver);
+  driver_->AddConnectionObserver(chromeos_connection_observer_.get());
+#endif
+
   identity_observer_.reset(new IdentityObserver(
       profile, static_cast<gcm::GCMDriverDesktop*>(driver_.get())));
 }
@@ -205,8 +213,11 @@ void GCMProfileService::Shutdown() {
 #if !defined(OS_ANDROID)
   identity_observer_.reset();
 #endif  // !defined(OS_ANDROID)
-
   if (driver_) {
+#if defined(OS_CHROMEOS)
+    driver_->RemoveConnectionObserver(chromeos_connection_observer_.get());
+    chromeos_connection_observer_.reset();
+#endif
     driver_->Shutdown();
     driver_.reset();
   }

chrome/browser/services/gcm/gcm_profile_service.h

@@ -86,6 +86,9 @@ class GCMProfileService : public KeyedService {
   class IdentityObserver;
   scoped_ptr<IdentityObserver> identity_observer_;
 #endif
+#if defined(OS_CHROMEOS)
+  scoped_ptr<GCMConnectionObserver> chromeos_connection_observer_;
+#endif
 
   DISALLOW_COPY_AND_ASSIGN(GCMProfileService);
 };

chrome/browser/services/gcm/gcm_profile_service_unittest.cc

@@ -15,6 +15,9 @@
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/test/base/testing_profile.h"
+#if defined(OS_CHROMEOS)
+#include "chromeos/dbus/dbus_thread_manager.h"
+#endif
 #include "components/gcm_driver/fake_gcm_app_handler.h"
 #include "components/gcm_driver/fake_gcm_client.h"
 #include "components/gcm_driver/fake_gcm_client_factory.h"
@@ -116,6 +119,11 @@ FakeGCMClient* GCMProfileServiceTest::GetGCMClient() const {
 }
 
 void GCMProfileServiceTest::SetUp() {
+#if defined(OS_CHROMEOS)
+  // Create a DBus thread manager setter for its side effect.
+  // Ignore the return value.
+  chromeos::DBusThreadManager::GetSetterForTesting();
+#endif
   TestingProfile::Builder builder;
   builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
                             FakeSigninManager::Build);

chrome/chrome_browser.gypi

@@ -2644,6 +2644,8 @@
       # support ChromeOS with enable_plugins==0.
       'browser/renderer_host/pepper/pepper_platform_verification_message_filter.cc',
       'browser/renderer_host/pepper/pepper_platform_verification_message_filter.h',
+      'browser/services/gcm/chromeos_gcm_connection_observer.cc',
+      'browser/services/gcm/chromeos_gcm_connection_observer.h',
     ],
     # Used everywhere but ChromeOS.
     'chrome_browser_non_chromeos_sources': [

chromeos/dbus/fake_shill_manager_client.cc

@@ -355,6 +355,23 @@ void FakeShillManagerClient::ConnectToBestServices(
       dbus::ObjectPath(best_service_), callback, error_callback);
 }
 
+void FakeShillManagerClient::AddWakeOnPacketConnection(
+    const net::IPEndPoint& ip_endpoint,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+}
+
+void FakeShillManagerClient::RemoveWakeOnPacketConnection(
+    const net::IPEndPoint& ip_endpoint,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+}
+
+void FakeShillManagerClient::RemoveAllWakeOnPacketConnections(
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+}
+
 ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() {
   return this;
 }

chromeos/dbus/fake_shill_manager_client.h

@@ -12,6 +12,10 @@
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/shill_manager_client.h"
 
+namespace net {
+class IPEndPoint;
+}
+
 namespace chromeos {
 
 // A fake implementation of ShillManagerClient. This works in close coordination
@@ -77,6 +81,18 @@ class CHROMEOS_EXPORT FakeShillManagerClient
   virtual void ConnectToBestServices(
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
+  virtual void AddWakeOnPacketConnection(
+      const net::IPEndPoint& ip_connection,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE;
+  virtual void RemoveWakeOnPacketConnection(
+      const net::IPEndPoint& ip_endpoint,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE;
+  virtual void RemoveAllWakeOnPacketConnections(
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE;
+
   virtual ShillManagerClient::TestInterface* GetTestInterface() OVERRIDE;
 
   // ShillManagerClient::TestInterface overrides.

chromeos/dbus/mock_shill_manager_client.h

@@ -8,6 +8,7 @@
 #include "base/values.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
+#include "net/base/ip_endpoint.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace chromeos {
@@ -66,6 +67,17 @@ class MockShillManagerClient : public ShillManagerClient {
   MOCK_METHOD2(ConnectToBestServices,
                void(const base::Closure& callback,
                     const ErrorCallback& error_callback));
+  MOCK_METHOD3(AddWakeOnPacketConnection,
+               void(const net::IPEndPoint& ip_connection,
+                    const base::Closure& callback,
+                    const ErrorCallback& error_callback));
+  MOCK_METHOD3(RemoveWakeOnPacketConnection,
+               void(const net::IPEndPoint& ip_connection,
+                    const base::Closure& callback,
+                    const ErrorCallback& error_callback));
+  MOCK_METHOD2(RemoveAllWakeOnPacketConnections,
+               void(const base::Closure& callback,
+                    const ErrorCallback& error_callback));
   MOCK_METHOD0(GetTestInterface, TestInterface*());
 
 };

chromeos/dbus/shill_manager_client.cc

@@ -14,6 +14,7 @@
 #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 {
@@ -210,6 +211,51 @@ class ShillManagerClientImpl : public ShillManagerClient {
                                             error_callback);
   }
 
+  virtual void AddWakeOnPacketConnection(
+      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::kFlimflamManagerInterface,
+                                 shill::kAddWakeOnPacketConnectionFunction);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(net::IPAddressToString(ip_endpoint.address()));
+    helper_->CallVoidMethodWithErrorCallback(&method_call,
+                                             callback,
+                                             error_callback);
+  }
+
+  virtual void RemoveWakeOnPacketConnection(
+      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::kFlimflamManagerInterface,
+                                 shill::kRemoveWakeOnPacketConnectionFunction);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(net::IPAddressToString(ip_endpoint.address()));
+    helper_->CallVoidMethodWithErrorCallback(&method_call,
+                                             callback,
+                                             error_callback);
+  }
+
+  virtual void RemoveAllWakeOnPacketConnections(
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
+    dbus::MethodCall method_call(
+        shill::kFlimflamManagerInterface,
+        shill::kRemoveAllWakeOnPacketConnectionsFunction);
+    helper_->CallVoidMethodWithErrorCallback(&method_call,
+                                             callback,
+                                             error_callback);
+  }
+
   virtual TestInterface* GetTestInterface() OVERRIDE {
     return NULL;
   }

chromeos/dbus/shill_manager_client.h

@@ -14,10 +14,12 @@
 #include "chromeos/dbus/shill_client_helper.h"
 
 namespace dbus {
-
 class ObjectPath;
+}
 
-}  // namespace dbus
+namespace net {
+class IPEndPoint;
+}
 
 namespace chromeos {
 
@@ -193,35 +195,53 @@ class CHROMEOS_EXPORT ShillManagerClient : public DBusClient {
                           const ObjectPathCallback& callback,
                           const ErrorCallback& error_callback) = 0;
 
-  // Verify that the given data corresponds to a trusted device, and return true
-  // to the callback if it is.
+  // Verifies that the given data corresponds to a trusted device, and returns
+  // true to the callback if it is.
   virtual void VerifyDestination(const VerificationProperties& properties,
                                  const BooleanCallback& callback,
                                  const ErrorCallback& error_callback) = 0;
 
-  // Verify that the given data corresponds to a trusted device, and if it is,
-  // return the encrypted credentials for connecting to the network represented
+  // Verifies that the given data corresponds to a trusted device, and if it is,
+  // returns the encrypted credentials for connecting to the network represented
   // by the given |service_path|, encrypted using the |public_key| for the
-  // trusted device. If the device is not trusted, return the empty string.
+  // trusted device. If the device is not trusted, returns the empty string.
   virtual void VerifyAndEncryptCredentials(
       const VerificationProperties& properties,
       const std::string& service_path,
       const StringCallback& callback,
       const ErrorCallback& error_callback) = 0;
 
-  // Verify that the given data corresponds to a trusted device, and return the
-  // |data| encrypted using the |public_key| for the trusted device. If the
-  // device is not trusted, return the empty string.
+  // Verifies that the given data corresponds to a trusted device, and returns
+  // the |data| encrypted using the |public_key| for the trusted device. If the
+  // device is not trusted, returns the empty string.
   virtual void VerifyAndEncryptData(const VerificationProperties& properties,
                                     const std::string& data,
                                     const StringCallback& callback,
                                     const ErrorCallback& error_callback) = 0;
 
-  // For each technology present, connect to the "best" service available.
+  // For each technology present, connects to the "best" service available.
   // Called once the user is logged in and certificates are loaded.
   virtual void ConnectToBestServices(const base::Closure& callback,
                                      const ErrorCallback& error_callback) = 0;
 
+  // Requests that shill program the NIC so that packets incoming on
+  // |ip_connection| wake up the CPU.
+  virtual void AddWakeOnPacketConnection(
+      const net::IPEndPoint& ip_endpoint,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) = 0;
+
+  // Removes a request to wake up on packets coming on |ip_connection|.
+  virtual void RemoveWakeOnPacketConnection(
+      const net::IPEndPoint& ip_endpoint,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) = 0;
+
+  // Clears all requests to wake up on packets.
+  virtual void RemoveAllWakeOnPacketConnections(
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) = 0;
+
   // Returns an interface for testing (stub only), or returns NULL.
   virtual TestInterface* GetTestInterface() = 0;