Tracking push events for lucid sleep

chrome/browser/chromeos/net/wake_on_wifi_manager.cc

 // Copyright 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/chromeos/net/wake_on_wifi_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
+#include "chrome/common/extensions/api/gcm.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "components/gcm_driver/gcm_connection_observer.h"
 #include "components/gcm_driver/gcm_driver.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_set.h"
+#include "extensions/common/one_shot_event.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "net/base/ip_endpoint.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kWakeOnNone[] = "none";
 const char kWakeOnPacket[] = "packet";
 const char kWakeOnSsid[] = "ssid";
@@ skipping 92 matching lines @@
 
 // static
 WakeOnWifiManager* WakeOnWifiManager::Get() {
   DCHECK(g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return g_wake_on_wifi_manager;
 }
 
 WakeOnWifiManager::WakeOnWifiManager()
     : current_feature_(WakeOnWifiManager::INVALID),
+      suspend_is_pending_(false),
       weak_ptr_factory_(this) {
+  LOG(WARNING) << "CONSTRUCTOR";
   // This class must be constructed before any users are logged in, i.e., before
   // any profiles are created or added to the ProfileManager.  Additionally,
   // IsUserLoggedIn always returns true when we are not running on a Chrome OS
   // device so this check should only run on real devices.
   CHECK(!base::SysInfo::IsRunningOnChromeOS() ||
         !LoginState::Get()->IsUserLoggedIn());
   DCHECK(!g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   g_wake_on_wifi_manager = this;
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_ADDED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   NetworkHandler::Get()
       ->network_device_handler()
       ->RemoveAllWifiWakeOnPacketConnections(
           base::Bind(&base::DoNothing),
           network_handler::ErrorCallback());
 
   if (!switches::WakeOnWifiEnabled())
     return;
+  LOG(WARNING) << "Adding WakeOnWifiManager as PowerManagerClient::Observer.";
+  DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
 
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceStateByType(
           NetworkTypePattern::WiFi());
   if (!device)
     return;
   // Get device properties to check whether wake-on-wifi is supported.
   NetworkHandler::Get()->network_device_handler()->GetDeviceProperties(
       device->path(),
       base::Bind(&WakeOnWifiManager::GetDevicePropertiesCallback,
                  weak_ptr_factory_.GetWeakPtr()),
       network_handler::ErrorCallback());
 }
 
 WakeOnWifiManager::~WakeOnWifiManager() {
   DCHECK(g_wake_on_wifi_manager);
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   g_wake_on_wifi_manager = NULL;
+
+  for (const auto& kv_pair : connection_observers_) {
+    Profile* profile = kv_pair.first;
+    extensions::ExtensionRegistry::Get(profile)->RemoveObserver(this);
+  }
+
+  if (switches::WakeOnWifiEnabled())
+    DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
 }
 
 void WakeOnWifiManager::OnPreferenceChanged(
     WakeOnWifiManager::WakeOnWifiFeature feature) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (current_feature_ == NOT_SUPPORTED)
     return;
   if (!switches::WakeOnWifiEnabled())
     feature = WAKE_ON_NONE;
   if (feature == current_feature_)
@@ skipping 39 matching lines @@
   if (properties.GetString(shill::kWakeOnWiFiFeaturesEnabledProperty,
                            &enabled) &&
       enabled == shill::kWakeOnWiFiFeaturesEnabledNotSupported) {
     current_feature_ = NOT_SUPPORTED;
   }
 }
 
 void WakeOnWifiManager::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
+  using DispatchDetails = extensions::EventRouter::DispatchDetails;
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_ADDED: {
       OnProfileAdded(content::Source<Profile>(source).ptr());
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       OnProfileDestroyed(content::Source<Profile>(source).ptr());
       break;
     }
+    case extensions::NOTIFICATION_EXTENSION_MESSAGE_DISPATCHED: {
+      OnExtensionMessageDispatched(
+          content::Details<DispatchDetails>(details).ptr());
+      break;
+    }
+    case extensions::NOTIFICATION_EXTENSION_MESSAGE_ACKED: {
+      OnExtensionMessageAcked(*(content::Details<int>(details).ptr()));
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
+void WakeOnWifiManager::OnExtensionLoaded(
+    content::BrowserContext* context, const extensions::Extension* extension) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!extension->permissions_data()->HasAPIPermission(
+          extensions::APIPermission::kGcm))
+    return;
+
+  gcm_extensions_.insert(extension->id());
+}
+
+void WakeOnWifiManager::SuspendImminent() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  OnSuspendImminent(false);
+}
+
+void WakeOnWifiManager::SuspendDone(const base::TimeDelta& duration) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  suspend_is_pending_ = false;
+  power_manager_callback_.Reset();
+  suspend_readiness_callback_.Cancel();
+}
+
+void WakeOnWifiManager::DarkSuspendImminent() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  OnSuspendImminent(true);
+}
+
 void WakeOnWifiManager::OnProfileAdded(Profile* profile) {
   // add will do nothing if |profile| already exists in |connection_observers_|.
   auto result = connection_observers_.add(
       profile,
       make_scoped_ptr(
           new WakeOnWifiManager::WakeOnPacketConnectionObserver(profile)));
 
   if (result.second) {
     // This is a profile we haven't seen before.
     gcm::GCMProfileServiceFactory::GetForProfile(profile)
         ->driver()
         ->WakeFromSuspendForHeartbeat(
             IsWakeOnPacketEnabled(current_feature_));
+
+    // The ExtensionRegistry will call OnExtensionLoaded whenever the user
+    // installs and enables a new extension.
+    extensions::ExtensionRegistry::Get(profile)->AddObserver(this);
+
+    // OnExtensionLoaded is not called for extensions that the user had already
+    // installed and enabled.  So we wait until the ExtensionSystem for the
+    // profile is ready and then iterate through the installed extensions,
+    // manually calling OnExtensionLoaded for each of them.
+    extensions::ExtensionSystem::Get(profile)->ready().Post(
+        FROM_HERE,
+        base::Bind(&WakeOnWifiManager::OnExtensionSystemReady,
+                   weak_ptr_factory_.GetWeakPtr(), profile));
+
+    registrar_.Add(this,
+                   extensions::NOTIFICATION_EXTENSION_MESSAGE_DISPATCHED,
+                   content::Source<content::BrowserContext>(profile));
+    registrar_.Add(this,
+                   extensions::NOTIFICATION_EXTENSION_MESSAGE_ACKED,
+                   content::Source<content::BrowserContext>(profile));
   }
 }
 
 void WakeOnWifiManager::OnProfileDestroyed(Profile* profile) {
   connection_observers_.erase(profile);
+
+  extensions::ExtensionRegistry::Get(profile)->RemoveObserver(this);
+  registrar_.Remove(this,
+                    extensions::NOTIFICATION_EXTENSION_MESSAGE_DISPATCHED,
+                    content::Source<content::BrowserContext>(profile));
+  registrar_.Remove(this,
+                    extensions::NOTIFICATION_EXTENSION_MESSAGE_ACKED,
+                    content::Source<content::BrowserContext>(profile));
+}
+
+void WakeOnWifiManager::OnSuspendImminent(bool dark_suspend) {
+  if (suspend_is_pending_) {
+    LOG(WARNING) << "OnSuspendImminent called while previous suspend attempt "
+                 << "is still pending.";
+  }
+
+  suspend_is_pending_ = true;
+  power_manager_callback_ =
+      DBusThreadManager::Get()
+          ->GetPowerManagerClient()
+          ->GetSuspendReadinessCallback();
+
+  suspend_readiness_callback_.Reset(
+      base::Bind(&WakeOnWifiManager::MaybeReportSuspendReadiness,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  base::MessageLoopProxy::current()->PostDelayedTask(
+      FROM_HERE,
+      suspend_readiness_callback_.callback(),
+      dark_suspend ? base::TimeDelta::FromSeconds(1) : base::TimeDelta());
+}
+
+void WakeOnWifiManager::MaybeReportSuspendReadiness() {
+  LOG(WARNING) << "MaybeReportSuspendReadiness. keepalive count = "
+               << unacked_extension_messages_.size();
+  if (!suspend_is_pending_ || unacked_extension_messages_.size() > 0 ||
+      power_manager_callback_.is_null())
+    return;
+
+  suspend_is_pending_ = false;
+  power_manager_callback_.Run();
+  power_manager_callback_.Reset();
+}
+
+void WakeOnWifiManager::OnExtensionMessageDispatched(
+    extensions::EventRouter::DispatchDetails* details) {
+  if (details->event_name_ != extensions::api::gcm::OnMessage::kEventName)
+    return;
+
+  if (gcm_extensions_.find(details->extension_id_) == gcm_extensions_.end())
+    return;
+
+  unacked_extension_messages_.insert(details->message_id_);
+}
+
+void WakeOnWifiManager::OnExtensionMessageAcked(int message_id) {
+  if (unacked_extension_messages_.erase(message_id) > 0)
+    MaybeReportSuspendReadiness();
+}
+
+void WakeOnWifiManager::OnExtensionSystemReady(Profile* profile) {
+  scoped_ptr<extensions::ExtensionSet> installed_set =
+      extensions::ExtensionRegistry::Get(profile)
+          ->GenerateInstalledExtensionsSet();
+
+  for (const auto& extension_refptr : *installed_set) {
+    OnExtensionLoaded(profile, extension_refptr.get());
+  }
 }
 
 }  // namespace chromeos