Reland "Replace Chrome IPC with Mojo IPC for querying BatteryStatus service"

content/renderer/renderer_blink_platform_impl.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 "content/renderer/renderer_blink_platform_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 133 matching lines @@
 namespace content {
 
 namespace {
 
 bool g_sandbox_enabled = true;
 double g_test_device_light_data = -1;
 base::LazyInstance<blink::WebDeviceMotionData>::Leaky
     g_test_device_motion_data = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<blink::WebDeviceOrientationData>::Leaky
     g_test_device_orientation_data = LAZY_INSTANCE_INITIALIZER;
+// Set in startListening() when running layout tests, unset in stopListening(),
+// not owned by us.
+blink::WebBatteryStatusListener* g_test_battery_status_listener = nullptr;

[timvolodine, 2014/10/28 18:59:28]

i think this is approximately how it used to be implemented before
https://codereview.chromium.org/446603002/.

[ppi, 2014/10/28 19:24:34]

Acknowledged.

 
 } // namespace
 
 //------------------------------------------------------------------------------
 
 class RendererBlinkPlatformImpl::MimeRegistry
     : public SimpleWebMimeRegistryImpl {
  public:
   virtual blink::WebMimeRegistry::SupportsType supportsMediaMIMEType(
       const blink::WebString& mime_type,
@@ skipping 874 matching lines @@
 // static
 PlatformEventObserverBase*
 RendererBlinkPlatformImpl::CreatePlatformEventObserverFromType(
     blink::WebPlatformEventType type) {
   RenderThread* thread = RenderThreadImpl::current();
 
   // When running layout tests, those observers should not listen to the actual
   // hardware changes. In order to make that happen, they will receive a null
   // thread.
   if (thread && RenderThreadImpl::current()->layout_test_mode())
-    thread = 0;
+    thread = NULL;
 
   switch (type) {
-  case blink::WebPlatformEventDeviceMotion: {
-    return new DeviceMotionEventPump(thread);
-  }
-  case blink::WebPlatformEventDeviceOrientation: {
-    return new DeviceOrientationEventPump(thread);
-  }
-  case blink::WebPlatformEventDeviceLight: {
-    return new DeviceLightEventPump(thread);
-  }
-  case blink::WebPlatformEventBattery: {
-    return new BatteryStatusDispatcher(thread);
-  }
-  case blink::WebPlatformEventGamepad:
-    return new GamepadSharedMemoryReader(thread);
-    break;
-  case blink::WebPlatformEventScreenOrientation:
-    return new ScreenOrientationObserver();
-  default:
-    // A default statement is required to prevent compilation errors when Blink
-    // adds a new type.
-    VLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
-               "unknown type.";
+    case blink::WebPlatformEventDeviceMotion:
+      return new DeviceMotionEventPump(thread);
+    case blink::WebPlatformEventDeviceOrientation:
+      return new DeviceOrientationEventPump(thread);
+    case blink::WebPlatformEventDeviceLight:
+      return new DeviceLightEventPump(thread);
+    case blink::WebPlatformEventGamepad:
+      return new GamepadSharedMemoryReader(thread);
+    case blink::WebPlatformEventScreenOrientation:
+      return new ScreenOrientationObserver();
+    default:
+      // A default statement is required to prevent compilation errors when
+      // Blink adds a new type.
+      VLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
+                 "unknown type.";
   }
 
-  return 0;
+  return NULL;
 }
 
 void RendererBlinkPlatformImpl::SetPlatformEventObserverForTesting(
     blink::WebPlatformEventType type,
     scoped_ptr<PlatformEventObserverBase> observer) {
+  DCHECK(type != blink::WebPlatformEventBattery);
+
   if (platform_event_observers_.Lookup(type))
     platform_event_observers_.Remove(type);
   platform_event_observers_.AddWithID(observer.release(), type);
 }
 
 void RendererBlinkPlatformImpl::startListening(
     blink::WebPlatformEventType type,
     blink::WebPlatformEventListener* listener) {
+  if (type == blink::WebPlatformEventBattery) {

[timvolodine, 2014/10/28 18:59:28]

this doesn't look like it will generalize very well, but for now I think it's
fine because other API are not using mojo (yet).

[ppi, 2014/10/28 19:24:34]

Ack. Let's figure something more general out once we need to add a second case
like this one.

+    if (RenderThreadImpl::current() &&
+        RenderThreadImpl::current()->layout_test_mode()) {
+      g_test_battery_status_listener =
+          static_cast<blink::WebBatteryStatusListener*>(listener);
+    } else {
+      battery_status_dispatcher_.reset(new BatteryStatusDispatcher(
+          static_cast<blink::WebBatteryStatusListener*>(listener)));
+    }
+    return;
+  }
+
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer) {
     observer = CreatePlatformEventObserverFromType(type);
     if (!observer)
       return;
     platform_event_observers_.AddWithID(observer, static_cast<int32>(type));
   }
   observer->Start(listener);
 
   // Device events (motion, orientation and light) expect to get an event fired
@@ skipping 38 matching lines @@
     return;
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&PlatformEventObserverBase::SendFakeDataForTesting,
                  base::Unretained(observer), data));
 }
 
 void RendererBlinkPlatformImpl::stopListening(
     blink::WebPlatformEventType type) {
+  if (type == blink::WebPlatformEventBattery) {
+    g_test_battery_status_listener = nullptr;
+    battery_status_dispatcher_.reset();
+    return;
+  }
+
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer)
     return;
   observer->Stop();
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::queryStorageUsageAndQuota(
     const blink::WebURL& storage_partition,
     blink::WebStorageQuotaType type,
     blink::WebStorageQuotaCallbacks callbacks) {
   if (!thread_safe_sender_.get() || !quota_message_filter_.get())
     return;
   QuotaDispatcher::ThreadSpecificInstance(thread_safe_sender_.get(),
                                           quota_message_filter_.get())
       ->QueryStorageUsageAndQuota(
           storage_partition,
           static_cast<storage::StorageType>(type),
           QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::MockBatteryStatusChangedForTesting(
     const blink::WebBatteryStatus& status) {
-  PlatformEventObserverBase* observer =
-      platform_event_observers_.Lookup(blink::WebPlatformEventBattery);
-  if (!observer)
+  if (!g_test_battery_status_listener)
     return;
-  observer->SendFakeDataForTesting((void*)&status);
+  g_test_battery_status_listener->updateBatteryStatus(
+      *static_cast<const blink::WebBatteryStatus*>(&status));

[timvolodine, 2014/10/28 18:59:28]

do you really need a static_cast here?

[ppi, 2014/10/28 19:24:34]

Done.

 }
 
 }  // namespace content