1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "build/build_config.h" 6 7 #include <windows.h> 8 #include <mmsystem.h> 9 10 #include "base/event_recorder.h" 11 #include "base/file_util.h" 12 #include "base/logging.h" 13 14 // A note about time. 15 // For perfect playback of events, you'd like a very accurate timer 16 // so that events are played back at exactly the same time that 17 // they were recorded. However, windows has a clock which is only 18 // granular to ~15ms. We see more consistent event playback when 19 // using a higher resolution timer. To do this, we use the 20 // timeGetTime API instead of the default GetTickCount() API. 21 22 namespace base { 23 24 EventRecorder* EventRecorder::current_ = NULL; 25 26 LRESULT CALLBACK StaticRecordWndProc(int nCode, WPARAM wParam, 27 LPARAM lParam) { 28 CHECK(EventRecorder::current()); 29 return EventRecorder::current()->RecordWndProc(nCode, wParam, lParam); 30 } 31 32 LRESULT CALLBACK StaticPlaybackWndProc(int nCode, WPARAM wParam, 33 LPARAM lParam) { 34 CHECK(EventRecorder::current()); 35 return EventRecorder::current()->PlaybackWndProc(nCode, wParam, lParam); 36 } 37 38 EventRecorder::~EventRecorder() { 39 // Try to assert early if the caller deletes the recorder 40 // while it is still in use. 41 DCHECK(!journal_hook_); 42 DCHECK(!is_recording_ && !is_playing_); 43 } 44 45 bool EventRecorder::StartRecording(const FilePath& filename) { 46 if (journal_hook_ != NULL) 47 return false; 48 if (is_recording_ || is_playing_) 49 return false; 50 51 // Open the recording file. 52 DCHECK(file_ == NULL); 53 file_ = file_util::OpenFile(filename, "wb+"); 54 if (!file_) { 55 DLOG(ERROR) << "EventRecorder could not open log file"; 56 return false; 57 } 58 59 // Set the faster clock, if possible. 60 ::timeBeginPeriod(1); 61 62 // Set the recording hook. JOURNALRECORD can only be used as a global hook. 63 journal_hook_ = ::SetWindowsHookEx(WH_JOURNALRECORD, StaticRecordWndProc, 64 GetModuleHandle(NULL), 0); 65 if (!journal_hook_) { 66 DLOG(ERROR) << "EventRecorder Record Hook failed"; 67 file_util::CloseFile(file_); 68 return false; 69 } 70 71 is_recording_ = true; 72 return true; 73 } 74 75 void EventRecorder::StopRecording() { 76 if (is_recording_) { 77 DCHECK(journal_hook_ != NULL); 78 79 if (!::UnhookWindowsHookEx(journal_hook_)) { 80 DLOG(ERROR) << "EventRecorder Unhook failed"; 81 // Nothing else we can really do here. 82 return; 83 } 84 85 ::timeEndPeriod(1); 86 87 DCHECK(file_ != NULL); 88 file_util::CloseFile(file_); 89 file_ = NULL; 90 91 journal_hook_ = NULL; 92 is_recording_ = false; 93 } 94 } 95 96 bool EventRecorder::StartPlayback(const FilePath& filename) { 97 if (journal_hook_ != NULL) 98 return false; 99 if (is_recording_ || is_playing_) 100 return false; 101 102 // Open the recording file. 103 DCHECK(file_ == NULL); 104 file_ = file_util::OpenFile(filename, "rb"); 105 if (!file_) { 106 DLOG(ERROR) << "EventRecorder Playback could not open log file"; 107 return false; 108 } 109 // Read the first event from the record. 110 if (fread(&playback_msg_, sizeof(EVENTMSG), 1, file_) != 1) { 111 DLOG(ERROR) << "EventRecorder Playback has no records!"; 112 file_util::CloseFile(file_); 113 return false; 114 } 115 116 // Set the faster clock, if possible. 117 ::timeBeginPeriod(1); 118 119 // Playback time is tricky. When playing back, we read a series of events, 120 // each with timeouts. Simply subtracting the delta between two timers will 121 // lead to fast playback (about 2x speed). The API has two events, one 122 // which advances to the next event (HC_SKIP), and another that requests the 123 // event (HC_GETNEXT). The same event will be requested multiple times. 124 // Each time the event is requested, we must calculate the new delay. 125 // To do this, we track the start time of the playback, and constantly 126 // re-compute the delay. I mention this only because I saw two examples 127 // of how to use this code on the net, and both were broken :-) 128 playback_start_time_ = timeGetTime(); 129 playback_first_msg_time_ = playback_msg_.time; 130 131 // Set the hook. JOURNALPLAYBACK can only be used as a global hook. 132 journal_hook_ = ::SetWindowsHookEx(WH_JOURNALPLAYBACK, StaticPlaybackWndProc, 133 GetModuleHandle(NULL), 0); 134 if (!journal_hook_) { 135 DLOG(ERROR) << "EventRecorder Playback Hook failed"; 136 return false; 137 } 138 139 is_playing_ = true; 140 141 return true; 142 } 143 144 void EventRecorder::StopPlayback() { 145 if (is_playing_) { 146 DCHECK(journal_hook_ != NULL); 147 148 if (!::UnhookWindowsHookEx(journal_hook_)) { 149 DLOG(ERROR) << "EventRecorder Unhook failed"; 150 // Nothing else we can really do here. 151 } 152 153 DCHECK(file_ != NULL); 154 file_util::CloseFile(file_); 155 file_ = NULL; 156 157 ::timeEndPeriod(1); 158 159 journal_hook_ = NULL; 160 is_playing_ = false; 161 } 162 } 163 164 // Windows callback hook for the recorder. 165 LRESULT EventRecorder::RecordWndProc(int nCode, WPARAM wParam, LPARAM lParam) { 166 static bool recording_enabled = true; 167 EVENTMSG* msg_ptr = NULL; 168 169 // The API says we have to do this. 170 // See http://msdn2.microsoft.com/en-us/library/ms644983(VS.85).aspx 171 if (nCode < 0) 172 return ::CallNextHookEx(journal_hook_, nCode, wParam, lParam); 173 174 // Check for the break key being pressed and stop recording. 175 if (::GetKeyState(VK_CANCEL) & 0x8000) { 176 StopRecording(); 177 return ::CallNextHookEx(journal_hook_, nCode, wParam, lParam); 178 } 179 180 // The Journal Recorder must stop recording events when system modal 181 // dialogs are present. (see msdn link above) 182 switch (nCode) { 183 case HC_SYSMODALON: 184 recording_enabled = false; 185 break; 186 case HC_SYSMODALOFF: 187 recording_enabled = true; 188 break; 189 } 190 191 if (nCode == HC_ACTION && recording_enabled) { 192 // Aha - we have an event to record. 193 msg_ptr = reinterpret_cast<EVENTMSG*>(lParam); 194 msg_ptr->time = timeGetTime(); 195 fwrite(msg_ptr, sizeof(EVENTMSG), 1, file_); 196 fflush(file_); 197 } 198 199 return CallNextHookEx(journal_hook_, nCode, wParam, lParam); 200 } 201 202 // Windows callback for the playback mode. 203 LRESULT EventRecorder::PlaybackWndProc(int nCode, WPARAM wParam, 204 LPARAM lParam) { 205 static bool playback_enabled = true; 206 int delay = 0; 207 208 switch (nCode) { 209 // A system modal dialog box is being displayed. Stop playing back 210 // messages. 211 case HC_SYSMODALON: 212 playback_enabled = false; 213 break; 214 215 // A system modal dialog box is destroyed. We can start playing back 216 // messages again. 217 case HC_SYSMODALOFF: 218 playback_enabled = true; 219 break; 220 221 // Prepare to copy the next mouse or keyboard event to playback. 222 case HC_SKIP: 223 if (!playback_enabled) 224 break; 225 226 // Read the next event from the record. 227 if (fread(&playback_msg_, sizeof(EVENTMSG), 1, file_) != 1) 228 this->StopPlayback(); 229 break; 230 231 // Copy the mouse or keyboard event to the EVENTMSG structure in lParam. 232 case HC_GETNEXT: 233 if (!playback_enabled) 234 break; 235 236 memcpy(reinterpret_cast<void*>(lParam), &playback_msg_, 237 sizeof(playback_msg_)); 238 239 // The return value is the amount of time (in milliseconds) to wait 240 // before playing back the next message in the playback queue. Each 241 // time this is called, we recalculate the delay relative to our current 242 // wall clock. 243 delay = (playback_msg_.time - playback_first_msg_time_) - 244 (timeGetTime() - playback_start_time_); 245 if (delay < 0) 246 delay = 0; 247 return delay; 248 249 // An application has called PeekMessage with wRemoveMsg set to PM_NOREMOVE 250 // indicating that the message is not removed from the message queue after 251 // PeekMessage processing. 252 case HC_NOREMOVE: 253 break; 254 } 255 256 return CallNextHookEx(journal_hook_, nCode, wParam, lParam); 257 } 258 259 } // namespace base 260
