The Tor Browser: comparison ipc/chromium/src/base/event

--1:000000000000
+:e93151935786
+// Copyright (c) 2006-2008 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 "build/build_config.h"
+#include <windows.h>
+#include <mmsystem.h>
+#include "base/event_recorder.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+// A note about time.
+// For perfect playback of events, you'd like a very accurate timer
+// so that events are played back at exactly the same time that
+// they were recorded.  However, windows has a clock which is only
+// granular to ~15ms.  We see more consistent event playback when
+// using a higher resolution timer.  To do this, we use the
+// timeGetTime API instead of the default GetTickCount() API.
+namespace base {
+EventRecorder* EventRecorder::current_ = NULL;
+LRESULT CALLBACK StaticRecordWndProc(int nCode, WPARAM wParam,
+LPARAM lParam) {
+CHECK(EventRecorder::current());
+return EventRecorder::current()->RecordWndProc(nCode, wParam, lParam);
+}
+LRESULT CALLBACK StaticPlaybackWndProc(int nCode, WPARAM wParam,
+LPARAM lParam) {
+CHECK(EventRecorder::current());
+return EventRecorder::current()->PlaybackWndProc(nCode, wParam, lParam);
+}
+EventRecorder::~EventRecorder() {
+// Try to assert early if the caller deletes the recorder
+// while it is still in use.
+DCHECK(!journal_hook_);
+DCHECK(!is_recording_ && !is_playing_);
+}
+bool EventRecorder::StartRecording(const FilePath& filename) {
+if (journal_hook_ != NULL)
+return false;
+if (is_recording_ || is_playing_)
+return false;
+// Open the recording file.
+DCHECK(file_ == NULL);
+file_ = file_util::OpenFile(filename, "wb+");
+if (!file_) {
+DLOG(ERROR) << "EventRecorder could not open log file";
+return false;
+}
+// Set the faster clock, if possible.
+::timeBeginPeriod(1);
+// Set the recording hook.  JOURNALRECORD can only be used as a global hook.
+journal_hook_ = ::SetWindowsHookEx(WH_JOURNALRECORD, StaticRecordWndProc,
+GetModuleHandle(NULL), 0);
+if (!journal_hook_) {
+DLOG(ERROR) << "EventRecorder Record Hook failed";
+file_util::CloseFile(file_);
+return false;
+}
+is_recording_ = true;
+return true;
+}
+void EventRecorder::StopRecording() {
+if (is_recording_) {
+DCHECK(journal_hook_ != NULL);
+if (!::UnhookWindowsHookEx(journal_hook_)) {
+DLOG(ERROR) << "EventRecorder Unhook failed";
+// Nothing else we can really do here.
+return;
+}
+::timeEndPeriod(1);
+DCHECK(file_ != NULL);
+file_util::CloseFile(file_);
+file_ = NULL;
+journal_hook_ = NULL;
+is_recording_ = false;
+}
+}
+bool EventRecorder::StartPlayback(const FilePath& filename) {
+if (journal_hook_ != NULL)
+return false;
+if (is_recording_ || is_playing_)
+return false;
+// Open the recording file.
+DCHECK(file_ == NULL);
+file_ = file_util::OpenFile(filename, "rb");
+if (!file_) {
+DLOG(ERROR) << "EventRecorder Playback could not open log file";
+return false;
+}
+// Read the first event from the record.
+if (fread(&playback_msg_, sizeof(EVENTMSG), 1, file_) != 1) {
+DLOG(ERROR) << "EventRecorder Playback has no records!";
+file_util::CloseFile(file_);
+return false;
+}
+// Set the faster clock, if possible.
+::timeBeginPeriod(1);
+// Playback time is tricky.  When playing back, we read a series of events,
+// each with timeouts.  Simply subtracting the delta between two timers will
+// lead to fast playback (about 2x speed).  The API has two events, one
+// which advances to the next event (HC_SKIP), and another that requests the
+// event (HC_GETNEXT).  The same event will be requested multiple times.
+// Each time the event is requested, we must calculate the new delay.
+// To do this, we track the start time of the playback, and constantly
+// re-compute the delay.   I mention this only because I saw two examples
+// of how to use this code on the net, and both were broken :-)
+playback_start_time_ = timeGetTime();
+playback_first_msg_time_ = playback_msg_.time;
+// Set the hook.  JOURNALPLAYBACK can only be used as a global hook.
+journal_hook_ = ::SetWindowsHookEx(WH_JOURNALPLAYBACK, StaticPlaybackWndProc,
+GetModuleHandle(NULL), 0);
+if (!journal_hook_) {
+DLOG(ERROR) << "EventRecorder Playback Hook failed";
+return false;
+}
+is_playing_ = true;
+return true;
+}
+void EventRecorder::StopPlayback() {
+if (is_playing_) {
+DCHECK(journal_hook_ != NULL);
+if (!::UnhookWindowsHookEx(journal_hook_)) {
+DLOG(ERROR) << "EventRecorder Unhook failed";
+// Nothing else we can really do here.
+}
+DCHECK(file_ != NULL);
+file_util::CloseFile(file_);
+file_ = NULL;
+::timeEndPeriod(1);
+journal_hook_ = NULL;
+is_playing_ = false;
+}
+}
+// Windows callback hook for the recorder.
+LRESULT EventRecorder::RecordWndProc(int nCode, WPARAM wParam, LPARAM lParam) {
+static bool recording_enabled = true;
+EVENTMSG* msg_ptr = NULL;
+// The API says we have to do this.
+// See http://msdn2.microsoft.com/en-us/library/ms644983(VS.85).aspx
+if (nCode < 0)
+return ::CallNextHookEx(journal_hook_, nCode, wParam, lParam);
+// Check for the break key being pressed and stop recording.
+if (::GetKeyState(VK_CANCEL) & 0x8000) {
+StopRecording();
+return ::CallNextHookEx(journal_hook_, nCode, wParam, lParam);
+}
+// The Journal Recorder must stop recording events when system modal
+// dialogs are present. (see msdn link above)
+switch(nCode) {
+case HC_SYSMODALON:
+recording_enabled = false;
+break;
+case HC_SYSMODALOFF:
+recording_enabled = true;
+break;
+}
+if (nCode == HC_ACTION && recording_enabled) {
+// Aha - we have an event to record.
+msg_ptr = reinterpret_cast<EVENTMSG*>(lParam);
+msg_ptr->time = timeGetTime();
+fwrite(msg_ptr, sizeof(EVENTMSG), 1, file_);
+fflush(file_);
+}
+return CallNextHookEx(journal_hook_, nCode, wParam, lParam);
+}
+// Windows callback for the playback mode.
+LRESULT EventRecorder::PlaybackWndProc(int nCode, WPARAM wParam,
+LPARAM lParam) {
+static bool playback_enabled = true;
+int delay = 0;
+switch(nCode) {
+// A system modal dialog box is being displayed.  Stop playing back
+// messages.
+case HC_SYSMODALON:
+playback_enabled = false;
+break;
+// A system modal dialog box is destroyed.  We can start playing back
+// messages again.
+case HC_SYSMODALOFF:
+playback_enabled = true;
+break;
+// Prepare to copy the next mouse or keyboard event to playback.
+case HC_SKIP:
+if (!playback_enabled)
+break;
+// Read the next event from the record.
+if (fread(&playback_msg_, sizeof(EVENTMSG), 1, file_) != 1)
+this->StopPlayback();
+break;
+// Copy the mouse or keyboard event to the EVENTMSG structure in lParam.
+case HC_GETNEXT:
+if (!playback_enabled)
+break;
+memcpy(reinterpret_cast<void*>(lParam), &playback_msg_,
+sizeof(playback_msg_));
+// The return value is the amount of time (in milliseconds) to wait
+// before playing back the next message in the playback queue.  Each
+// time this is called, we recalculate the delay relative to our current
+// wall clock.
+delay = (playback_msg_.time - playback_first_msg_time_) -
+(timeGetTime() - playback_start_time_);
+if (delay < 0)
+delay = 0;
+return delay;
+// An application has called PeekMessage with wRemoveMsg set to PM_NOREMOVE
+// indicating that the message is not removed from the message queue after
+// PeekMessage processing.
+case HC_NOREMOVE:
+break;
+}
+return CallNextHookEx(journal_hook_, nCode, wParam, lParam);
+}
+}  // namespace base

The Tor Browser / file comparison

comparison: ipc/chromium/src/base/event_recorder.cc

ipc/chromium/src/base/event_recorder.cc