Make PP_TimeTicks actually be a tick counter rather than be the same as the

webkit/plugins/ppapi/event_conversion.cc

 // Copyright (c) 2011 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/plugins/ppapi/event_conversion.h"
 
 #include "base/basictypes.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/utf_string_conversion_utils.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/shared_impl/input_event_impl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/plugins/ppapi/common.h"
+#include "webkit/plugins/ppapi/time_conversion.h"
 
 using ppapi::InputEventData;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace webkit {
 namespace ppapi {
 
@@ skipping 28 matching lines @@
       return PP_INPUTEVENT_TYPE_UNDEFINED;
   }
 }
 
 // Generates a PP_InputEvent with the fields common to all events, as well as
 // the event type from the given web event. Event-specific fields will be zero
 // initialized.
 InputEventData GetEventWithCommonFieldsAndType(const WebInputEvent& web_event) {
   InputEventData result;
   result.event_type = ConvertEventTypes(web_event.type);
-  // TODO(brettw) http://code.google.com/p/chromium/issues/detail?id=57448
-  // This should use a tick count rather than the wall clock time that WebKit
-  // uses.
-  result.event_time_stamp = web_event.timeStampSeconds;
+  result.event_time_stamp = EventTimeToPPTimeTicks(web_event.timeStampSeconds);
   return result;
 }
 
 void AppendKeyEvent(const WebInputEvent& event,
                     std::vector<InputEventData>* result_events) {
   const WebKeyboardEvent& key_event =
       static_cast<const WebKeyboardEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = key_event.modifiers;
   result.key_code = key_event.windowsKeyCode;
@@ skipping 80 matching lines @@
       break;
     case PP_INPUTEVENT_TYPE_KEYDOWN:
       key_event->type = WebInputEvent::KeyDown;
       break;
     case PP_INPUTEVENT_TYPE_KEYUP:
       key_event->type = WebInputEvent::KeyUp;
       break;
     default:
       NOTREACHED();
   }
-  key_event->timeStampSeconds = event.time_stamp;
+  key_event->timeStampSeconds = PPTimeTicksToEventTime(event.time_stamp);
   key_event->modifiers = event.u.key.modifier;
   key_event->windowsKeyCode = event.u.key.key_code;
   return key_event;
 }
 
 WebKeyboardEvent* BuildCharEvent(const PP_InputEvent& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   key_event->type = WebInputEvent::Char;
-  key_event->timeStampSeconds = event.time_stamp;
+  key_event->timeStampSeconds = PPTimeTicksToEventTime(event.time_stamp);
   key_event->modifiers = event.u.character.modifier;
 
   // 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;
   size_t text_len = 0;
   while (text_len < text_length_cap && event.u.character.text[text_len])
       text_len++;
   string16 text16 = UTF8ToUTF16(std::string(event.u.character.text, text_len));
 
@@ skipping 23 matching lines @@
       break;
     case PP_INPUTEVENT_TYPE_MOUSELEAVE:
       mouse_event->type = WebInputEvent::MouseLeave;
       break;
     case PP_INPUTEVENT_TYPE_CONTEXTMENU:
       mouse_event->type = WebInputEvent::ContextMenu;
       break;
     default:
       NOTREACHED();
   }
-  mouse_event->timeStampSeconds = event.time_stamp;
+  mouse_event->timeStampSeconds = PPTimeTicksToEventTime(event.time_stamp);
   mouse_event->modifiers = event.u.mouse.modifier;
   mouse_event->button =
       static_cast<WebMouseEvent::Button>(event.u.mouse.button);
   mouse_event->x = static_cast<int>(event.u.mouse.x);
   mouse_event->y = static_cast<int>(event.u.mouse.y);
   mouse_event->clickCount = event.u.mouse.click_count;
   return mouse_event;
 }
 
 WebMouseWheelEvent* BuildMouseWheelEvent(const PP_InputEvent& event) {
   WebMouseWheelEvent* mouse_wheel_event = new WebMouseWheelEvent();
   mouse_wheel_event->type = WebInputEvent::MouseWheel;
-  mouse_wheel_event->timeStampSeconds = event.time_stamp;
+  mouse_wheel_event->timeStampSeconds =
+      PPTimeTicksToEventTime(event.time_stamp);
   mouse_wheel_event->modifiers = event.u.wheel.modifier;
   mouse_wheel_event->deltaX = event.u.wheel.delta_x;
   mouse_wheel_event->deltaY = event.u.wheel.delta_y;
   mouse_wheel_event->wheelTicksX = event.u.wheel.wheel_ticks_x;
   mouse_wheel_event->wheelTicksY = event.u.wheel.wheel_ticks_y;
   mouse_wheel_event->scrollByPage = event.u.wheel.scroll_by_page;
   return mouse_wheel_event;
 }
 
 void InputEventDataToPPInputEvent(const InputEventData& data,
@@ skipping 127 matching lines @@
       return PP_INPUTEVENT_CLASS_KEYBOARD;
     case WebInputEvent::Undefined:
     default:
       NOTREACHED();
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace ppapi
 }  // namespace webkit