cef/tests/cefclient/browser/main_message_loop_external_...

150 lines
4.2 KiB
C++

// Copyright (c) 2016 The Chromium Embedded Framework 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 "cefclient/browser/main_message_loop_external_pump.h"
#include <CommCtrl.h>
#include "include/cef_app.h"
#include "cefclient/browser/util_win.h"
namespace client {
namespace {
// Message sent to get an additional time slice for pumping (processing) another
// task (a series of such messages creates a continuous task pump).
static const int kMsgHaveWork = WM_USER + 1;
class MainMessageLoopExternalPumpWin : public MainMessageLoopExternalPump {
public:
MainMessageLoopExternalPumpWin();
~MainMessageLoopExternalPumpWin();
// MainMessageLoopStd methods:
void Quit() OVERRIDE;
int Run() OVERRIDE;
// MainMessageLoopExternalPump methods:
void OnScheduleMessagePumpWork(int64 delay_ms) OVERRIDE;
protected:
// MainMessageLoopExternalPump methods:
void SetTimer(int64 delay_ms) OVERRIDE;
void KillTimer() OVERRIDE;
bool IsTimerPending() OVERRIDE { return timer_pending_; }
private:
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam,
LPARAM lparam);
// True if a timer event is currently pending.
bool timer_pending_;
// HWND owned by the thread that CefDoMessageLoopWork should be invoked on.
HWND main_thread_target_;
};
MainMessageLoopExternalPumpWin::MainMessageLoopExternalPumpWin()
: timer_pending_(false),
main_thread_target_(NULL) {
HINSTANCE hInstance = GetModuleHandle(NULL);
const wchar_t* const kClassName = L"CEFMainTargetHWND";
WNDCLASSEX wcex = {};
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.lpfnWndProc = WndProc;
wcex.hInstance = hInstance;
wcex.lpszClassName = kClassName;
RegisterClassEx(&wcex);
// Create the message handling window.
main_thread_target_ = CreateWindowW(kClassName, NULL, WS_OVERLAPPEDWINDOW,
0, 0, 0, 0, HWND_MESSAGE , NULL, hInstance, NULL);
DCHECK(main_thread_target_);
SetUserDataPtr(main_thread_target_, this);
}
MainMessageLoopExternalPumpWin::~MainMessageLoopExternalPumpWin() {
KillTimer();
if (main_thread_target_)
DestroyWindow(main_thread_target_);
}
void MainMessageLoopExternalPumpWin::Quit() {
PostMessage(NULL, WM_QUIT, 0, 0);
}
int MainMessageLoopExternalPumpWin::Run() {
// Run the message loop.
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
KillTimer();
// We need to run the message pump until it is idle. However we don't have
// that information here so we run the message loop "for a while".
for (int i = 0; i < 10; ++i) {
// Do some work.
CefDoMessageLoopWork();
// Sleep to allow the CEF proc to do work.
Sleep(50);
}
return 0;
}
void MainMessageLoopExternalPumpWin::OnScheduleMessagePumpWork(int64 delay_ms) {
// This method may be called on any thread.
PostMessage(main_thread_target_, kMsgHaveWork, 0,
static_cast<LPARAM>(delay_ms));
}
void MainMessageLoopExternalPumpWin::SetTimer(int64 delay_ms) {
DCHECK(!timer_pending_);
DCHECK_GT(delay_ms, 0);
timer_pending_ = true;
::SetTimer(main_thread_target_, 1, static_cast<UINT>(delay_ms), NULL);
}
void MainMessageLoopExternalPumpWin::KillTimer() {
if (timer_pending_) {
::KillTimer(main_thread_target_, 1);
timer_pending_ = false;
}
}
// static
LRESULT CALLBACK MainMessageLoopExternalPumpWin::WndProc(
HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
if (msg == WM_TIMER || msg == kMsgHaveWork) {
MainMessageLoopExternalPumpWin* message_loop =
GetUserDataPtr<MainMessageLoopExternalPumpWin*>(hwnd);
if (msg == kMsgHaveWork) {
// OnScheduleMessagePumpWork() request.
const int64 delay_ms = static_cast<int64>(lparam);
message_loop->OnScheduleWork(delay_ms);
} else {
// Timer timed out.
message_loop->OnTimerTimeout();
}
}
return DefWindowProc(hwnd, msg, wparam, lparam);
}
} // namespace
// static
SCOPED_PTR(MainMessageLoopExternalPump)
MainMessageLoopExternalPump::Create() {
return SCOPED_PTR(MainMessageLoopExternalPump)(
new MainMessageLoopExternalPumpWin());
}
} // namespace client