Add Dispatcher class to the Battery Status API module.

Source/modules/battery/BatteryManager.cpp

 // 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 "config.h"
 #include "modules/battery/BatteryManager.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "core/events/Event.h"
+#include "modules/battery/BatteryDispatcher.h"
 #include "modules/battery/BatteryStatus.h"
 #include <limits>
 
 namespace WebCore {
 
 PassRefPtrWillBeRawPtr<BatteryManager> BatteryManager::create(ExecutionContext* context)
 {
-    return adoptRefWillBeRefCountedGarbageCollected(new BatteryManager(context));
+    RefPtr<BatteryManager> batteryManager(adoptRefWillBeRefCountedGarbageCollected(new BatteryManager(context)));

[sof, 2014/04/07 12:52:44]

Use RefPtrWillBeRawPtr<> instead of RefPtr<>.

+    batteryManager->suspendIfNeeded();
+    return batteryManager.release();
 }
 
 BatteryManager::~BatteryManager()
 {

[timvolodine, 2014/04/02 14:24:51]

we probably want to unregister here by calling stopUpdating()

 }
 
 BatteryManager::BatteryManager(ExecutionContext* context)
-    : ContextLifecycleObserver(context)
+    : ActiveDOMObject(context)
+    , DeviceSensorEventController(*toDocument(context))
     , m_batteryStatus(nullptr)
 {
+    // Need to figure out a way to startUpdating only afters EventListeners are added: didAddEventListener?
+    m_hasEventListener = true;
+    startUpdating();

[timvolodine, 2014/04/02 14:24:51]

yeah this is a bit tricky. Think it's generally ok to start updating here, but
note that BatteryManager::level() will not necessarily have m_batteryStatus
updated, because the startUpdating is async. The current implementation might be
ok for as a short term solution, but we need some mechanism to have a sync
fetch.
Taking Battery::level() as example, I think we could have something like
BatteryDispatcher::instance.sampleData(WebBatteryStatus&) in case no local
m_batteryStatus is available. wdyt?

[Srini, 2014/04/02 17:25:36]

The spec mentions a default value when the battery status isn't available. I
have made them the default values here, just before they are fetched/updated.
IMO this should be sufficient in that small interval.

 }
 
 bool BatteryManager::charging()
 {
     return m_batteryStatus ? m_batteryStatus->charging() : true;
 }
 
 double BatteryManager::chargingTime()
 {
     if (!m_batteryStatus || !m_batteryStatus->charging())
         return std::numeric_limits<double>::infinity();
 
     return m_batteryStatus->chargingTime();
 }
 
 double BatteryManager::dischargingTime()
 {
     if (!m_batteryStatus || m_batteryStatus->charging())
         return std::numeric_limits<double>::infinity();
 
     return m_batteryStatus->dischargingTime();
 }
 
 double BatteryManager::level()
 {
     return m_batteryStatus ? m_batteryStatus->level() : 1;

[timvolodine, 2014/04/03 13:48:16]

Also batteryStatus appears to be stored twice in both the dispatcher and the
manager. I think we should avoid this by removing m_batteryStatus from the
BatteryManager and simply delegate calls like BatteryManagers::level() to
BatteryDispatcher:
{
  if (BatteryStatus* lastData = BatteryDispatcher::instance::getLatestData()){
    return lastData->level();
  }
  return 1;
}
this would likely simplify the code a bit.
Also we need a one-shot callback upon first registration if last data is
available. Simply providing hasLastData() and getLastEvent() in BatteryManager
would solve that issue. You can have a look at
DeviceOrientationDispatcher/Controller for reference.

 }
 
-void BatteryManager::didChangeBatteryStatus(PassRefPtr<Event> event, PassOwnPtr<BatteryStatus> batteryStatus)
+void BatteryManager::didChangeBatteryStatus(PassRefPtr<Event> event, PassRefPtr<BatteryStatus> batteryStatus)

[sof, 2014/04/07 12:52:44]

Change PassRefPtr<Event> to PassRefPtrWillBeRawPtr<Event> here also.

 {
     ASSERT(RuntimeEnabledFeatures::batteryStatusEnabled());
 
     m_batteryStatus = batteryStatus;
     dispatchEvent(event);
 }
 
+void BatteryManager::registerWithDispatcher()
+{
+    BatteryDispatcher::instance().addClient(this);
+}
+
+void BatteryManager::unregisterWithDispatcher()
+{
+    BatteryDispatcher::instance().removeClient(this);
+}
+
+bool BatteryManager::hasLastData()
+{
+    /* Battery Manager sends the event itself */
+    return false;
+}
+
+PassRefPtr<Event> BatteryManager::getLastEvent()

[sof, 2014/04/07 12:52:44]

Change this to PassRefPtrWillBeRawPtr<Event>

+{
+    // This is called only when hasLastData() is true.
+    ASSERT_NOT_REACHED();
+    return nullptr;
+}
+
+bool BatteryManager::isNullEvent(Event*)
+{
+    // This is called only when hasLastData() is true.
+    ASSERT_NOT_REACHED();
+    return false;
+}
+
+void BatteryManager::suspend()
+{
+    stopUpdating();
+}
+
+void BatteryManager::resume()
+{
+    startUpdating();
+}
+
+void BatteryManager::stop()
+{
+    stopUpdating();
+}
+
 } // namespace WebCore