TEST(WTF_GMainLoopSource, DestructionDuringDispatch)
{
// This is just a raw test that ensures deleting the GMainLoopSource object during
// dispatch does not cause problems. This test succeeds if it doesn't crash.
GMainLoopSource* source;
GMainLoop* loop = g_main_loop_new(nullptr, TRUE);
source = new GMainLoopSource;
source->schedule("[Test] DestroySourceTask", [&] {
delete source;
g_main_loop_quit(loop);
});
g_main_loop_run(loop);
source = new GMainLoopSource;
source->schedule("[Test] DestroySourceTask", std::function<bool ()>([&] {
delete source;
g_main_loop_quit(loop);
return false;
}));
g_main_loop_run(loop);
g_main_loop_unref(loop);
}
void TestController::platformRunUntil(bool&, double timeout)
{
if (timeout > 0) {
timeoutSource.scheduleAfterDelay("[WTR] Test timeout source", [] {
fprintf(stderr, "FAIL: TestControllerRunLoop timed out.\n");
gtk_main_quit();
}, std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(timeout)));
} else
timeoutSource.cancel();
gtk_main();
}
void setSharedTimerFireInterval(double interval)
{
ASSERT(sharedTimerFiredFunction);
gSharedTimer.scheduleAfterDelay("[WebKit] sharedTimerTimeoutCallback", std::function<void()>(sharedTimerFiredFunction),
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(interval)), GDK_PRIORITY_REDRAW);
}
namespace WebCore {
static GMainLoopSource gSharedTimer;
static void (*sharedTimerFiredFunction)();
void setSharedTimerFiredFunction(void (*f)())
{
sharedTimerFiredFunction = f;
if (!sharedTimerFiredFunction)
gSharedTimer.cancel();
}
void setSharedTimerFireInterval(double interval)
{
ASSERT(sharedTimerFiredFunction);
gSharedTimer.scheduleAfterDelay("[WebKit] sharedTimerTimeoutCallback", std::function<void()>(sharedTimerFiredFunction),
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(interval)), GDK_PRIORITY_REDRAW);
}
void stopSharedTimer()
{
gSharedTimer.cancel();
}
}
namespace WebCore {
static GMainLoopSource gSharedTimer;
static void (*sharedTimerFiredFunction)();
void setSharedTimerFiredFunction(void (*f)())
{
sharedTimerFiredFunction = f;
if (!sharedTimerFiredFunction)
gSharedTimer.cancel();
}
void setSharedTimerFireInterval(double interval)
{
ASSERT(sharedTimerFiredFunction);
// This is GDK_PRIORITY_REDRAW, but we don't want to depend on GDK here just to use a constant.
static const int priority = G_PRIORITY_HIGH_IDLE + 20;
gSharedTimer.scheduleAfterDelay("[WebKit] sharedTimerTimeoutCallback", std::function<void()>(sharedTimerFiredFunction),
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(interval)), priority);
}
void stopSharedTimer()
{
gSharedTimer.cancel();
}
}
void setSharedTimerFireInterval(double interval)
{
ASSERT(sharedTimerFiredFunction);
// This is GDK_PRIORITY_REDRAW, but we don't want to depend on GDK here just to use a constant.
static const int priority = G_PRIORITY_HIGH_IDLE + 20;
gSharedTimer.scheduleAfterDelay("[WebKit] sharedTimerTimeoutCallback", std::function<void()>(sharedTimerFiredFunction),
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(interval)), priority);
}
void TestController::notifyDone()
{
gtk_main_quit();
timeoutSource.cancel();
}
namespace WTR {
static GMainLoopSource timeoutSource;
void TestController::notifyDone()
{
gtk_main_quit();
timeoutSource.cancel();
}
void TestController::platformInitialize()
{
}
void TestController::platformDestroy()
{
}
void TestController::platformRunUntil(bool&, double timeout)
{
if (timeout > 0) {
timeoutSource.scheduleAfterDelay("[WTR] Test timeout source", [] {
fprintf(stderr, "FAIL: TestControllerRunLoop timed out.\n");
gtk_main_quit();
}, std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(timeout)));
} else
timeoutSource.cancel();
gtk_main();
}
static char* getEnvironmentVariableAsUTF8String(const char* variableName)
{
const char* value = g_getenv(variableName);
if (!value) {
fprintf(stderr, "%s environment variable not found\n", variableName);
exit(0);
}
gsize bytesWritten;
return g_filename_to_utf8(value, -1, 0, &bytesWritten, 0);
}
void TestController::initializeInjectedBundlePath()
{
GUniquePtr<char> utf8BundlePath(getEnvironmentVariableAsUTF8String("TEST_RUNNER_INJECTED_BUNDLE_FILENAME"));
m_injectedBundlePath.adopt(WKStringCreateWithUTF8CString(utf8BundlePath.get()));
}
void TestController::initializeTestPluginDirectory()
{
GUniquePtr<char> testPluginPath(getEnvironmentVariableAsUTF8String("TEST_RUNNER_TEST_PLUGIN_PATH"));
m_testPluginDirectory.adopt(WKStringCreateWithUTF8CString(testPluginPath.get()));
}
void TestController::platformInitializeContext()
{
}
void TestController::setHidden(bool hidden)
{
if (!m_mainWebView)
return;
if (hidden)
gtk_widget_unmap(GTK_WIDGET(m_mainWebView->platformView()));
else
gtk_widget_map(GTK_WIDGET(m_mainWebView->platformView()));
}
void TestController::runModal(PlatformWebView*)
{
// FIXME: Need to implement this to test showModalDialog.
}
const char* TestController::platformLibraryPathForTesting()
{
return 0;
}
void TestController::platformConfigureViewForTest(const TestInvocation&)
{
}
void TestController::platformResetPreferencesToConsistentValues()
{
if (!m_mainWebView)
return;
m_mainWebView->dismissAllPopupMenus();
}
void TestController::updatePlatformSpecificViewOptionsForTest(ViewOptions&, const TestInvocation&) const
{
}
} // namespace WTR
void stopSharedTimer()
{
gSharedTimer.cancel();
}
void setSharedTimerFiredFunction(void (*f)())
{
sharedTimerFiredFunction = f;
if (!sharedTimerFiredFunction)
gSharedTimer.cancel();
}
