Message decoding functions should take a MessageDecoder reference
[WebKit-https.git] / Source / WebKit2 / Shared / ShareableBitmap.h
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef ShareableBitmap_h
27 #define ShareableBitmap_h
28
29 #include "SharedMemory.h"
30 #include <WebCore/IntRect.h>
31 #include <wtf/PassOwnPtr.h>
32 #include <wtf/PassRefPtr.h>
33 #include <wtf/RefCounted.h>
34 #include <wtf/RefPtr.h>
35
36 #if USE(CG)
37 #include <wtf/RetainPtr.h>
38 #endif
39
40 #if USE(CAIRO)
41 #include <WebCore/RefPtrCairo.h>
42 #endif
43
44 #if PLATFORM(QT)
45 #include <QImage>
46 #ifdef Q_WS_X11
47 // Avoid ambiguity caused by the Region typedef from qwindowdefs.h.
48 namespace WebCore { class Region; }
49 namespace WebKit { using WebCore::Region; }
50 #endif
51 #endif
52
53 namespace WebCore {
54     class Image;
55     class GraphicsContext;
56 }
57
58 namespace WebKit {
59     
60 class ShareableBitmap : public RefCounted<ShareableBitmap> {
61 public:
62     enum Flag {
63         NoFlags = 0,
64         SupportsAlpha = 1 << 0,
65     };
66     typedef unsigned Flags;
67
68     class Handle {
69         WTF_MAKE_NONCOPYABLE(Handle);
70     public:
71         Handle();
72
73         bool isNull() const { return m_handle.isNull(); }
74
75         void encode(CoreIPC::ArgumentEncoder&) const;
76         static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
77
78     private:
79         friend class ShareableBitmap;
80
81         mutable SharedMemory::Handle m_handle;
82         WebCore::IntSize m_size;
83         Flags m_flags;
84     };
85
86     // Create a shareable bitmap that uses malloced memory.
87     static PassRefPtr<ShareableBitmap> create(const WebCore::IntSize&, Flags);
88
89     // Create a shareable bitmap whose backing memory can be shared with another process.
90     static PassRefPtr<ShareableBitmap> createShareable(const WebCore::IntSize&, Flags);
91
92     // Create a shareable bitmap from an already existing shared memory block.
93     static PassRefPtr<ShareableBitmap> create(const WebCore::IntSize&, Flags, PassRefPtr<SharedMemory>);
94
95     // Create a shareable bitmap from a handle.
96     static PassRefPtr<ShareableBitmap> create(const Handle&, SharedMemory::Protection = SharedMemory::ReadWrite);
97
98     // Create a handle.
99     bool createHandle(Handle&, SharedMemory::Protection = SharedMemory::ReadWrite);
100
101     ~ShareableBitmap();
102
103     const WebCore::IntSize& size() const { return m_size; }
104     WebCore::IntRect bounds() const { return WebCore::IntRect(WebCore::IntPoint(), size()); }
105
106     bool resize(const WebCore::IntSize& size);
107
108     // Create a graphics context that can be used to paint into the backing store.
109     PassOwnPtr<WebCore::GraphicsContext> createGraphicsContext();
110
111     // Paint the backing store into the given context.
112     void paint(WebCore::GraphicsContext&, const WebCore::IntPoint& destination, const WebCore::IntRect& source);
113     void paint(WebCore::GraphicsContext&, float scaleFactor, const WebCore::IntPoint& destination, const WebCore::IntRect& source);
114
115     bool isBackedBySharedMemory() const { return m_sharedMemory; }
116
117     // This creates a bitmap image that directly references the shared bitmap data.
118     // This is only safe to use when we know that the contents of the shareable bitmap won't change.
119     PassRefPtr<WebCore::Image> createImage();
120
121 #if USE(CG)
122     // This creates a copied CGImageRef (most likely a copy-on-write) of the shareable bitmap.
123     RetainPtr<CGImageRef> makeCGImageCopy();
124
125     // This creates a CGImageRef that directly references the shared bitmap data.
126     // This is only safe to use when we know that the contents of the shareable bitmap won't change.
127     RetainPtr<CGImageRef> makeCGImage();
128 #elif USE(CAIRO)
129     // This creates a BitmapImage that directly references the shared bitmap data.
130     // This is only safe to use when we know that the contents of the shareable bitmap won't change.
131     PassRefPtr<cairo_surface_t> createCairoSurface();
132 #elif PLATFORM(QT)
133     // This creates a QImage that directly references the shared bitmap data.
134     // This is only safe to use when we know that the contents of the shareable bitmap won't change.
135     QImage createQImage();
136     static void releaseSharedMemoryData(void* typelessBitmap);
137 #endif
138
139 private:
140     ShareableBitmap(const WebCore::IntSize&, Flags, void*);
141     ShareableBitmap(const WebCore::IntSize&, Flags, PassRefPtr<SharedMemory>);
142
143 #if USE(CAIRO)
144     static size_t numBytesForSize(const WebCore::IntSize&);
145 #else
146     static size_t numBytesForSize(const WebCore::IntSize& size) { return size.width() * size.height() * 4; }
147 #endif
148
149 #if USE(CG)
150     RetainPtr<CGImageRef> createCGImage(CGDataProviderRef) const;
151     static void releaseBitmapContextData(void* typelessBitmap, void* typelessData);
152     static void releaseDataProviderData(void* typelessBitmap, const void* typelessData, size_t);
153 #endif
154
155 #if USE(CAIRO)
156     static void releaseSurfaceData(void* typelessBitmap);
157 #endif
158
159     void* data() const;
160     size_t sizeInBytes() const { return numBytesForSize(m_size); }
161
162     WebCore::IntSize m_size;
163     Flags m_flags;
164
165     // If the shareable bitmap is backed by shared memory, this points to the shared memory object.
166     RefPtr<SharedMemory> m_sharedMemory;
167
168     // If the shareable bitmap is backed by fastMalloced memory, this points to the data.
169     void* m_data;
170 };
171
172 } // namespace WebKit
173
174 #endif // ShareableBitmap_h