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: {
if (gestureEvent.data.flingStart.sourceDevice == WebGestureEvent::Touchpad)
m_inputHandlerClient->scrollEnd();
m_flingCurve = adoptPtr(Platform::current()->createFlingAnimationCurve(gestureEvent.data.flingStart.sourceDevice, WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY), WebSize()));
TRACE_EVENT_ASYNC_BEGIN0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::started", this);
m_flingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
m_flingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
m_flingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
m_flingParameters.modifiers = gestureEvent.modifiers;
m_flingParameters.sourceDevice = gestureEvent.data.flingStart.sourceDevice;
m_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case WebInputHandlerClient::ScrollStatusOnMainThread: {
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
m_flingActiveOnMainThread = true;
return DidNotHandle;
}
case WebInputHandlerClient::ScrollStatusIgnored: {
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
if (gestureEvent.data.flingStart.sourceDevice == WebGestureEvent::Touchpad) {
// 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 DropEvent;
}
}
return DidNotHandle;
}
WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
{
CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(gestureEvent.x, gestureEvent.y), CCInputHandlerClient::Gesture);
switch (scrollStatus) {
case CCInputHandlerClient::ScrollStarted: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::started");
OwnPtr<PlatformGestureCurve> flingCurve = TouchpadFlingPlatformGestureCurve::create(FloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY));
m_wheelFlingAnimation = CCActiveGestureAnimation::create(PlatformGestureToCCGestureAdapter::create(flingCurve.release()), this);
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_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case CCInputHandlerClient::ScrollOnMainThread: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
return DidNotHandle;
}
case CCInputHandlerClient::ScrollIgnored: {
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;
}
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;
}
Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, PassRefPtr<SkSurface> surface, int msaaSampleCount, OpacityMode opacityMode)
: m_surface(surface)
, m_contextProvider(contextProvider)
, m_imageBuffer(0)
, m_msaaSampleCount(msaaSampleCount)
, m_bytesAllocated(0)
, m_haveRecordedDrawCommands(false)
, m_framesPending(0)
, m_destructionInProgress(false)
, m_rateLimitingEnabled(false)
, m_filterQuality(kLow_SkFilterQuality)
, m_isHidden(false)
, m_isDeferralEnabled(true)
, m_lastImageId(0)
, m_lastFilter(GL_LINEAR)
, m_opacityMode(opacityMode)
, m_size(m_surface->width(), m_surface->height())
{
ASSERT(m_surface);
ASSERT(m_contextProvider);
m_initialSurfaceSaveCount = m_surface->getCanvas()->getSaveCount();
// Used by browser tests to detect the use of a Canvas2DLayerBridge.
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
m_layer->setOpaque(opacityMode == Opaque);
m_layer->setBlendBackgroundColor(opacityMode != Opaque);
GraphicsLayer::registerContentsLayer(m_layer->layer());
m_layer->setRateLimitContext(m_rateLimitingEnabled);
m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
startRecording();
#ifndef NDEBUG
canvas2DLayerBridgeInstanceCounter.increment();
#endif
}
DrawingBuffer::DrawingBuffer(GraphicsContext3D* context,
const IntSize& size,
bool multisampleExtensionSupported,
bool packedDepthStencilExtensionSupported,
PreserveDrawingBuffer preserve,
PassRefPtr<ContextEvictionManager> contextEvictionManager)
: m_preserveDrawingBuffer(preserve)
, m_scissorEnabled(false)
, m_texture2DBinding(0)
, m_framebufferBinding(0)
, m_activeTextureUnit(GraphicsContext3D::TEXTURE0)
, m_context(context)
, m_size(-1, -1)
, m_multisampleExtensionSupported(multisampleExtensionSupported)
, m_packedDepthStencilExtensionSupported(packedDepthStencilExtensionSupported)
, m_fbo(0)
, m_colorBuffer(0)
, m_frontColorBuffer(0)
, m_depthStencilBuffer(0)
, m_depthBuffer(0)
, m_stencilBuffer(0)
, m_multisampleFBO(0)
, m_multisampleColorBuffer(0)
, m_contentsChanged(true)
, m_internalColorFormat(0)
, m_colorFormat(0)
, m_internalRenderbufferFormat(0)
, m_maxTextureSize(0)
, m_contextEvictionManager(contextEvictionManager)
{
// Used by browser tests to detect the use of a DrawingBuffer.
TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation");
initialize(size);
}
bool WebCompositorInputHandlerImpl::touchpadFlingScroll(const WebPoint& increment)
{
WebMouseWheelEvent syntheticWheel;
syntheticWheel.type = WebInputEvent::MouseWheel;
syntheticWheel.deltaX = increment.x;
syntheticWheel.deltaY = increment.y;
syntheticWheel.hasPreciseScrollingDeltas = true;
syntheticWheel.x = m_flingParameters.point.x;
syntheticWheel.y = m_flingParameters.point.y;
syntheticWheel.globalX = m_flingParameters.globalPoint.x;
syntheticWheel.globalY = m_flingParameters.globalPoint.y;
syntheticWheel.modifiers = m_flingParameters.modifiers;
WebCompositorInputHandlerImpl::EventDisposition disposition = handleInputEventInternal(syntheticWheel);
switch (disposition) {
case DidHandle:
return true;
case DropEvent:
break;
case DidNotHandle:
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::scrollBy::AbortFling");
// If we got a DidNotHandle, that means we need to deliver wheels on the main thread.
// In this case we need to schedule a commit and transfer the fling curve over to the main
// thread and run the rest of the wheels from there.
// This can happen when flinging a page that contains a scrollable subarea that we can't
// scroll on the thread if the fling starts outside the subarea but then is flung "under" the
// pointer.
m_client->transferActiveWheelFlingAnimation(m_flingParameters);
m_flingActiveOnMainThread = true;
cancelCurrentFling();
break;
}
return false;
}
Canvas2DLayerBridge::Canvas2DLayerBridge(PassRefPtr<GraphicsContext3D> context, SkDeferredCanvas* canvas, OpacityMode opacityMode, ThreadMode threadMode)
: m_canvas(canvas)
, m_context(context)
, m_bytesAllocated(0)
, m_didRecordDrawCommand(false)
, m_framesPending(0)
, m_next(0)
, m_prev(0)
#if ENABLE(CANVAS_USES_MAILBOX)
, m_lastImageId(0)
#endif
{
ASSERT(m_canvas);
// Used by browser tests to detect the use of a Canvas2DLayerBridge.
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
m_canvas->setNotificationClient(this);
#if ENABLE(CANVAS_USES_MAILBOX)
m_layer = adoptPtr(WebKit::Platform::current()->compositorSupport()->createExternalTextureLayerForMailbox(this));
#else
m_layer = adoptPtr(WebKit::Platform::current()->compositorSupport()->createExternalTextureLayer(this));
m_layer->setRateLimitContext(threadMode == SingleThread);
GrRenderTarget* renderTarget = reinterpret_cast<GrRenderTarget*>(m_canvas->getDevice()->accessRenderTarget());
if (renderTarget) {
m_layer->setTextureId(renderTarget->asTexture()->getTextureHandle());
}
#endif
m_layer->setOpaque(opacityMode == Opaque);
GraphicsLayerChromium::registerContentsLayer(m_layer->layer());
}
Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
: m_contextProvider(contextProvider)
, m_imageBuffer(0)
, m_msaaSampleCount(msaaSampleCount)
, m_bytesAllocated(0)
, m_haveRecordedDrawCommands(false)
, m_destructionInProgress(false)
, m_filterQuality(kLow_SkFilterQuality)
, m_isHidden(false)
, m_isDeferralEnabled(true)
, m_isRegisteredTaskObserver(false)
, m_renderingTaskCompletedForCurrentFrame(false)
, m_lastImageId(0)
, m_lastFilter(GL_LINEAR)
, m_accelerationMode(accelerationMode)
, m_opacityMode(opacityMode)
, m_size(size)
{
ASSERT(m_contextProvider);
// Used by browser tests to detect the use of a Canvas2DLayerBridge.
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
startRecording();
#ifndef NDEBUG
canvas2DLayerBridgeInstanceCounter().increment();
#endif
}
void WebCompositorInputHandlerImpl::scrollBy(const IntPoint& increment)
{
if (increment == IntPoint::zero())
return;
TRACE_EVENT2("cc", "WebCompositorInputHandlerImpl::scrollBy", "x", increment.x(), "y", increment.y());
WebMouseWheelEvent event;
event.type = WebInputEvent::MouseWheel;
event.deltaX = -increment.x();
event.deltaY = -increment.y();
event.hasPreciseScrollingDeltas = true;
event.x = m_wheelFlingPoint.x();
event.y = m_wheelFlingPoint.y();
WebCompositorInputHandlerImpl::EventDisposition disposition = handleInputEventInternal(event);
switch (disposition) {
case DidHandle:
case DropEvent:
break;
case DidNotHandle:
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::scrollBy::AbortFling");
// FIXME: If we got a DidNotHandle, that means we need to deliver wheels on the main thread.
// In this case we need to schedule a commit and transfer the fling curve over to the main
// thread and run the rest of the wheels from there.
// This can happen when flinging a page that contains a scrollable subarea that we can't
// scroll on the thread if the fling starts outside the subarea but then is flung "under" the
// pointer.
// For now, just abort the fling.
cancelCurrentFling();
}
}
void InspectorTimelineAgent::didBeginFrame()
{
#if PLATFORM(CHROMIUM)
TRACE_EVENT_INSTANT0("webkit", InstrumentationEvents::BeginFrame);
#endif
m_pendingFrameRecord = TimelineRecordFactory::createGenericRecord(timestamp(), 0);
}
PassOwnPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(PassRefPtr<GraphicsContext3D> context, const IntSize& size, OpacityMode opacityMode)
{
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
SkAutoTUnref<SkSurface> surface(createSurface(context.get(), size));
if (!surface.get())
return PassOwnPtr<Canvas2DLayerBridge>();
SkDeferredCanvas* canvas = SkDeferredCanvas::Create(surface.get());
OwnPtr<Canvas2DLayerBridge> layerBridge = adoptPtr(new Canvas2DLayerBridge(context, canvas, opacityMode));
return layerBridge.release();
}
PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
{
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
if (!contextProvider)
return nullptr;
RefPtr<Canvas2DLayerBridge> layerBridge;
layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), size, msaaSampleCount, opacityMode, accelerationMode));
return layerBridge.release();
}
void WebCompositorInputHandlerImpl::bindToClient(WebInputHandlerClient* client)
{
ASSERT(!m_inputHandlerClient);
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::bindToClient");
if (!s_compositors)
s_compositors = new HashSet<WebCompositorInputHandlerImpl*>;
s_compositors->add(this);
m_inputHandlerClient = client;
}
void WebCompositorInputHandlerImpl::animate(double monotonicTime)
{
if (!m_wheelFlingAnimation)
return;
if (m_wheelFlingAnimation->animate(monotonicTime))
m_inputHandlerClient->scheduleAnimation();
else {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::animate::flingOver");
m_wheelFlingAnimation.clear();
}
}
PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, OpacityMode opacityMode, int msaaSampleCount)
{
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
RefPtr<GraphicsContext3D> context = SharedGraphicsContext3D::get();
RefPtr<SkSurface> surface(createSkSurface(context.get(), size, msaaSampleCount));
if (!surface)
return 0;
RefPtr<Canvas2DLayerBridge> layerBridge;
OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
layerBridge = adoptRef(new Canvas2DLayerBridge(context, canvas.release(), msaaSampleCount, opacityMode));
return layerBridge.release();
}
PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, OpacityMode opacityMode, int msaaSampleCount)
{
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
if (!contextProvider)
return nullptr;
RefPtr<SkSurface> surface(createSkSurface(contextProvider->grContext(), size, msaaSampleCount, opacityMode));
if (!surface)
return nullptr;
RefPtr<Canvas2DLayerBridge> layerBridge;
OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
layerBridge = adoptRef(new Canvas2DLayerBridge(contextProvider.release(), canvas.release(), surface.release(), msaaSampleCount, opacityMode));
return layerBridge.release();
}
DrawingBuffer::DrawingBuffer(GraphicsContext3D* context,
const IntSize& size,
bool multisampleExtensionSupported,
bool packedDepthStencilExtensionSupported,
PreserveDrawingBuffer preserve,
PassRefPtr<ContextEvictionManager> contextEvictionManager)
: m_preserveDrawingBuffer(preserve)
, m_scissorEnabled(false)
, m_texture2DBinding(0)
, m_framebufferBinding(0)
, m_activeTextureUnit(GraphicsContext3D::TEXTURE0)
, m_context(context)
, m_size(-1, -1)
, m_multisampleExtensionSupported(multisampleExtensionSupported)
, m_packedDepthStencilExtensionSupported(packedDepthStencilExtensionSupported)
, m_fbo(0)
, m_colorBuffer(0)
, m_frontColorBuffer(0)
, m_separateFrontTexture(false)
, m_depthStencilBuffer(0)
, m_depthBuffer(0)
, m_stencilBuffer(0)
, m_multisampleFBO(0)
, m_multisampleColorBuffer(0)
, m_contentsChanged(true)
, m_internalColorFormat(0)
, m_colorFormat(0)
, m_internalRenderbufferFormat(0)
, m_maxTextureSize(0)
, m_contextEvictionManager(contextEvictionManager)
{
// Used by browser tests to detect the use of a DrawingBuffer.
TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation");
// Before enabling mailboxes for canvas, make sure the scenarios
// from http://crbug.com/234428 do not reproduce!
#if !ENABLE(CANVAS_USES_MAILBOX)
// We need a separate front and back textures if ...
m_separateFrontTexture = m_preserveDrawingBuffer == Preserve // ... we have to preserve contents after compositing, which is done with a copy or ...
|| WebKit::Platform::current()->isThreadedCompositingEnabled(); // ... if we're in threaded mode and need to double buffer.
#if OS(DARWIN)
// http://crbug.com/234428 : always use a separate front texture
// on Mac OS. Doing this on all GPUs, not just NVIDIA GPUs,
// ensures consistent behavior and is much less code.
m_separateFrontTexture = true;
#endif // OS(DARWIN)
#endif // !ENABLE(CANVAS_USES_MAILBOX)
initialize(size);
}
void WebCompositorInputHandlerImpl::animate(double monotonicTime)
{
if (!m_wheelFlingAnimation)
return;
if (!m_wheelFlingParameters.startTime)
m_wheelFlingParameters.startTime = monotonicTime;
if (m_wheelFlingAnimation->animate(monotonicTime))
m_inputHandlerClient->scheduleAnimation();
else {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::animate::flingOver");
cancelCurrentFling();
}
}
void WebCompositorInputHandlerImpl::animate(double monotonicTime)
{
if (!m_flingCurve)
return;
if (!m_flingParameters.startTime) {
m_flingParameters.startTime = monotonicTime;
m_inputHandlerClient->scheduleAnimation();
return;
}
if (m_flingCurve->apply(monotonicTime - m_flingParameters.startTime, this))
m_inputHandlerClient->scheduleAnimation();
else {
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::animate::flingOver");
cancelCurrentFling();
}
}
Canvas2DLayerBridge::Canvas2DLayerBridge(PassRefPtr<GraphicsContext3D> context, SkDeferredCanvas* canvas, OpacityMode opacityMode)
: m_canvas(canvas)
, m_context(context)
, m_bytesAllocated(0)
, m_didRecordDrawCommand(false)
, m_surfaceIsValid(true)
, m_framesPending(0)
, m_rateLimitingEnabled(false)
, m_next(0)
, m_prev(0)
, m_lastImageId(0)
{
ASSERT(m_canvas);
// Used by browser tests to detect the use of a Canvas2DLayerBridge.
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
m_layer = adoptPtr(WebKit::Platform::current()->compositorSupport()->createExternalTextureLayer(this));
m_layer->setOpaque(opacityMode == Opaque);
m_layer->setBlendBackgroundColor(opacityMode != Opaque);
GraphicsLayer::registerContentsLayer(m_layer->layer());
m_layer->setRateLimitContext(m_rateLimitingEnabled);
m_canvas->setNotificationClient(this);
}
DrawingBuffer::DrawingBuffer(
PassOwnPtr<WebGraphicsContext3DProvider> contextProvider,
PassOwnPtr<Extensions3DUtil> extensionsUtil,
bool discardFramebufferSupported,
bool wantAlphaChannel,
bool premultipliedAlpha,
PreserveDrawingBuffer preserve,
bool wantDepth,
bool wantStencil)
: m_preserveDrawingBuffer(preserve)
, m_contextProvider(std::move(contextProvider))
, m_gl(m_contextProvider->contextGL())
, m_extensionsUtil(std::move(extensionsUtil))
, m_discardFramebufferSupported(discardFramebufferSupported)
, m_wantAlphaChannel(wantAlphaChannel)
, m_premultipliedAlpha(premultipliedAlpha)
, m_wantDepth(wantDepth)
, m_wantStencil(wantStencil)
{
memset(m_colorMask, 0, 4 * sizeof(GLboolean));
memset(m_clearColor, 0, 4 * sizeof(GLfloat));
// Used by browser tests to detect the use of a DrawingBuffer.
TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation", TRACE_EVENT_SCOPE_GLOBAL);
}
Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, PassOwnPtr<SkDeferredCanvas> canvas, PassRefPtr<SkSurface> surface, int msaaSampleCount, OpacityMode opacityMode)
: m_canvas(canvas)
, m_surface(surface)
, m_contextProvider(contextProvider)
, m_imageBuffer(0)
, m_msaaSampleCount(msaaSampleCount)
, m_bytesAllocated(0)
, m_didRecordDrawCommand(false)
, m_isSurfaceValid(true)
, m_framesPending(0)
, m_destructionInProgress(false)
, m_rateLimitingEnabled(false)
, m_filterLevel(SkPaint::kLow_FilterLevel)
, m_isHidden(false)
, m_next(0)
, m_prev(0)
, m_lastImageId(0)
, m_lastFilter(GL_LINEAR)
, m_opacityMode(opacityMode)
{
ASSERT(m_canvas);
ASSERT(m_surface);
ASSERT(m_contextProvider);
// Used by browser tests to detect the use of a Canvas2DLayerBridge.
TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation");
m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
m_layer->setOpaque(opacityMode == Opaque);
m_layer->setBlendBackgroundColor(opacityMode != Opaque);
GraphicsLayer::registerContentsLayer(m_layer->layer());
m_layer->setRateLimitContext(m_rateLimitingEnabled);
m_layer->setNearestNeighbor(m_filterLevel == SkPaint::kNone_FilterLevel);
m_canvas->setNotificationClient(this);
#ifndef NDEBUG
canvas2DLayerBridgeInstanceCounter.increment();
#endif
}
void InspectorTimelineAgent::didBeginFrame()
{
TRACE_EVENT_INSTANT0("webkit", InstrumentationEvents::BeginFrame);
m_pendingFrameRecord = TimelineRecordFactory::createGenericRecord(timestamp(), 0, TimelineRecordType::BeginFrame);
}
void LoggingAnnotator::setMarker(const char *markerName)
{
TRACE_EVENT_INSTANT0("gpu.angle", markerName);
}
