WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
{
WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(gestureEvent.x, gestureEvent.y), WebInputHandlerClient::ScrollInputTypeGesture);
switch (scrollStatus) {
case WebInputHandlerClient::ScrollStatusStarted: {
m_inputHandlerClient->scrollEnd();
m_wheelFlingCurve = PlatformGestureCurveFactory::get()->createCurve(gestureEvent.data.flingStart.sourceDevice, FloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY));
TRACE_EVENT_ASYNC_BEGIN1("cc", "WebCompositorInputHandlerImpl::handleGestureFling::started", this, "curve", m_wheelFlingCurve->debugName());
m_wheelFlingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
m_wheelFlingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
m_wheelFlingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
m_wheelFlingParameters.modifiers = gestureEvent.modifiers;
m_wheelFlingParameters.sourceDevice = gestureEvent.data.flingStart.sourceDevice;
m_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case WebInputHandlerClient::ScrollStatusOnMainThread: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
return DidNotHandle;
}
case WebInputHandlerClient::ScrollStatusIgnored: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
// We still pass the curve to the main thread if there's nothing scrollable, in case something
// registers a handler before the curve is over.
return DidNotHandle;
}
}
return DidNotHandle;
}
void CCActiveAnimation::setRunState(RunState runState, double monotonicTime)
{
if (m_suspended)
return;
char nameBuffer[256];
base::snprintf(nameBuffer, sizeof(nameBuffer), "%s-%d%s", s_targetPropertyNames[m_targetProperty], m_group, m_isControllingInstance ? "(impl)" : "");
bool isWaitingToStart = m_runState == WaitingForNextTick
|| m_runState == WaitingForTargetAvailability
|| m_runState == WaitingForStartTime;
if (isWaitingToStart && runState == Running)
TRACE_EVENT_ASYNC_BEGIN1("cc", "CCActiveAnimation", this, "Name", TRACE_STR_COPY(nameBuffer));
bool wasFinished = isFinished();
const char* oldRunStateName = s_runStateNames[m_runState];
if (runState == Running && m_runState == Paused)
m_totalPausedTime += monotonicTime - m_pauseTime;
else if (runState == Paused)
m_pauseTime = monotonicTime;
m_runState = runState;
const char* newRunStateName = s_runStateNames[runState];
if (!wasFinished && isFinished())
TRACE_EVENT_ASYNC_END0("cc", "CCActiveAnimation", this);
char stateBuffer[256];
base::snprintf(stateBuffer, sizeof(stateBuffer), "%s->%s", oldRunStateName, newRunStateName);
TRACE_EVENT_INSTANT2("cc", "CCLayerAnimationController::setRunState", "Name", TRACE_STR_COPY(nameBuffer), "State", TRACE_STR_COPY(stateBuffer));
}
void FrameFetchContext::willStartLoadingResource(unsigned long identifier, ResourceRequest& request, Resource::Type type)
{
TRACE_EVENT_ASYNC_BEGIN1("blink.net", "Resource", identifier, "data", loadResourceTraceData(identifier, request.url(), request.priority()));
frame()->loader().progress().willStartLoading(identifier);
prepareRequest(identifier, request, ResourceResponse());
if (!m_documentLoader || m_documentLoader->fetcher()->archive() || !request.url().isValid())
return;
if (type == Resource::MainResource)
m_documentLoader->applicationCacheHost()->willStartLoadingMainResource(request);
else
m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
}
AnimationPlayer::PlayStateUpdateScope::~PlayStateUpdateScope()
{
AnimationPlayState oldPlayState = m_initial;
AnimationPlayState newPlayState = m_player->calculatePlayState();
if (oldPlayState != newPlayState) {
bool wasActive = oldPlayState == Pending || oldPlayState == Running;
bool isActive = newPlayState == Pending || newPlayState == Running;
if (!wasActive && isActive) {
if (m_player->m_content) {
TRACE_EVENT_ASYNC_BEGIN1("blink", "Animation", &m_player, "Name", TRACE_STR_COPY(m_player->m_content->name().utf8().data()));
} else {
TRACE_EVENT_ASYNC_BEGIN0("blink", "Animation", &m_player);
}
} else if (wasActive && !isActive) {
if (oldPlayState != Idle && oldPlayState != Finished) {
TRACE_EVENT_ASYNC_END0("blink", "Animation", &m_player);
}
}
if (isActive) {
TRACE_EVENT_ASYNC_STEP_INTO0("blink", "Animation", &m_player, playStateString(newPlayState));
}
}
if (oldPlayState != newPlayState && (oldPlayState == Idle || newPlayState == Idle)) {
m_player->setOutdated();
}
m_player->m_playState = newPlayState;
#if ENABLE(ASSERT)
// Verify that current time is up to date.
m_player->currentTimeInternal();
#endif
switch (m_compositorPendingChange) {
case SetCompositorPending:
m_player->setCompositorPending();
break;
case SetCompositorPendingWithSourceChanged:
m_player->setCompositorPending(true);
break;
case DoNotSetCompositorPending:
break;
default:
ASSERT_NOT_REACHED();
break;
}
m_player->endUpdatingState();
}
bool GenericEventQueue::enqueueEvent(PassRefPtr<Event> event)
{
if (m_isClosed)
return false;
if (event->target() == m_owner)
event->setTarget(nullptr);
TRACE_EVENT_ASYNC_BEGIN1("event", "GenericEventQueue:enqueueEvent", event.get(), "type", event->type().ascii());
m_pendingEvents.append(event);
if (!m_timer.isActive())
m_timer.startOneShot(0, FROM_HERE);
return true;
}
bool GenericEventQueue::enqueueEvent(Event* event)
{
if (m_isClosed)
return false;
if (event->target() == m_owner)
event->setTarget(nullptr);
TRACE_EVENT_ASYNC_BEGIN1("event", "GenericEventQueue:enqueueEvent", event, "type", event->type().ascii());
EventTarget* target = event->target() ? event->target() : m_owner.get();
InspectorInstrumentation::asyncTaskScheduled(target->getExecutionContext(), event->type(), event);
m_pendingEvents.append(event);
if (!m_timer.isActive())
m_timer.startOneShot(0, BLINK_FROM_HERE);
return true;
}
