Chrome side of converting enums to uppercase.

webkit/glue/plugins/pepper_event_conversion.cc

 // Copyright (c) 2010 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 "webkit/glue/plugins/pepper_event_conversion.h"
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "third_party/ppapi/c/pp_event.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace {
 // Anonymous namespace for functions converting WebInputEvent to PP_Event and
 // back.
 PP_Event_Type ConvertEventTypes(WebInputEvent::Type wetype) {
   switch (wetype) {
     case WebInputEvent::MouseDown:
-      return PP_Event_Type_MouseDown;
+      return PP_EVENT_TYPE_MOUSEDOWN;
     case WebInputEvent::MouseUp:
-      return PP_Event_Type_MouseUp;
+      return PP_EVENT_TYPE_MOUSEUP;
     case WebInputEvent::MouseMove:
-      return PP_Event_Type_MouseMove;
+      return PP_EVENT_TYPE_MOUSEMOVE;
     case WebInputEvent::MouseEnter:
-      return PP_Event_Type_MouseEnter;
+      return PP_EVENT_TYPE_MOUSEENTER;
     case WebInputEvent::MouseLeave:
-      return PP_Event_Type_MouseLeave;
+      return PP_EVENT_TYPE_MOUSELEAVE;
     case WebInputEvent::MouseWheel:
-      return PP_Event_Type_MouseWheel;
+      return PP_EVENT_TYPE_MOUSEWHEEL;
     case WebInputEvent::RawKeyDown:
-      return PP_Event_Type_RawKeyDown;
+      return PP_EVENT_TYPE_RAWKEYDOWN;
     case WebInputEvent::KeyDown:
-      return PP_Event_Type_KeyDown;
+      return PP_EVENT_TYPE_KEYDOWN;
     case WebInputEvent::KeyUp:
-      return PP_Event_Type_KeyUp;
+      return PP_EVENT_TYPE_KEYUP;
     case WebInputEvent::Char:
-      return PP_Event_Type_Char;
+      return PP_EVENT_TYPE_CHAR;
     case WebInputEvent::Undefined:
     default:
-      return PP_Event_Type_Undefined;
+      return PP_EVENT_TYPE_UNDEFINED;
   }
 }
 
 void BuildKeyEvent(const WebInputEvent* event, PP_Event* pp_event) {
   const WebKeyboardEvent* key_event =
       reinterpret_cast<const WebKeyboardEvent*>(event);
   pp_event->u.key.modifier = key_event->modifiers;
   pp_event->u.key.normalizedKeyCode = key_event->windowsKeyCode;
 }
 
