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));
}
// Compiles a GL shader and attaches it to a program. Returns the shader ID if
// successful, or 0 if not.
static GrGLuint attach_shader(const GrGLContext& glCtx,
GrGLuint programId,
GrGLenum type,
const SkString& shaderSrc) {
const GrGLInterface* gli = glCtx.interface();
GrGLuint shaderId;
GR_GL_CALL_RET(gli, shaderId, CreateShader(type));
if (0 == shaderId) {
return 0;
}
const GrGLchar* sourceStr = shaderSrc.c_str();
GrGLint sourceLength = static_cast<GrGLint>(shaderSrc.size());
GR_GL_CALL(gli, ShaderSource(shaderId, 1, &sourceStr, &sourceLength));
GR_GL_CALL(gli, CompileShader(shaderId));
// Calling GetShaderiv in Chromium is quite expensive. Assume success in release builds.
bool checkCompiled = !glCtx.isChromium();
#ifdef SK_DEBUG
checkCompiled = true;
#endif
if (checkCompiled) {
GrGLint compiled = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_COMPILE_STATUS, &compiled));
if (!compiled) {
GrGLint infoLen = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_INFO_LOG_LENGTH, &infoLen));
SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
if (infoLen > 0) {
// retrieve length even though we don't need it to workaround bug in Chromium cmd
// buffer param validation.
GrGLsizei length = GR_GL_INIT_ZERO;
GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1,
&length, (char*)log.get()));
GrPrintf(shaderSrc.c_str());
GrPrintf("\n%s", log.get());
}
SkDEBUGFAIL("Shader compilation failed!");
GR_GL_CALL(gli, DeleteShader(shaderId));
return 0;
}
}
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "skia_gpu::GLShader",
TRACE_EVENT_SCOPE_THREAD, "shader", TRACE_STR_COPY(shaderSrc.c_str()));
if (c_PrintShaders) {
GrPrintf(shaderSrc.c_str());
GrPrintf("\n");
}
// Attach the shader, but defer deletion until after we have linked the program.
// This works around a bug in the Android emulator's GLES2 wrapper which
// will immediately delete the shader object and free its memory even though it's
// attached to a program, which then causes glLinkProgram to fail.
GR_GL_CALL(gli, AttachShader(programId, shaderId));
return shaderId;
}
void ResourceFetcher::willStartLoadingResource(Resource* resource, ResourceRequest& request)
{
TRACE_EVENT_ASYNC_BEGIN2(
"net", "Resource", resource, "url",
TRACE_STR_COPY(resource->url().string().ascii().data()), "priority",
resource->resourceRequest().priority());
}
v8::MaybeLocal<v8::Value> V8ScriptRunner::runCompiledScript(v8::Isolate* isolate, v8::Local<v8::Script> script, ExecutionContext* context)
{
ASSERT(!script.IsEmpty());
TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
TRACE_EVENT1("v8", "v8.run", "fileName", TRACE_STR_COPY(*v8::String::Utf8Value(script->GetUnboundScript()->GetScriptName())));
if (V8RecursionScope::recursionLevel(isolate) >= kMaxRecursionDepth)
return throwStackOverflowExceptionIfNeeded(isolate);
RELEASE_ASSERT(!context->isIteratingOverObservers());
// Run the script and keep track of the current recursion depth.
v8::MaybeLocal<v8::Value> result;
{
if (ScriptForbiddenScope::isScriptForbidden()) {
throwScriptForbiddenException(isolate);
return v8::MaybeLocal<v8::Value>();
}
V8RecursionScope recursionScope(isolate);
result = script->Run(isolate->GetCurrentContext());
}
crashIfV8IsDead();
return result;
}
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();
}
