PPAPI: Format ppapi/thunk using clang-format.

ppapi/thunk/ppb_input_event_thunk.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 "ppapi/c/pp_errors.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_input_event_api.h"
 #include "ppapi/thunk/ppb_instance_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
@@ skipping 18 matching lines @@
 int32_t RequestFilteringInputEvents(PP_Instance instance,
                                     uint32_t event_classes) {
   VLOG(4) << "PPB_InputEvent::RequestFilteringInputEvents()";
   EnterInstance enter(instance);
   if (enter.failed())
     return enter.retval();
   return enter.functions()->RequestFilteringInputEvents(instance,
                                                         event_classes);
 }
 
-void ClearInputEventRequest(PP_Instance instance,
-                            uint32_t event_classes) {
+void ClearInputEventRequest(PP_Instance instance, uint32_t event_classes) {
   VLOG(4) << "PPB_InputEvent::ClearInputEventRequest()";
   EnterInstance enter(instance);
   if (enter.succeeded())
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
 PP_Bool IsInputEvent(PP_Resource resource) {
   VLOG(4) << "PPB_InputEvent::IsInputEvent()";
   EnterInputEvent enter(resource, false);
   return enter.succeeded() ? PP_TRUE : PP_FALSE;
@@ skipping 17 matching lines @@
 
 uint32_t GetModifiers(PP_Resource event) {
   VLOG(4) << "PPB_InputEvent::GetModifiers()";
   EnterInputEvent enter(event, true);
   if (enter.failed())
     return 0;
   return enter.object()->GetModifiers();
 }
 
 const PPB_InputEvent g_ppb_input_event_thunk = {
-  &RequestInputEvents,
-  &RequestFilteringInputEvents,
-  &ClearInputEventRequest,
-  &IsInputEvent,
-  &GetType,
-  &GetTimeStamp,
-  &GetModifiers
-};
+    &RequestInputEvents, &RequestFilteringInputEvents, &ClearInputEventRequest,
+    &IsInputEvent,       &GetType,                     &GetTimeStamp,
+    &GetModifiers};
 
 // Mouse -----------------------------------------------------------------------
 
 PP_Resource CreateMouseInputEvent1_0(PP_Instance instance,
                                      PP_InputEvent_Type type,
                                      PP_TimeTicks time_stamp,
                                      uint32_t modifiers,
                                      PP_InputEvent_MouseButton mouse_button,
                                      const PP_Point* mouse_position,
                                      int32_t click_count) {
   VLOG(4) << "PPB_MouseInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
 
   PP_Point mouse_movement = PP_MakePoint(0, 0);
-  return enter.functions()->CreateMouseInputEvent(instance, type, time_stamp,
-                                                  modifiers, mouse_button,
-                                                  mouse_position, click_count,
+  return enter.functions()->CreateMouseInputEvent(instance,
+                                                  type,
+                                                  time_stamp,
+                                                  modifiers,
+                                                  mouse_button,
+                                                  mouse_position,
+                                                  click_count,
                                                   &mouse_movement);
 }
 
 PP_Resource CreateMouseInputEvent1_1(PP_Instance instance,
                                      PP_InputEvent_Type type,
                                      PP_TimeTicks time_stamp,
                                      uint32_t modifiers,
                                      PP_InputEvent_MouseButton mouse_button,
                                      const PP_Point* mouse_position,
                                      int32_t click_count,
                                      const PP_Point* mouse_movement) {
   VLOG(4) << "PPB_MouseInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateMouseInputEvent(instance, type, time_stamp,
-                                                  modifiers, mouse_button,
-                                                  mouse_position, click_count,
+  return enter.functions()->CreateMouseInputEvent(instance,
+                                                  type,
+                                                  time_stamp,
+                                                  modifiers,
+                                                  mouse_button,
+                                                  mouse_position,
+                                                  click_count,
                                                   mouse_movement);
 }
 
 PP_Bool IsMouseInputEvent(PP_Resource resource) {
   VLOG(4) << "PPB_MouseInputEvent::IsMouseInputEvent()";
   if (!IsInputEvent(resource))
     return PP_FALSE;  // Prevent warning log in GetType.
   PP_InputEvent_Type type = GetType(resource);
   return PP_FromBool(type == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
                      type == PP_INPUTEVENT_TYPE_MOUSEUP ||
@@ skipping 29 matching lines @@
 
 PP_Point GetMouseMovement(PP_Resource mouse_event) {
   VLOG(4) << "PPB_MouseInputEvent::GetMovement()";
   EnterInputEvent enter(mouse_event, true);
   if (enter.failed())
     return PP_MakePoint(0, 0);
   return enter.object()->GetMouseMovement();
 }
 
 const PPB_MouseInputEvent_1_0 g_ppb_mouse_input_event_1_0_thunk = {
-  &CreateMouseInputEvent1_0,
-  &IsMouseInputEvent,
-  &GetMouseButton,
-  &GetMousePosition,
-  &GetMouseClickCount
-};
+    &CreateMouseInputEvent1_0, &IsMouseInputEvent, &GetMouseButton,
+    &GetMousePosition, &GetMouseClickCount};
 
 const PPB_MouseInputEvent g_ppb_mouse_input_event_1_1_thunk = {
-  &CreateMouseInputEvent1_1,
-  &IsMouseInputEvent,
-  &GetMouseButton,
-  &GetMousePosition,
-  &GetMouseClickCount,
-  &GetMouseMovement
-};
+    &CreateMouseInputEvent1_1, &IsMouseInputEvent,  &GetMouseButton,
+    &GetMousePosition,         &GetMouseClickCount, &GetMouseMovement};
 
 // Wheel -----------------------------------------------------------------------
 
 PP_Resource CreateWheelInputEvent(PP_Instance instance,
                                   PP_TimeTicks time_stamp,
                                   uint32_t modifiers,
                                   const PP_FloatPoint* wheel_delta,
                                   const PP_FloatPoint* wheel_ticks,
                                   PP_Bool scroll_by_page) {
   VLOG(4) << "PPB_WheelInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateWheelInputEvent(instance, time_stamp,
-                                                  modifiers, wheel_delta,
-                                                  wheel_ticks, scroll_by_page);
+  return enter.functions()->CreateWheelInputEvent(instance,
+                                                  time_stamp,
+                                                  modifiers,
+                                                  wheel_delta,
+                                                  wheel_ticks,
+                                                  scroll_by_page);
 }
 
 PP_Bool IsWheelInputEvent(PP_Resource resource) {
   VLOG(4) << "PPB_WheelInputEvent::IsWheelInputEvent()";
   if (!IsInputEvent(resource))
     return PP_FALSE;  // Prevent warning log in GetType.
   PP_InputEvent_Type type = GetType(resource);
   return PP_FromBool(type == PP_INPUTEVENT_TYPE_WHEEL);
 }
 
@@ skipping 15 matching lines @@
 
 PP_Bool GetWheelScrollByPage(PP_Resource wheel_event) {
   VLOG(4) << "PPB_WheelInputEvent::GetScrollByPage()";
   EnterInputEvent enter(wheel_event, true);
   if (enter.failed())
     return PP_FALSE;
   return enter.object()->GetWheelScrollByPage();
 }
 
 const PPB_WheelInputEvent g_ppb_wheel_input_event_thunk = {
-  &CreateWheelInputEvent,
-  &IsWheelInputEvent,
-  &GetWheelDelta,
-  &GetWheelTicks,
-  &GetWheelScrollByPage
-};
+    &CreateWheelInputEvent, &IsWheelInputEvent, &GetWheelDelta, &GetWheelTicks,
+    &GetWheelScrollByPage};
 
 // Keyboard --------------------------------------------------------------------
 
 PP_Resource CreateKeyboardInputEvent_1_0(PP_Instance instance,
                                          PP_InputEvent_Type type,
                                          PP_TimeTicks time_stamp,
                                          uint32_t modifiers,
                                          uint32_t key_code,
                                          struct PP_Var character_text) {
   VLOG(4) << "PPB_KeyboardInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateKeyboardInputEvent_1_0(instance, type,
-                                                         time_stamp,
-                                                         modifiers, key_code,
-                                                         character_text);
+  return enter.functions()->CreateKeyboardInputEvent_1_0(
+      instance, type, time_stamp, modifiers, key_code, character_text);
 }
 
 PP_Resource CreateKeyboardInputEvent_1_2(PP_Instance instance,
                                          PP_InputEvent_Type type,
                                          PP_TimeTicks time_stamp,
                                          uint32_t modifiers,
                                          uint32_t key_code,
                                          struct PP_Var character_text,
                                          struct PP_Var code) {
   VLOG(4) << "PPB_KeyboardInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateKeyboardInputEvent_1_2(instance, type,
-                                                         time_stamp,
-                                                         modifiers, key_code,
-                                                         character_text, code);
+  return enter.functions()->CreateKeyboardInputEvent_1_2(
+      instance, type, time_stamp, modifiers, key_code, character_text, code);
 }
 
 PP_Bool IsKeyboardInputEvent(PP_Resource resource) {
   VLOG(4) << "PPB_KeyboardInputEvent::IsKeyboardInputEvent()";
   if (!IsInputEvent(resource))
     return PP_FALSE;  // Prevent warning log in GetType.
   PP_InputEvent_Type type = GetType(resource);
-  return PP_FromBool(type == PP_INPUTEVENT_TYPE_KEYDOWN ||
-                     type == PP_INPUTEVENT_TYPE_KEYUP ||
-                     type == PP_INPUTEVENT_TYPE_RAWKEYDOWN ||
-                     type == PP_INPUTEVENT_TYPE_CHAR);
+  return PP_FromBool(
+      type == PP_INPUTEVENT_TYPE_KEYDOWN || type == PP_INPUTEVENT_TYPE_KEYUP ||
+      type == PP_INPUTEVENT_TYPE_RAWKEYDOWN || type == PP_INPUTEVENT_TYPE_CHAR);
 }
 
 uint32_t GetKeyCode(PP_Resource key_event) {
   VLOG(4) << "PPB_KeyboardInputEvent::GetKeyCode()";
   EnterInputEvent enter(key_event, true);
   if (enter.failed())
     return 0;
   return enter.object()->GetKeyCode();
 }
 
 PP_Var GetCharacterText(PP_Resource character_event) {
   VLOG(4) << "PPB_KeyboardInputEvent::GetCharacterText()";
   EnterInputEvent enter(character_event, true);
   if (enter.failed())
     return PP_MakeUndefined();
   return enter.object()->GetCharacterText();
 }
 
 PP_Var GetCode(PP_Resource key_event) {
   VLOG(4) << "PPB_KeyboardInputEvent::GetCode()";
   EnterInputEvent enter(key_event, true);
   if (enter.failed())
     return PP_MakeUndefined();
   return enter.object()->GetCode();
 }
 
 const PPB_KeyboardInputEvent_1_0 g_ppb_keyboard_input_event_1_0_thunk = {
-  &CreateKeyboardInputEvent_1_0,
-  &IsKeyboardInputEvent,
-  &GetKeyCode,
-  &GetCharacterText
-};
+    &CreateKeyboardInputEvent_1_0, &IsKeyboardInputEvent, &GetKeyCode,
+    &GetCharacterText};
 
 const PPB_KeyboardInputEvent g_ppb_keyboard_input_event_thunk = {
-  &CreateKeyboardInputEvent_1_2,
-  &IsKeyboardInputEvent,
-  &GetKeyCode,
-  &GetCharacterText,
-  &GetCode
-};
+    &CreateKeyboardInputEvent_1_2, &IsKeyboardInputEvent, &GetKeyCode,
+    &GetCharacterText, &GetCode};
 
 // Composition -----------------------------------------------------------------
 
 PP_Resource CreateIMEInputEvent(PP_Instance instance,
                                 PP_InputEvent_Type type,
                                 PP_TimeTicks time_stamp,
                                 PP_Var text,
                                 uint32_t segment_number,
                                 const uint32_t segment_offsets[],
                                 int32_t target_segment,
                                 uint32_t selection_start,
                                 uint32_t selection_end) {
   VLOG(4) << "PPB_IMEInputEvent_Dev::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateIMEInputEvent(instance, type, time_stamp,
-                                                text, segment_number,
+  return enter.functions()->CreateIMEInputEvent(instance,
+                                                type,
+                                                time_stamp,
+                                                text,
+                                                segment_number,
                                                 segment_offsets,
                                                 target_segment,
                                                 selection_start,
                                                 selection_end);
 }
 
 PP_Bool IsIMEInputEvent(PP_Resource resource) {
   VLOG(4) << "PPB_IMEInputEvent_Dev::IsIMEInputEvent()";
   if (!IsInputEvent(resource))
     return PP_FALSE;  // Prevent warning log in GetType.
@@ skipping 40 matching lines @@
     if (start)
       *start = 0;
     if (end)
       *end = 0;
     return;
   }
   enter.object()->GetIMESelection(start, end);
 }
 
 const PPB_IMEInputEvent_Dev_0_1 g_ppb_ime_input_event_0_1_thunk = {
-  &IsIMEInputEvent,
-  &GetIMEText,
-  &GetIMESegmentNumber,
-  &GetIMESegmentOffset,
-  &GetIMETargetSegment,
-  &GetIMESelection
-};
+    &IsIMEInputEvent,     &GetIMEText,          &GetIMESegmentNumber,
+    &GetIMESegmentOffset, &GetIMETargetSegment, &GetIMESelection};
 
 const PPB_IMEInputEvent_Dev_0_2 g_ppb_ime_input_event_0_2_thunk = {
-  &CreateIMEInputEvent,
-  &IsIMEInputEvent,
-  &GetIMEText,
-  &GetIMESegmentNumber,
-  &GetIMESegmentOffset,
-  &GetIMETargetSegment,
-  &GetIMESelection
-};
+    &CreateIMEInputEvent, &IsIMEInputEvent,     &GetIMEText,
+    &GetIMESegmentNumber, &GetIMESegmentOffset, &GetIMETargetSegment,
+    &GetIMESelection};
 
 const PPB_IMEInputEvent_1_0 g_ppb_ime_input_event_1_0_thunk = {
-  &CreateIMEInputEvent,
-  &IsIMEInputEvent,
-  &GetIMEText,
-  &GetIMESegmentNumber,
-  &GetIMESegmentOffset,
-  &GetIMETargetSegment,
-  &GetIMESelection
-};
+    &CreateIMEInputEvent, &IsIMEInputEvent,     &GetIMEText,
+    &GetIMESegmentNumber, &GetIMESegmentOffset, &GetIMETargetSegment,
+    &GetIMESelection};
 
 // Touch -----------------------------------------------------------------------
 
 PP_Resource CreateTouchInputEvent(PP_Instance instance,
                                   PP_InputEvent_Type type,
                                   PP_TimeTicks time_stamp,
                                   uint32_t modifiers) {
   VLOG(4) << "PPB_TouchInputEvent::Create()";
   EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
-  return enter.functions()->CreateTouchInputEvent(instance, type, time_stamp,
-                                                  modifiers);
+  return enter.functions()->CreateTouchInputEvent(
+      instance, type, time_stamp, modifiers);
 }
 
 void AddTouchPoint(PP_Resource touch_event,
                    PP_TouchListType list,
                    const PP_TouchPoint* point) {
   VLOG(4) << "PPB_TouchInputEvent::AddTouchPoint()";
   EnterInputEvent enter(touch_event, true);
   if (enter.failed())
     return;
   return enter.object()->AddTouchPoint(list, *point);
@@ skipping 32 matching lines @@
                                   PP_TouchListType list,
                                   uint32_t id) {
   VLOG(4) << "PPB_TouchInputEvent::GetTouchById()";
   EnterInputEvent enter(touch_event, true);
   if (enter.failed())
     return PP_MakeTouchPoint();
   return enter.object()->GetTouchById(list, id);
 }
 
 const PPB_TouchInputEvent_1_0 g_ppb_touch_input_event_thunk = {
-  &CreateTouchInputEvent,
-  &AddTouchPoint,
-  &IsTouchInputEvent,
-  &GetTouchCount,
-  &GetTouchByIndex,
-  &GetTouchById
-};
+    &CreateTouchInputEvent, &AddTouchPoint,   &IsTouchInputEvent,
+    &GetTouchCount,         &GetTouchByIndex, &GetTouchById};
 
 }  // namespace
 
 const PPB_InputEvent_1_0* GetPPB_InputEvent_1_0_Thunk() {
   return &g_ppb_input_event_thunk;
 }
 
 const PPB_MouseInputEvent_1_0* GetPPB_MouseInputEvent_1_0_Thunk() {
   return &g_ppb_mouse_input_event_1_0_thunk;
 }
@@ skipping 25 matching lines @@
 const PPB_IMEInputEvent_1_0* GetPPB_IMEInputEvent_1_0_Thunk() {
   return &g_ppb_ime_input_event_1_0_thunk;
 }
 
 const PPB_TouchInputEvent_1_0* GetPPB_TouchInputEvent_1_0_Thunk() {
   return &g_ppb_touch_input_event_thunk;
 }
 
 }  // namespace thunk
 }  // namespace ppapi