@@ skipping 29 matching lines @@
   pp_event->u.wheel.deltaY = mouse_wheel_event->deltaY;
   pp_event->u.wheel.wheelTicksX = mouse_wheel_event->wheelTicksX;
   pp_event->u.wheel.wheelTicksY = mouse_wheel_event->wheelTicksY;
   pp_event->u.wheel.scrollByPage = mouse_wheel_event->scrollByPage;
 }
 
 
 WebKeyboardEvent* BuildKeyEvent(const PP_Event& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   switch (event.type) {
-    case PP_Event_Type_RawKeyDown:
+    case PP_EVENT_TYPE_RAWKEYDOWN:
       key_event->type = WebInputEvent::RawKeyDown;
       break;
-    case PP_Event_Type_KeyDown:
+    case PP_EVENT_TYPE_KEYDOWN:
       key_event->type = WebInputEvent::KeyDown;
       break;
-    case PP_Event_Type_KeyUp:
+    case PP_EVENT_TYPE_KEYUP:
       key_event->type = WebInputEvent::KeyUp;
       break;
   }
   key_event->timeStampSeconds = event.time_stamp_seconds;
   key_event->modifiers = event.u.key.modifier;
   key_event->windowsKeyCode = event.u.key.normalizedKeyCode;
   return key_event;
 }
 
 WebKeyboardEvent* BuildCharEvent(const PP_Event& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   key_event->type = WebInputEvent::Char;
   key_event->timeStampSeconds = event.time_stamp_seconds;
   key_event->modifiers = event.u.character.modifier;
   // For consistency, check that the sizes of the texts agree.
   DCHECK(sizeof(event.u.character.text) == sizeof(key_event->text));
   DCHECK(sizeof(event.u.character.unmodifiedText) ==
          sizeof(key_event->unmodifiedText));
   for (size_t i = 0; i < WebKeyboardEvent::textLengthCap; ++i) {
     key_event->text[i] = event.u.character.text[i];
     key_event->unmodifiedText[i] = event.u.character.unmodifiedText[i];
   }
   return key_event;
 }
 
 WebMouseEvent* BuildMouseEvent(const PP_Event& event) {
   WebMouseEvent* mouse_event = new WebMouseEvent();
   switch (event.type) {
-    case PP_Event_Type_MouseDown:
+    case PP_EVENT_TYPE_MOUSEDOWN:
       mouse_event->type = WebInputEvent::MouseDown;
       break;
-    case PP_Event_Type_MouseUp:
+    case PP_EVENT_TYPE_MOUSEUP:
       mouse_event->type = WebInputEvent::MouseUp;
       break;
-    case PP_Event_Type_MouseMove:
+    case PP_EVENT_TYPE_MOUSEMOVE:
       mouse_event->type = WebInputEvent::MouseMove;
       break;
-    case PP_Event_Type_MouseEnter:
+    case PP_EVENT_TYPE_MOUSEENTER:
       mouse_event->type = WebInputEvent::MouseEnter;
       break;
-    case PP_Event_Type_MouseLeave:
+    case PP_EVENT_TYPE_MOUSELEAVE:
       mouse_event->type = WebInputEvent::MouseLeave;
       break;
   }
   mouse_event->timeStampSeconds = event.time_stamp_seconds;
   mouse_event->modifiers = event.u.mouse.modifier;
   mouse_event->button =
       static_cast<WebMouseEvent::Button>(event.u.mouse.button);
   mouse_event->x = event.u.mouse.x;
   mouse_event->y = event.u.mouse.y;
   mouse_event->clickCount = event.u.mouse.clickCount;
@@ skipping 17 matching lines @@
 
 namespace pepper {
 
 PP_Event* CreatePP_Event(const WebInputEvent& event) {
   scoped_ptr<PP_Event> pp_event(new PP_Event);
 
   pp_event->type = ConvertEventTypes(event.type);
   pp_event->size = sizeof(pp_event);
   pp_event->time_stamp_seconds = event.timeStampSeconds;
   switch (pp_event->type) {
-    case PP_Event_Type_Undefined:
+    case PP_EVENT_TYPE_UNDEFINED:
       return NULL;
-    case PP_Event_Type_MouseDown:
-    case PP_Event_Type_MouseUp:
-    case PP_Event_Type_MouseMove:
-    case PP_Event_Type_MouseEnter:
-    case PP_Event_Type_MouseLeave:
+    case PP_EVENT_TYPE_MOUSEDOWN:
+    case PP_EVENT_TYPE_MOUSEUP:
+    case PP_EVENT_TYPE_MOUSEMOVE:
+    case PP_EVENT_TYPE_MOUSEENTER:
+    case PP_EVENT_TYPE_MOUSELEAVE:
       BuildMouseEvent(&event, pp_event.get());
       break;
-    case PP_Event_Type_MouseWheel:
+    case PP_EVENT_TYPE_MOUSEWHEEL:
       BuildMouseWheelEvent(&event, pp_event.get());
       break;
-    case PP_Event_Type_RawKeyDown:
-    case PP_Event_Type_KeyDown:
-    case PP_Event_Type_KeyUp:
+    case PP_EVENT_TYPE_RAWKEYDOWN:
+    case PP_EVENT_TYPE_KEYDOWN:
+    case PP_EVENT_TYPE_KEYUP:
       BuildKeyEvent(&event, pp_event.get());
       break;
-    case PP_Event_Type_Char:
+    case PP_EVENT_TYPE_CHAR:
       BuildCharEvent(&event, pp_event.get());
       break;
   }
 
   return pp_event.release();
 }
 
 WebInputEvent* CreateWebInputEvent(const PP_Event& event) {
   scoped_ptr<WebInputEvent> web_input_event;
   switch (event.type) {
-    case PP_Event_Type_Undefined:
+    case PP_EVENT_TYPE_UNDEFINED:
       return NULL;
-    case PP_Event_Type_MouseDown:
-    case PP_Event_Type_MouseUp:
-    case PP_Event_Type_MouseMove:
-    case PP_Event_Type_MouseEnter:
-    case PP_Event_Type_MouseLeave:
+    case PP_EVENT_TYPE_MOUSEDOWN:
+    case PP_EVENT_TYPE_MOUSEUP:
+    case PP_EVENT_TYPE_MOUSEMOVE:
+    case PP_EVENT_TYPE_MOUSEENTER:
+    case PP_EVENT_TYPE_MOUSELEAVE:
       web_input_event.reset(BuildMouseEvent(event));
       break;
-    case PP_Event_Type_MouseWheel:
+    case PP_EVENT_TYPE_MOUSEWHEEL:
       web_input_event.reset(BuildMouseWheelEvent(event));
       break;
-    case PP_Event_Type_RawKeyDown:
-    case PP_Event_Type_KeyDown:
-    case PP_Event_Type_KeyUp:
+    case PP_EVENT_TYPE_RAWKEYDOWN:
+    case PP_EVENT_TYPE_KEYDOWN:
+    case PP_EVENT_TYPE_KEYUP:
       web_input_event.reset(BuildKeyEvent(event));
       break;
-    case PP_Event_Type_Char:
+    case PP_EVENT_TYPE_CHAR:
       web_input_event.reset(BuildCharEvent(event));
       break;
-    case PP_Event_Type_Focus:
+    case PP_EVENT_TYPE_FOCUS:
       // NOTIMPLEMENTED();
       return NULL;
   }
 
   return web_input_event.release();
 }
 
 }  // namespace pepper