PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/event_conversion.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/pepper/event_conversion.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/i18n/char_iterator.h"
@@ skipping 25 matching lines @@
 using blink::WebUChar;
 
 namespace content {
 
 namespace {
 
 // Verify the modifier flags WebKit uses match the Pepper ones. If these start
 // not matching, we'll need to write conversion code to preserve the Pepper
 // values (since plugins will be depending on them).
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_SHIFTKEY) ==
-               static_cast<int>(WebInputEvent::ShiftKey),
+                   static_cast<int>(WebInputEvent::ShiftKey),
                ShiftKeyMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_CONTROLKEY) ==
-               static_cast<int>(WebInputEvent::ControlKey),
+                   static_cast<int>(WebInputEvent::ControlKey),
                ControlKeyMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ALTKEY) ==
-               static_cast<int>(WebInputEvent::AltKey),
+                   static_cast<int>(WebInputEvent::AltKey),
                AltKeyMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_METAKEY) ==
-               static_cast<int>(WebInputEvent::MetaKey),
+                   static_cast<int>(WebInputEvent::MetaKey),
                MetaKeyMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISKEYPAD) ==
-               static_cast<int>(WebInputEvent::IsKeyPad),
+                   static_cast<int>(WebInputEvent::IsKeyPad),
                KeyPadMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT) ==
-               static_cast<int>(WebInputEvent::IsAutoRepeat),
+                   static_cast<int>(WebInputEvent::IsAutoRepeat),
                AutoRepeatMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN) ==
-               static_cast<int>(WebInputEvent::LeftButtonDown),
+                   static_cast<int>(WebInputEvent::LeftButtonDown),
                LeftButtonMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN) ==
-               static_cast<int>(WebInputEvent::MiddleButtonDown),
+                   static_cast<int>(WebInputEvent::MiddleButtonDown),
                MiddleButtonMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN) ==
-               static_cast<int>(WebInputEvent::RightButtonDown),
+                   static_cast<int>(WebInputEvent::RightButtonDown),
                RightButtonMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY) ==
-               static_cast<int>(WebInputEvent::CapsLockOn),
+                   static_cast<int>(WebInputEvent::CapsLockOn),
                CapsLockMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_NUMLOCKKEY) ==
-               static_cast<int>(WebInputEvent::NumLockOn),
+                   static_cast<int>(WebInputEvent::NumLockOn),
                NumLockMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISLEFT) ==
-               static_cast<int>(WebInputEvent::IsLeft),
+                   static_cast<int>(WebInputEvent::IsLeft),
                LeftMatches);
 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISRIGHT) ==
-               static_cast<int>(WebInputEvent::IsRight),
+                   static_cast<int>(WebInputEvent::IsRight),
                RightMatches);
 
 PP_InputEvent_Type ConvertEventTypes(WebInputEvent::Type wetype) {
   switch (wetype) {
     case WebInputEvent::MouseDown:
       return PP_INPUTEVENT_TYPE_MOUSEDOWN;
     case WebInputEvent::MouseUp:
       return PP_INPUTEVENT_TYPE_MOUSEUP;
     case WebInputEvent::MouseMove:
       return PP_INPUTEVENT_TYPE_MOUSEMOVE;
@@ skipping 72 matching lines @@
     base::WriteUnicodeCharacter(iter.get(), &result.character_text);
 
     result_events->push_back(result);
     iter.Advance();
   }
 }
 
 void AppendMouseEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonNone) ==
-                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
+                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
                  MouseNone);
   COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonLeft) ==
-                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
+                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
                  MouseLeft);
   COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonRight) ==
-                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
+                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
                  MouseRight);
   COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonMiddle) ==
-                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
+                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
                  MouseMiddle);
 
