ebeb7c18cdb94a08474e040ff9064207f1b51e97
[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         WTFLogAlways("DumpRenderTree: calloc(%llu, %llu) failed\n", pixelsHigh, rowBytes);
59         return nullptr;
60     }
61     
62     // Creating this bitmap in the device color space prevents any color conversion when the image of the web view is drawn into it.
63     RetainPtr<CGColorSpaceRef> colorSpace = adoptCF(CGColorSpaceCreateDeviceRGB());
64     CGContextRef context = CGBitmapContextCreate(buffer, pixelsWide, pixelsHigh, 8, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host); // Use ARGB8 on PPC or BGRA8 on X86 to improve CG performance
65     if (!context) {
66         free(buffer);
67         WTFLogAlways("DumpRenderTree: CGBitmapContextCreate(%p, %llu, %llu, 8, %llu, %p, 0x%x) failed\n", buffer, pixelsHigh, pixelsWide, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host);
68         return nullptr;
69     }
70
71     return BitmapContext::createByAdoptingBitmapAndContext(buffer, context);
72 }
73
74 static void paintRepaintRectOverlay(WebView* webView, CGContextRef context)
75 {
76     CGRect viewRect = NSRectToCGRect([webView bounds]);
77
78     CGContextSaveGState(context);
79
80     // Using a transparency layer is easier than futzing with clipping.
81     CGContextBeginTransparencyLayer(context, 0);
82
83     // Flip the context.
84     CGContextScaleCTM(context, 1, -1);
85     CGContextTranslateCTM(context, 0, -viewRect.size.height);
86     
87     CGContextSetRGBFillColor(context, 0, 0, 0, static_cast<CGFloat>(0.66));
88     CGContextFillRect(context, viewRect);
89
90     NSArray *repaintRects = [webView trackedRepaintRects];
91     if (repaintRects) {
92         
93         for (NSValue *value in repaintRects) {
94             CGRect currRect = NSRectToCGRect([value rectValue]);
95             CGContextClearRect(context, currRect);
96         }
97     }
98     
99     CGContextEndTransparencyLayer(context);
100     CGContextRestoreGState(context);
101 }
102
103 PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool onscreen, bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect)
104 {
105     WebView* view = [mainFrame webView];
106
107     // If the WebHTMLView uses accelerated compositing, we need for force the on-screen capture path
108     // and also force Core Animation to start its animations with -display since the DRT window has autodisplay disabled.
109     if ([view _isUsingAcceleratedCompositing])
110         onscreen = YES;
111
112     // If the window is layer-backed, its backing store will be empty, so we have to use a window server snapshot.
113     if ([view.window.contentView layer])
114         onscreen = YES;
115
116     float deviceScaleFactor = [view _backingScaleFactor];
117     NSSize webViewSize = [view frame].size;
118     size_t pixelsWide = static_cast<size_t>(webViewSize.width * deviceScaleFactor);
119     size_t pixelsHigh = static_cast<size_t>(webViewSize.height * deviceScaleFactor);
120     size_t rowBytes = 0;
121     void* buffer = nullptr;
122     RefPtr<BitmapContext> bitmapContext = createBitmapContext(pixelsWide, pixelsHigh, rowBytes, buffer);
123     if (!bitmapContext)
124         return nullptr;
125     CGContextRef context = bitmapContext->cgContext();
126     // The final scaling gets doubled on the screen capture surface when we use the hidpi backingScaleFactor value for CTM.
127     // This is a workaround to push the scaling back.
128     float scaleForCTM = onscreen ? 1 : [view _backingScaleFactor];
129     CGContextScaleCTM(context, scaleForCTM, scaleForCTM);
130
131     NSGraphicsContext *nsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
132     ASSERT(nsContext);
133     
134     if (incrementalRepaint) {
135         if (sweepHorizontally) {
136             for (NSRect column = NSMakeRect(0, 0, 1, webViewSize.height); column.origin.x < webViewSize.width; column.origin.x++)
137                 [view displayRectIgnoringOpacity:column inContext:nsContext];
138         } else {
139             for (NSRect line = NSMakeRect(0, 0, webViewSize.width, 1); line.origin.y < webViewSize.height; line.origin.y++)
140                 [view displayRectIgnoringOpacity:line inContext:nsContext];
141         }
142     } else {
143       if (onscreen) {
144             // FIXME: This will break repaint testing if we have compositing in repaint tests.
145             // (displayWebView() painted gray over the webview, but we'll be making everything repaint again).
146             [view display];
147             [CATransaction flush];
148             [CATransaction synchronize];
149
150             // Ask the window server to provide us a composited version of the *real* window content including surfaces (i.e. OpenGL content)
151             // Note that the returned image might differ very slightly from the window backing because of dithering artifacts in the window server compositor.
152             CGImageRef image = CGWindowListCreateImage(CGRectNull, kCGWindowListOptionIncludingWindow, [[view window] windowNumber], kCGWindowImageBoundsIgnoreFraming | kCGWindowImageShouldBeOpaque);
153             CGContextDrawImage(context, CGRectMake(0, 0, CGImageGetWidth(image), CGImageGetHeight(image)), image);
154             CGImageRelease(image);
155
156             if ([view isTrackingRepaints])
157                 paintRepaintRectOverlay(view, context);
158         } else if (deviceScaleFactor != 1) {
159             // Call displayRectIgnoringOpacity for HiDPI tests since it ensures we paint directly into the context
160             // that we have appropriately sized and scaled.
161             [view displayRectIgnoringOpacity:[view bounds] inContext:nsContext];
162             if ([view isTrackingRepaints])
163                 paintRepaintRectOverlay(view, context);
164         } else {
165             // Make sure the view has been painted.
166             [view displayIfNeeded];
167
168             // Grab directly the contents of the window backing buffer (this ignores any surfaces on the window)
169             // FIXME: This path is suboptimal: data is read from window backing store, converted to RGB8 then drawn again into an RGBA8 bitmap
170             [view lockFocus];
171             NSBitmapImageRep *imageRep = [[[NSBitmapImageRep alloc] initWithFocusedViewRect:[view frame]] autorelease];
172             [view unlockFocus];
173
174             RetainPtr<NSGraphicsContext> savedContext = [NSGraphicsContext currentContext];
175             [NSGraphicsContext setCurrentContext:nsContext];
176             [imageRep draw];
177             
178             if ([view isTrackingRepaints])
179                 paintRepaintRectOverlay(view, context);
180             
181             [NSGraphicsContext setCurrentContext:savedContext.get()];
182         }
183     }
184
185     if (drawSelectionRect) {
186         NSView *documentView = [[mainFrame frameView] documentView];
187         ASSERT([documentView conformsToProtocol:@protocol(WebDocumentSelection)]);
188         NSRect rect = [documentView convertRect:[(id <WebDocumentSelection>)documentView selectionRect] fromView:nil];
189         CGContextSaveGState(context);
190         CGContextSetLineWidth(context, 1.0);
191         CGContextSetRGBStrokeColor(context, 1.0, 0.0, 0.0, 1.0);
192         CGContextStrokeRect(context, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
193         CGContextRestoreGState(context);
194     }
195     
196     return bitmapContext.release();
197 }
198
199 PassRefPtr<BitmapContext> createPagedBitmapContext()
200 {
201     int pageWidthInPixels = TestRunner::viewWidth;
202     int pageHeightInPixels = TestRunner::viewHeight;
203     int numberOfPages = [mainFrame numberOfPagesWithPageWidth:pageWidthInPixels pageHeight:pageHeightInPixels];
204     size_t rowBytes = 0;
205     void* buffer = 0;
206
207     RefPtr<BitmapContext> bitmapContext = createBitmapContext(pageWidthInPixels, numberOfPages * (pageHeightInPixels + 1) - 1, rowBytes, buffer);
208     [mainFrame printToCGContext:bitmapContext->cgContext() pageWidth:pageWidthInPixels pageHeight:pageHeightInPixels];
209     return bitmapContext.release();
210 }