Extract device_sensors to /device via Mojofication

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 1075 matching lines @@
     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 = 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::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.
       DVLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
                   "unknown type.";
   }
 
   return NULL;
 }
 
 void RendererBlinkPlatformImpl::SetPlatformEventObserverForTesting(
     blink::WebPlatformEventType type,
     scoped_ptr<PlatformEventObserverBase> observer) {
   DCHECK(type != blink::WebPlatformEventBattery);
+  DCHECK(type != blink::WebPlatformEventDeviceMotion);
+  DCHECK(type != blink::WebPlatformEventDeviceOrientation);
+  DCHECK(type != blink::WebPlatformEventDeviceLight);
 
   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) {
+  switch (type) {
+    case blink::WebPlatformEventBattery:
     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;
+    case blink::WebPlatformEventDeviceMotion:
+      device_motion_event_pump_.reset(new DeviceMotionEventPump(
+          static_cast<blink::WebDeviceMotionListener*>(listener)));
+      SendFakeDeviceEventDataForTesting(type);
+      return;
+    case blink::WebPlatformEventDeviceOrientation:
+      device_orientation_event_pump_.reset(new DeviceOrientationEventPump(
+          static_cast<blink::WebDeviceOrientationListener*>(listener)));
+      SendFakeDeviceEventDataForTesting(type);
+      return;
+    case blink::WebPlatformEventDeviceLight:
+      device_light_event_pump_.reset(new DeviceLightEventPump(
+          static_cast<blink::WebDeviceLightListener*>(listener)));
+      SendFakeDeviceEventDataForTesting(type);
+      return;
+    default:
+      break;
   }
 
   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);
+}
 
+void RendererBlinkPlatformImpl::SendFakeDeviceEventDataForTesting(
+    blink::WebPlatformEventType type) {
   // Device events (motion, orientation and light) expect to get an event fired
   // as soon as a listener is registered if a fake data was passed before.
   // TODO(mlamouri,timvolodine): make those send mock values directly instead of
   // using this broken pattern.
-  if (RenderThreadImpl::current() &&
-      RenderThreadImpl::current()->layout_test_mode() &&
-      (type == blink::WebPlatformEventDeviceMotion ||
-       type == blink::WebPlatformEventDeviceOrientation ||
-       type == blink::WebPlatformEventDeviceLight)) {
-    SendFakeDeviceEventDataForTesting(type);
+  if (!RenderThreadImpl::current() ||
+      !RenderThreadImpl::current()->layout_test_mode()) {
+    return;
   }
-}
-
-void RendererBlinkPlatformImpl::SendFakeDeviceEventDataForTesting(
-    blink::WebPlatformEventType type) {
-  PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
-  CHECK(observer);
 
   void* data = 0;
+  DeviceSensorEventPump* event_pump = nullptr;
 
   switch (type) {
   case blink::WebPlatformEventDeviceMotion:
     if (!(g_test_device_motion_data == 0))
       data = &g_test_device_motion_data.Get();
+    event_pump =
+        static_cast<DeviceSensorEventPump*>(device_motion_event_pump_.get());
     break;
   case blink::WebPlatformEventDeviceOrientation:
     if (!(g_test_device_orientation_data == 0))
       data = &g_test_device_orientation_data.Get();
+    event_pump = static_cast<DeviceSensorEventPump*>(
+        device_orientation_event_pump_.get());
     break;
   case blink::WebPlatformEventDeviceLight:
     if (g_test_device_light_data >= 0)
       data = &g_test_device_light_data;
+    event_pump =
+        static_cast<DeviceSensorEventPump*>(device_light_event_pump_.get());
     break;
   default:
     NOTREACHED();
     break;
   }
 
-  if (!data)
+  if (!data || !event_pump)
     return;
 
   base::MessageLoopProxy::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&PlatformEventObserverBase::SendFakeDataForTesting,
-                 base::Unretained(observer), data));
+      FROM_HERE, base::Bind(&DeviceSensorEventPump::SendFakeDataForTesting,
+                            base::Unretained(event_pump), data));
 }
 
 void RendererBlinkPlatformImpl::stopListening(
     blink::WebPlatformEventType type) {
-  if (type == blink::WebPlatformEventBattery) {
-    g_test_battery_status_listener = nullptr;
-    battery_status_dispatcher_.reset();
-    return;
+  switch (type) {
+    case blink::WebPlatformEventBattery:
+      g_test_battery_status_listener = nullptr;
+      battery_status_dispatcher_.reset();
+      return;
+    case blink::WebPlatformEventDeviceMotion:
+      device_motion_event_pump_.reset();
+      return;
+    case blink::WebPlatformEventDeviceOrientation:
+      device_orientation_event_pump_.reset();
+      return;
+    case blink::WebPlatformEventDeviceLight:
+      device_light_event_pump_.reset();
+      return;
+    default:
+      break;
   }
 
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer)
     return;
   observer->Stop();
 }
 
 //------------------------------------------------------------------------------
 
@@ skipping 14 matching lines @@
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::MockBatteryStatusChangedForTesting(
     const blink::WebBatteryStatus& status) {
   if (!g_test_battery_status_listener)
     return;
   g_test_battery_status_listener->updateBatteryStatus(status);
 }
 
 }  // namespace content