-  const WebMouseEvent& mouse_event =
-      static_cast<const WebMouseEvent&>(event);
+  const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = mouse_event.modifiers;
   if (mouse_event.type == WebInputEvent::MouseDown ||
       mouse_event.type == WebInputEvent::MouseMove ||
       mouse_event.type == WebInputEvent::MouseUp) {
     result.mouse_button =
         static_cast<PP_InputEvent_MouseButton>(mouse_event.button);
   }
   result.mouse_position.x = mouse_event.x;
   result.mouse_position.y = mouse_event.y;
@@ skipping 10 matching lines @@
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = mouse_wheel_event.modifiers;
   result.wheel_delta.x = mouse_wheel_event.deltaX;
   result.wheel_delta.y = mouse_wheel_event.deltaY;
   result.wheel_ticks.x = mouse_wheel_event.wheelTicksX;
   result.wheel_ticks.y = mouse_wheel_event.wheelTicksY;
   result.wheel_scroll_by_page = !!mouse_wheel_event.scrollByPage;
   result_events->push_back(result);
 }
 
-void SetPPTouchPoints(const WebTouchPoint* touches, uint32_t touches_length,
+void SetPPTouchPoints(const WebTouchPoint* touches,
+                      uint32_t touches_length,
                       std::vector<PP_TouchPoint>* result) {
   for (uint32_t i = 0; i < touches_length; i++) {
     const WebTouchPoint& touch_point = touches[i];
     PP_TouchPoint pp_pt;
     pp_pt.id = touch_point.id;
     pp_pt.position.x = touch_point.position.x;
     pp_pt.position.y = touch_point.position.y;
     pp_pt.radius.x = touch_point.radiusX;
     pp_pt.radius.y = touch_point.radiusY;
     pp_pt.rotation_angle = touch_point.rotationAngle;
     pp_pt.pressure = touch_point.force;
     result->push_back(pp_pt);
   }
 }
 
 void AppendTouchEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   const WebTouchEvent& touch_event =
       reinterpret_cast<const WebTouchEvent&>(event);
 
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  SetPPTouchPoints(touch_event.touches, touch_event.touchesLength,
-                   &result.touches);
-  SetPPTouchPoints(touch_event.changedTouches, touch_event.changedTouchesLength,
+  SetPPTouchPoints(
+      touch_event.touches, touch_event.touchesLength, &result.touches);
+  SetPPTouchPoints(touch_event.changedTouches,
+                   touch_event.changedTouchesLength,
                    &result.changed_touches);
-  SetPPTouchPoints(touch_event.targetTouches, touch_event.targetTouchesLength,
+  SetPPTouchPoints(touch_event.targetTouches,
+                   touch_event.targetTouchesLength,
                    &result.target_touches);
 
   result_events->push_back(result);
 }
 
 // Structure used to map touch point id's to touch states.  Since the pepper
 // touch event structure does not have states for individual touch points and
 // instead relies on the event type in combination with the set of touch lists,
 // we have to set the state for the changed touches to be the same as the event
 // type and all others to be 'stationary.'
 typedef std::map<uint32_t, WebTouchPoint::State> TouchStateMap;
 
 void SetWebTouchPoints(const std::vector<PP_TouchPoint>& pp_touches,
                        const TouchStateMap& states_map,
                        WebTouchPoint* web_touches,
                        uint32_t* web_touches_length) {
 
-  for (uint32_t i = 0; i < pp_touches.size() &&
-       i < WebTouchEvent::touchesLengthCap; i++) {
+  for (uint32_t i = 0;
+       i < pp_touches.size() && i < WebTouchEvent::touchesLengthCap;
+       i++) {
     WebTouchPoint pt;
     const PP_TouchPoint& pp_pt = pp_touches[i];
     pt.id = pp_pt.id;
 
     if (states_map.find(pt.id) == states_map.end())
       pt.state = WebTouchPoint::StateStationary;
     else
       pt.state = states_map.find(pt.id)->second;
 
     pt.position.x = pp_pt.position.x;
@@ skipping 33 matching lines @@
     default:
       NOTREACHED();
   }
 
   TouchStateMap states_map;
   for (uint32_t i = 0; i < event.changed_touches.size(); i++)
     states_map[event.changed_touches[i].id] = state;
 
   web_event->timeStampSeconds = PPTimeTicksToEventTime(event.event_time_stamp);
 
-  SetWebTouchPoints(event.changed_touches, states_map,
+  SetWebTouchPoints(event.changed_touches,
+                    states_map,
                     web_event->changedTouches,
                     &web_event->changedTouchesLength);
 
-  SetWebTouchPoints(event.touches, states_map, web_event->touches,
-                    &web_event->touchesLength);
+  SetWebTouchPoints(
+      event.touches, states_map, web_event->touches, &web_event->touchesLength);
 
-  SetWebTouchPoints(event.target_touches, states_map, web_event->targetTouches,
+  SetWebTouchPoints(event.target_touches,
+                    states_map,
+                    web_event->targetTouches,
                     &web_event->targetTouchesLength);
 
   if (web_event->type == WebInputEvent::TouchEnd ||
       web_event->type == WebInputEvent::TouchCancel) {
-    SetWebTouchPoints(event.changed_touches, states_map,
-                      web_event->touches, &web_event->touchesLength);
-    SetWebTouchPoints(event.changed_touches, states_map,
+    SetWebTouchPoints(event.changed_touches,
+                      states_map,
+                      web_event->touches,
+                      &web_event->touchesLength);
+    SetWebTouchPoints(event.changed_touches,
+                      states_map,
                       web_event->targetTouches,
                       &web_event->targetTouchesLength);
   }
 
   return web_event;
 }
 
 WebKeyboardEvent* BuildKeyEvent(const InputEventData& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   switch (event.event_type) {
@@ skipping 22 matching lines @@
   key_event->timeStampSeconds = PPTimeTicksToEventTime(event.event_time_stamp);
   key_event->modifiers = event.event_modifiers;
 
   // Make sure to not read beyond the buffer in case some bad code doesn't
   // NULL-terminate it (this is called from plugins).
   size_t text_length_cap = WebKeyboardEvent::textLengthCap;
   base::string16 text16 = base::UTF8ToUTF16(event.character_text);
 
   memset(key_event->text, 0, text_length_cap);
   memset(key_event->unmodifiedText, 0, text_length_cap);
-  for (size_t i = 0;
-       i < std::min(text_length_cap, text16.size());
-       ++i)
+  for (size_t i = 0; i < std::min(text_length_cap, text16.size()); ++i)
     key_event->text[i] = text16[i];
   return key_event;
 }
 
 WebMouseEvent* BuildMouseEvent(const InputEventData& event) {
   WebMouseEvent* mouse_event = new WebMouseEvent();
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
       mouse_event->type = WebInputEvent::MouseDown;
       break;
@@ skipping 11 matching lines @@
       break;
     case PP_INPUTEVENT_TYPE_CONTEXTMENU:
       mouse_event->type = WebInputEvent::ContextMenu;
       break;
     default:
       NOTREACHED();
   }
   mouse_event->timeStampSeconds =
       PPTimeTicksToEventTime(event.event_time_stamp);
   mouse_event->modifiers = event.event_modifiers;
-  mouse_event->button =
-      static_cast<WebMouseEvent::Button>(event.mouse_button);
+  mouse_event->button = static_cast<WebMouseEvent::Button>(event.mouse_button);
   if (mouse_event->type == WebInputEvent::MouseMove) {
     if (mouse_event->modifiers & WebInputEvent::LeftButtonDown)
       mouse_event->button = WebMouseEvent::ButtonLeft;
     else if (mouse_event->modifiers & WebInputEvent::MiddleButtonDown)
       mouse_event->button = WebMouseEvent::ButtonMiddle;
     else if (mouse_event->modifiers & WebInputEvent::RightButtonDown)
       mouse_event->button = WebMouseEvent::ButtonRight;
   }
   mouse_event->x = event.mouse_position.x;
   mouse_event->y = event.mouse_position.y;
@@ skipping 11 matching lines @@
   mouse_wheel_event->modifiers = event.event_modifiers;
   mouse_wheel_event->deltaX = event.wheel_delta.x;
   mouse_wheel_event->deltaY = event.wheel_delta.y;
   mouse_wheel_event->wheelTicksX = event.wheel_ticks.x;
   mouse_wheel_event->wheelTicksY = event.wheel_ticks.y;
   mouse_wheel_event->scrollByPage = event.wheel_scroll_by_page;
   return mouse_wheel_event;
 }
 
 #if !defined(OS_WIN)
-#define VK_RETURN         0x0D
+#define VK_RETURN 0x0D
 
-#define VK_PRIOR          0x21
-#define VK_NEXT           0x22
-#define VK_END            0x23
-#define VK_HOME           0x24
-#define VK_LEFT           0x25
-#define VK_UP             0x26
-#define VK_RIGHT          0x27
-#define VK_DOWN           0x28
-#define VK_SNAPSHOT       0x2C
-#define VK_INSERT         0x2D
-#define VK_DELETE         0x2E
+#define VK_PRIOR 0x21
+#define VK_NEXT 0x22
+#define VK_END 0x23
+#define VK_HOME 0x24
+#define VK_LEFT 0x25
+#define VK_UP 0x26
+#define VK_RIGHT 0x27
+#define VK_DOWN 0x28
+#define VK_SNAPSHOT 0x2C
+#define VK_INSERT 0x2D
+#define VK_DELETE 0x2E
 
-#define VK_APPS           0x5D
+#define VK_APPS 0x5D
 
-#define VK_F1             0x70
+#define VK_F1 0x70
 #endif
 
 // Convert a character string to a Windows virtual key code. Adapted from
 // src/content/shell/renderer/test_runner/event_sender.cc. This
 // is used by CreateSimulatedWebInputEvents to convert keyboard events.
 void GetKeyCode(const std::string& char_text,
                 WebUChar* code,
                 WebUChar* text,
                 bool* needs_shift_modifier,
                 bool* generate_char) {
@@ skipping 39 matching lines @@
       }
     }
     if (!vk_code) {
       WebString web_char_text =
           WebString::fromUTF8(char_text.data(), char_text.size());
       DCHECK_EQ(web_char_text.length(), 1U);
       vk_text = vk_code = web_char_text.at(0);
       *needs_shift_modifier =
           (vk_code & 0xFF) >= 'A' && (vk_code & 0xFF) <= 'Z';
       if ((vk_code & 0xFF) >= 'a' && (vk_code & 0xFF) <= 'z')
-          vk_code -= 'a' - 'A';
+        vk_code -= 'a' - 'A';
       *generate_char = true;
     }
   }
 
   *code = vk_code;
   *text = vk_text;
 }
 
 }  // namespace
 
@@ skipping 103 matching lines @@
           static_cast<WebMouseWheelEvent*>(original_event.get());
       web_mouse_wheel_event->x = plugin_x;
       web_mouse_wheel_event->y = plugin_y;
       events.push_back(original_event);
       break;
     }
 
     case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYUP: {
-      // Windows key down events should always be "raw" to avoid an ASSERT.
+// Windows key down events should always be "raw" to avoid an ASSERT.
 #if defined(OS_WIN)
       WebKeyboardEvent* web_keyboard_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
       if (web_keyboard_event->type == WebInputEvent::KeyDown)
         web_keyboard_event->type = WebInputEvent::RawKeyDown;
 #endif
       events.push_back(original_event);
       break;
     }
 
@@ skipping 70 matching lines @@
     case WebInputEvent::TouchStart:
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::Undefined:
     default:
       NOTREACHED();
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content