Rename enums in WebPlatformEventType.h to follow blink style

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/location.h"
@@ skipping 865 matching lines @@
 
 WebBlobRegistry* RendererBlinkPlatformImpl::blobRegistry() {
   // blob_registry_ can be NULL when running some tests.
   return blob_registry_.get();
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::sampleGamepads(WebGamepads& gamepads) {
   PlatformEventObserverBase* observer =
-      platform_event_observers_.Lookup(blink::WebPlatformEventGamepad);
+      platform_event_observers_.Lookup(blink::WebPlatformEventTypeGamepad);
   if (!observer)
     return;
   static_cast<RendererGamepadProvider*>(observer)->SampleGamepads(gamepads);
 }
 
 //------------------------------------------------------------------------------
 
 WebMediaRecorderHandler*
 RendererBlinkPlatformImpl::createMediaRecorderHandler() {
 #if !defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
@@ skipping 224 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:
+    case blink::WebPlatformEventTypeDeviceMotion:
       return new DeviceMotionEventPump(thread);
-    case blink::WebPlatformEventDeviceOrientation:
+    case blink::WebPlatformEventTypeDeviceOrientation:
       return new DeviceOrientationEventPump(thread);
-    case blink::WebPlatformEventDeviceLight:
+    case blink::WebPlatformEventTypeDeviceLight:
       return new DeviceLightEventPump(thread);
-    case blink::WebPlatformEventGamepad:
+    case blink::WebPlatformEventTypeGamepad:
       return new GamepadSharedMemoryReader(thread);
-    case blink::WebPlatformEventScreenOrientation:
+    case blink::WebPlatformEventTypeScreenOrientation:
       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::WebPlatformEventTypeBattery);
 
   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) {
+  if (type == blink::WebPlatformEventTypeBattery) {
     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
   // 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)) {
+      (type == blink::WebPlatformEventTypeDeviceMotion ||
+       type == blink::WebPlatformEventTypeDeviceOrientation ||
+       type == blink::WebPlatformEventTypeDeviceLight)) {
     SendFakeDeviceEventDataForTesting(type);
   }
 }
 
 void RendererBlinkPlatformImpl::SendFakeDeviceEventDataForTesting(
     blink::WebPlatformEventType type) {
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   CHECK(observer);
 
   void* data = 0;
 
   switch (type) {
-  case blink::WebPlatformEventDeviceMotion:
+  case blink::WebPlatformEventTypeDeviceMotion:
     if (!(g_test_device_motion_data == 0))
       data = &g_test_device_motion_data.Get();
     break;
-  case blink::WebPlatformEventDeviceOrientation:
+  case blink::WebPlatformEventTypeDeviceOrientation:
     if (!(g_test_device_orientation_data == 0))
       data = &g_test_device_orientation_data.Get();
     break;
-  case blink::WebPlatformEventDeviceLight:
+  case blink::WebPlatformEventTypeDeviceLight:
     if (g_test_device_light_data >= 0)
       data = &g_test_device_light_data;
     break;
   default:
     NOTREACHED();
     break;
   }
 
   if (!data)
     return;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PlatformEventObserverBase::SendFakeDataForTesting,
                             base::Unretained(observer), data));
 }
 
 void RendererBlinkPlatformImpl::stopListening(
     blink::WebPlatformEventType type) {
-  if (type == blink::WebPlatformEventBattery) {
+  if (type == blink::WebPlatformEventTypeBattery) {
     g_test_battery_status_listener = nullptr;
     battery_status_dispatcher_.reset();
     return;
   }
 
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer)
     return;
   observer->Stop();
 }
@@ skipping 17 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