Migrates battery_status from content/renderer/ to WebKit/platform/

third_party/WebKit/Source/platform/battery/battery_status_dispatcher.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 "content/renderer/battery_status/battery_status_dispatcher.h"
+#include "platform/battery/battery_status_dispatcher.h"
 
-#include "content/public/common/service_registry.h"
-#include "content/public/renderer/render_thread.h"
-#include "third_party/WebKit/public/platform/WebBatteryStatusListener.h"
+#include "platform/base/Bind.h"
+#include "platform/battery/battery_status.h"
+#include "platform/battery/battery_status_listener.h"
+#include "public/platform/Platform.h"
+#include "wtf/Assertions.h"
 
-namespace content {
+namespace blink {
 
-BatteryStatusDispatcher::BatteryStatusDispatcher(
-    blink::WebBatteryStatusListener* listener)
-    : listener_(listener) {
-  DCHECK(listener_);
+BatteryStatusDispatcher::BatteryStatusDispatcher(BatteryStatusListener* listener)

[haraken, 2016/02/09 12:01:21]

Honestly speaking, I want to let modules/ directly talk with Mojo and remove the
BatteryStatusDispatcher. However, if we don't want to go that way for now, at
least I want to make it clearer that the BatteryStatusDispatcher is a "proxy"
for the BatteryDispatcher. Specifically:

- Rename BatteryStatusDispatcher to BatteryDispatcherProxy.

- Make the lifetime of BatteryDispatcher and BatteryDispatcherProxy identical.
The constructor should be renamed to startListening and the destructor should be
renamed to stopListening.

- BatteryDispatcherProxy should take the BatteryDispatcher as an argument,
rather than BatteryStatusListener. The role of the BatteryDispatcherProxy should
be *just proxying* methods between BatteryDispatcher and content/. Make that
logic clearer.

[Yuki, 2016/02/12 12:36:14]

OK
OK
OK
No, platform/battery/BatteryDispatcherProxy cannot depend on
modules/battery/BatteryDispatcher.  The proxy class cannot directly take
BatteryDispatcher as an argument.

Is it okay to keep using BatteryStatusListener for the time being?
If you're okay, I'll address the other two comments above.

[haraken, 2016/02/12 12:48:45]

Ah, got it. Then how about passing a function pointer that invokes
BatteryDispatcher::OnDidChage()? Then the BatteryDispatcher::OnDidChage()
invokes listener_->OnUpdateBatteryStatus(status).

Avoiding the dependency problem by passing BatteryStatusListener sounds like a
kind of hack to me.

+    : listener_(listener)
+{
+  ASSERT(listener_);
 
-  if (ServiceRegistry* registry = RenderThread::Get()->GetServiceRegistry()) {
-    // registry can be null during testing.
-    registry->ConnectToRemoteService(mojo::GetProxy(&monitor_));
+  Platform::current()->connectToRemoteService(mojo::GetProxy(&monitor_));
+  // monitor_ can be null during testing.
+  if (monitor_)
     QueryNextStatus();
-  }
 }
 
-BatteryStatusDispatcher::~BatteryStatusDispatcher() {
+BatteryStatusDispatcher::~BatteryStatusDispatcher() {}
+
+void BatteryStatusDispatcher::QueryNextStatus()
+{
+  monitor_->QueryNextStatus(
+      bindInstanceToMethodForMojo(&BatteryStatusDispatcher::OnDidChange, this));
 }
 
-void BatteryStatusDispatcher::QueryNextStatus() {
-  monitor_->QueryNextStatus(
-      base::Bind(&BatteryStatusDispatcher::DidChange, base::Unretained(this)));
-}
-
-void BatteryStatusDispatcher::DidChange(
-    device::BatteryStatusPtr battery_status) {
+void BatteryStatusDispatcher::OnDidChange(device::BatteryStatusPtr battery_status)
+{
   // monitor_ can be null during testing.
   if (monitor_)
     QueryNextStatus();
 
   DCHECK(battery_status);
 
-  blink::WebBatteryStatus web_battery_status;
-  web_battery_status.charging = battery_status->charging;
-  web_battery_status.chargingTime = battery_status->charging_time;
-  web_battery_status.dischargingTime = battery_status->discharging_time;
-  web_battery_status.level = battery_status->level;
-  listener_->updateBatteryStatus(web_battery_status);
+  BatteryStatus status(battery_status->charging,
+                       battery_status->charging_time,
+                       battery_status->discharging_time,
+                       battery_status->level);
+  listener_->OnUpdateBatteryStatus(status);
 }
 
-}  // namespace content
+} // namespace blink