DumpRenderTree generates white snapshots on some platforms
[WebKit-https.git] / Tools / DumpRenderTree / mac / PixelDumpSupportMac.mm
1 /*
2  * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
3  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
4  *           (C) 2007 Eric Seidel <eric@webkit.org>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer. 
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution. 
15  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission. 
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #import "config.h"
32 #import "PixelDumpSupport.h"
33 #import "PixelDumpSupportCG.h"
34
35 #import "DumpRenderTree.h" 
36 #import "TestRunner.h"
37 #import <CoreGraphics/CGBitmapContext.h>
38 #import <QuartzCore/QuartzCore.h>
39 #import <wtf/Assertions.h>
40 #import <wtf/RefPtr.h>
41
42 #import <WebKit/WebCoreStatistics.h>
43 #import <WebKit/WebDocumentPrivate.h>
44 #import <WebKit/WebHTMLViewPrivate.h>
45 #import <WebKit/WebKit.h>
46 #import <WebKit/WebViewPrivate.h>
47
48 @interface CATransaction (Details)
49 + (void)synchronize;
50 @end
51
52 static PassRefPtr<BitmapContext> createBitmapContext(size_t pixelsWide, size_t pixelsHigh, size_t& rowBytes, void*& buffer)
53 {
54     rowBytes = (4 * pixelsWide + 63) & ~63; // Use a multiple of 64 bytes to improve CG performance
55
56     buffer = calloc(pixelsHigh, rowBytes);
57     if (!buffer)
58         return 0;
59     
60     // Creating this bitmap in the device color space prevents any color conversion when the image of the web view is drawn into it.
61     RetainPtr<CGColorSpaceRef> colorSpace = adoptCF(CGColorSpaceCreateDeviceRGB());
62     CGContextRef context = CGBitmapContextCreate(buffer, pixelsWide, pixelsHigh, 8, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host); // Use ARGB8 on PPC or BGRA8 on X86 to improve CG performance
63     if (!context) {
64         free(buffer);
65         return 0;
66     }
67
68     return BitmapContext::createByAdoptingBitmapAndContext(buffer, context);
69 }
70
71 static void paintRepaintRectOverlay(WebView* webView, CGContextRef context)
72 {
73     CGRect viewRect = NSRectToCGRect([webView bounds]);
74
75     CGContextSaveGState(context);
76
77     // Using a transparency layer is easier than futzing with clipping.
78     CGContextBeginTransparencyLayer(context, 0);
79
80     // Flip the context.
81     CGContextScaleCTM(context, 1, -1);
82     CGContextTranslateCTM(context, 0, -viewRect.size.height);
83     
84     CGContextSetRGBFillColor(context, 0, 0, 0, static_cast<CGFloat>(0.66));
85     CGContextFillRect(context, viewRect);
86
87     NSArray *repaintRects = [webView trackedRepaintRects];
88     if (repaintRects) {
89         
90         for (NSValue *value in repaintRects) {
91             CGRect currRect = NSRectToCGRect([value rectValue]);
92             CGContextClearRect(context, currRect);
93         }
94     }
95     
96     CGContextEndTransparencyLayer(context);
97     CGContextRestoreGState(context);
98 }
99
100 PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool onscreen, bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect)
101 {
102     WebView* view = [mainFrame webView];
103
104     // If the WebHTMLView uses accelerated compositing, we need for force the on-screen capture path
105     // and also force Core Animation to start its animations with -display since the DRT window has autodisplay disabled.
106     if ([view _isUsingAcceleratedCompositing])
107         onscreen = YES;
108
109     float deviceScaleFactor = [view _backingScaleFactor];
110     NSSize webViewSize = [view frame].size;
111     size_t pixelsWide = static_cast<size_t>(webViewSize.width * deviceScaleFactor);
112     size_t pixelsHigh = static_cast<size_t>(webViewSize.height * deviceScaleFactor);
113     size_t rowBytes = 0;
114     void* buffer = 0;
115     RefPtr<BitmapContext> bitmapContext = createBitmapContext(pixelsWide, pixelsHigh, rowBytes, buffer);
116     if (!bitmapContext)
117         return 0;
118     CGContextRef context = bitmapContext->cgContext();
119     // The final scaling gets doubled on the screen capture surface when we use the hidpi backingScaleFactor value for CTM.
120     // This is a workaround to push the scaling back.
121     float scaleForCTM = onscreen ? 1 : [view _backingScaleFactor];
122     CGContextScaleCTM(context, scaleForCTM, scaleForCTM);
123
124     NSGraphicsContext *nsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
125     ASSERT(nsContext);
126     
127     if (incrementalRepaint) {
128         if (sweepHorizontally) {
129             for (NSRect column = NSMakeRect(0, 0, 1, webViewSize.height); column.origin.x < webViewSize.width; column.origin.x++)
130                 [view displayRectIgnoringOpacity:column inContext:nsContext];
131         } else {
132             for (NSRect line = NSMakeRect(0, 0, webViewSize.width, 1); line.origin.y < webViewSize.height; line.origin.y++)
133                 [view displayRectIgnoringOpacity:line inContext:nsContext];
134         }
135     } else {
136       if (onscreen) {
137             // FIXME: This will break repaint testing if we have compositing in repaint tests.
138             // (displayWebView() painted gray over the webview, but we'll be making everything repaint again).
139             [view display];
140             [CATransaction flush];
141             [CATransaction synchronize];
142
143             // Ask the window server to provide us a composited version of the *real* window content including surfaces (i.e. OpenGL content)
144             // Note that the returned image might differ very slightly from the window backing because of dithering artifacts in the window server compositor.
145             CGImageRef image = CGWindowListCreateImage(CGRectNull, kCGWindowListOptionIncludingWindow, [[view window] windowNumber], kCGWindowImageBoundsIgnoreFraming | kCGWindowImageShouldBeOpaque);
146             CGContextDrawImage(context, CGRectMake(0, 0, CGImageGetWidth(image), CGImageGetHeight(image)), image);
147             CGImageRelease(image);
148
149             if ([view isTrackingRepaints])
150                 paintRepaintRectOverlay(view, context);
151         } else if (deviceScaleFactor != 1) {
152             // Call displayRectIgnoringOpacity for HiDPI tests since it ensures we paint directly into the context
153             // that we have appropriately sized and scaled.
154             [view displayRectIgnoringOpacity:[view bounds] inContext:nsContext];
155             if ([view isTrackingRepaints])
156                 paintRepaintRectOverlay(view, context);
157         } else {
158             // Make sure the view has been painted.
159             [view displayIfNeeded];
160
161             // Grab directly the contents of the window backing buffer (this ignores any surfaces on the window)
162             // FIXME: This path is suboptimal: data is read from window backing store, converted to RGB8 then drawn again into an RGBA8 bitmap
163             [view lockFocus];
164             NSBitmapImageRep *imageRep = [[[NSBitmapImageRep alloc] initWithFocusedViewRect:[view frame]] autorelease];
165             [view unlockFocus];
166
167             RetainPtr<NSGraphicsContext> savedContext = [NSGraphicsContext currentContext];
168             [NSGraphicsContext setCurrentContext:nsContext];
169             [imageRep draw];
170             
171             if ([view isTrackingRepaints])
172                 paintRepaintRectOverlay(view, context);
173             
174             [NSGraphicsContext setCurrentContext:savedContext.get()];
175         }
176     }
177
178     if (drawSelectionRect) {
179         NSView *documentView = [[mainFrame frameView] documentView];
180         ASSERT([documentView conformsToProtocol:@protocol(WebDocumentSelection)]);
181         NSRect rect = [documentView convertRect:[(id <WebDocumentSelection>)documentView selectionRect] fromView:nil];
182         CGContextSaveGState(context);
183         CGContextSetLineWidth(context, 1.0);
184         CGContextSetRGBStrokeColor(context, 1.0, 0.0, 0.0, 1.0);
185         CGContextStrokeRect(context, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
186         CGContextRestoreGState(context);
187     }
188     
189     return bitmapContext.release();
190 }
191
192 PassRefPtr<BitmapContext> createPagedBitmapContext()
193 {
194     int pageWidthInPixels = TestRunner::viewWidth;
195     int pageHeightInPixels = TestRunner::viewHeight;
196     int numberOfPages = [mainFrame numberOfPagesWithPageWidth:pageWidthInPixels pageHeight:pageHeightInPixels];
197     size_t rowBytes = 0;
198     void* buffer = 0;
199
200     RefPtr<BitmapContext> bitmapContext = createBitmapContext(pageWidthInPixels, numberOfPages * (pageHeightInPixels + 1) - 1, rowBytes, buffer);
201     [mainFrame printToCGContext:bitmapContext->cgContext() pageWidth:pageWidthInPixels pageHeight:pageHeightInPixels];
202     return bitmapContext.release();
203 }