void WebViewHost::paintInvalidatedRegion()
{
#if ENABLE(REQUEST_ANIMATION_FRAME)
webWidget()->animate(0.0);
#endif
webWidget()->layout();
WebSize widgetSize = webWidget()->size();
WebRect clientRect(0, 0, widgetSize.width, widgetSize.height);
// Paint the canvas if necessary. Allow painting to generate extra rects
// for the first two calls. This is necessary because some WebCore rendering
// objects update their layout only when painted.
// Store the total area painted in total_paint. Then tell the gdk window
// to update that area after we're done painting it.
for (int i = 0; i < 3; ++i) {
// rect = intersect(proxy()->paintRect() , clientRect)
WebRect damageRect = proxy()->paintRect();
int left = max(damageRect.x, clientRect.x);
int top = max(damageRect.y, clientRect.y);
int right = min(damageRect.x + damageRect.width, clientRect.x + clientRect.width);
int bottom = min(damageRect.y + damageRect.height, clientRect.y + clientRect.height);
WebRect rect;
if (left < right && top < bottom)
rect = WebRect(left, top, right - left, bottom - top);
proxy()->setPaintRect(WebRect());
if (rect.isEmpty())
continue;
paintRect(rect);
}
ASSERT(proxy()->paintRect().isEmpty());
}
void WebPopupMenuImpl::paint(WebCanvas* canvas, const WebRect& rect)
{
if (!m_widget)
return;
if (!rect.isEmpty())
m_widget->paint(&GraphicsContextBuilder(canvas).context(), rect);
}
void WebPopupMenuImpl::paintContents(WebCanvas* canvas, const WebRect& rect, bool, WebFloatRect&)
{
if (!m_widget)
return;
if (!rect.isEmpty()) {
GraphicsContext context(canvas);
m_widget->paint(&context, rect);
}
}
void WebPopupMenuImpl::paint(WebCanvas* canvas, const WebRect& rect, PaintOptions)
{
if (!m_widget)
return;
if (!rect.isEmpty()) {
GraphicsContext context(canvas);
context.applyDeviceScaleFactor(m_client->deviceScaleFactor());
m_widget->paint(&context, rect);
}
}
void WebPopupMenuImpl::paintContents(WebCanvas* canvas, const WebRect& rect, bool, WebContentLayerClient::GraphicsContextStatus contextStatus)
{
if (!m_widget)
return;
if (!rect.isEmpty()) {
GraphicsContext context(canvas,
contextStatus == WebContentLayerClient::GraphicsContextEnabled ? GraphicsContext::NothingDisabled : GraphicsContext::FullyDisabled);
m_widget->paint(&context, rect);
}
}
void WebPopupMenuImpl::paint(WebCanvas* canvas, const WebRect& rect)
{
if (!m_widget)
return;
if (!rect.isEmpty()) {
OwnPtr<GraphicsContext> context = GraphicsContext::deprecatedCreateWithCanvas(canvas);
float scaleFactor = m_client->deviceScaleFactor();
context->scale(scaleFactor, scaleFactor);
m_widget->paint(context.get(), rect);
}
}
void WebViewHost::updatePaintRect(const WebRect& rect)
{
// m_paintRect = m_paintRect U rect
if (rect.isEmpty())
return;
if (m_paintRect.isEmpty()) {
m_paintRect = rect;
return;
}
int left = min(m_paintRect.x, rect.x);
int top = min(m_paintRect.y, rect.y);
int right = max(m_paintRect.x + m_paintRect.width, rect.x + rect.width);
int bottom = max(m_paintRect.y + m_paintRect.height, rect.y + rect.height);
m_paintRect = WebRect(left, top, right - left, bottom - top);
}
void PageWidgetDelegate::paint(Page* page, PageOverlayList* overlays, WebCanvas* canvas, const WebRect& rect, CanvasBackground background)
{
if (rect.isEmpty())
return;
GraphicsContextBuilder builder(canvas);
GraphicsContext& gc = builder.context();
gc.platformContext()->setDrawingToImageBuffer(background == Opaque ? false : true);
gc.applyDeviceScaleFactor(page->deviceScaleFactor());
IntRect dirtyRect(rect);
gc.save();
FrameView* view = mainFrameView(page);
// FIXME: Can we remove the mainFrame()->document() check?
if (view && page->mainFrame()->document()) {
gc.clip(dirtyRect);
view->paint(&gc, dirtyRect);
if (overlays)
overlays->paintWebFrame(gc);
} else
gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);
gc.restore();
}
void PageWidgetDelegate::paint(Page* page, PageOverlayList* overlays, WebCanvas* canvas, const WebRect& rect, CanvasBackground background)
{
if (rect.isEmpty())
return;
GraphicsContext gc(canvas);
gc.setCertainlyOpaque(background == Opaque);
gc.applyDeviceScaleFactor(page->deviceScaleFactor());
gc.setUseHighResMarkers(page->deviceScaleFactor() > 1.5f);
IntRect dirtyRect(rect);
gc.save(); // Needed to save the canvas, not the GraphicsContext.
FrameView* view = mainFrameView(page);
// FIXME: Can we remove the mainFrame()->document() check?
if (view && page->mainFrame()->document()) {
gc.clip(dirtyRect);
view->paint(&gc, dirtyRect);
if (overlays)
overlays->paintWebFrame(gc);
} else {
gc.fillRect(dirtyRect, Color::white);
}
gc.restore();
}
void PageWidgetDelegate::paint(Page& page, PageOverlayList* overlays, WebCanvas* canvas, const WebRect& rect, CanvasBackground background, LocalFrame& root)
{
if (rect.isEmpty())
return;
GraphicsContext gc(canvas, nullptr);
gc.setCertainlyOpaque(background == Opaque);
float scaleFactor = page.deviceScaleFactor();
gc.scale(scaleFactor, scaleFactor);
gc.setDeviceScaleFactor(scaleFactor);
IntRect dirtyRect(rect);
gc.save(); // Needed to save the canvas, not the GraphicsContext.
FrameView* view = root.view();
if (view) {
gc.clip(dirtyRect);
view->paint(&gc, dirtyRect);
if (overlays)
overlays->paintWebFrame(gc);
} else {
gc.fillRect(dirtyRect, Color::white);
}
gc.restore();
}
void TestShell::dump()
{
WebScriptController::flushConsoleMessages();
// Dump the requested representation.
WebFrame* frame = m_webView->mainFrame();
if (!frame)
return;
bool shouldDumpAsText = m_layoutTestController->shouldDumpAsText();
bool shouldDumpAsAudio = m_layoutTestController->shouldDumpAsAudio();
bool shouldGeneratePixelResults = m_layoutTestController->shouldGeneratePixelResults();
bool shouldDumpAsPrinted = m_layoutTestController->isPrinting();
bool dumpedAnything = false;
if (shouldDumpAsAudio) {
m_printer->handleAudioHeader();
const WebKit::WebArrayBufferView& webArrayBufferView = m_layoutTestController->audioData();
printf("Content-Length: %d\n", webArrayBufferView.byteLength());
if (fwrite(webArrayBufferView.baseAddress(), 1, webArrayBufferView.byteLength(), stdout) != webArrayBufferView.byteLength())
FATAL("Short write to stdout, disk full?\n");
printf("\n");
m_printer->handleTestFooter(true);
fflush(stdout);
fflush(stderr);
return;
}
if (m_params.dumpTree) {
dumpedAnything = true;
m_printer->handleTextHeader();
// Text output: the test page can request different types of output
// which we handle here.
if (!shouldDumpAsText) {
// Plain text pages should be dumped as text
string mimeType = frame->dataSource()->response().mimeType().utf8();
if (mimeType == "text/plain") {
shouldDumpAsText = true;
shouldGeneratePixelResults = false;
}
}
if (shouldDumpAsText) {
bool recursive = m_layoutTestController->shouldDumpChildFramesAsText();
string dataUtf8 = shouldDumpAsPrinted ? dumpFramesAsPrintedText(frame, recursive) : dumpFramesAsText(frame, recursive);
if (fwrite(dataUtf8.c_str(), 1, dataUtf8.size(), stdout) != dataUtf8.size())
FATAL("Short write to stdout, disk full?\n");
} else {
WebFrame::RenderAsTextControls renderTextBehavior = WebFrame::RenderAsTextNormal;
if (shouldDumpAsPrinted)
renderTextBehavior |= WebFrame::RenderAsTextPrinting;
if (m_params.debugRenderTree)
renderTextBehavior |= WebFrame::RenderAsTextDebug;
printf("%s", frame->renderTreeAsText(renderTextBehavior).utf8().data());
bool recursive = m_layoutTestController->shouldDumpChildFrameScrollPositions();
dumpFrameScrollPosition(frame, recursive);
}
if (m_layoutTestController->shouldDumpBackForwardList())
printf("%s", dumpAllBackForwardLists().c_str());
}
if (dumpedAnything && m_params.printSeparators)
m_printer->handleTextFooter();
if (m_params.dumpPixels && shouldGeneratePixelResults) {
// Image output: we write the image data to the file given on the
// command line (for the dump pixels argument), and the MD5 sum to
// stdout.
dumpedAnything = true;
m_webView->layout();
if (m_layoutTestController->testRepaint()) {
WebSize viewSize = m_webView->size();
int width = viewSize.width;
int height = viewSize.height;
if (m_layoutTestController->sweepHorizontally()) {
for (WebRect column(0, 0, 1, height); column.x < width; column.x++)
m_webViewHost->paintRect(column);
} else {
for (WebRect line(0, 0, width, 1); line.y < height; line.y++)
m_webViewHost->paintRect(line);
}
} else if (m_layoutTestController->isPrinting())
m_webViewHost->paintPagesWithBoundaries();
else
m_webViewHost->paintInvalidatedRegion();
// See if we need to draw the selection bounds rect. Selection bounds
// rect is the rect enclosing the (possibly transformed) selection.
// The rect should be drawn after everything is laid out and painted.
if (m_layoutTestController->shouldDumpSelectionRect()) {
// If there is a selection rect - draw a red 1px border enclosing rect
WebRect wr = frame->selectionBoundsRect();
if (!wr.isEmpty()) {
// Render a red rectangle bounding selection rect
SkPaint paint;
paint.setColor(0xFFFF0000); // Fully opaque red
paint.setStyle(SkPaint::kStroke_Style);
paint.setFlags(SkPaint::kAntiAlias_Flag);
paint.setStrokeWidth(1.0f);
SkIRect rect; // Bounding rect
rect.set(wr.x, wr.y, wr.x + wr.width, wr.y + wr.height);
m_webViewHost->canvas()->drawIRect(rect, paint);
}
}
dumpImage(m_webViewHost->canvas());
}
m_printer->handleImageFooter();
m_printer->handleTestFooter(dumpedAnything);
fflush(stdout);
fflush(stderr);
}