OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkData.h" | 8 #include "SkData.h" |
9 #include "SkLazyPtr.h" | 9 #include "SkLazyPtr.h" |
10 #include "SkOSFile.h" | 10 #include "SkOSFile.h" |
11 #include "SkReadBuffer.h" | 11 #include "SkReadBuffer.h" |
12 #include "SkStream.h" | 12 #include "SkStream.h" |
13 #include "SkWriteBuffer.h" | 13 #include "SkWriteBuffer.h" |
14 | 14 |
| 15 #ifdef SK_SUPPORT_LEGACY_DATARELEASEPROC_PARAMS |
| 16 SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context, |
| 17 LegacyReleaseProc legacyProc) { |
| 18 #else |
15 SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) { | 19 SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) { |
| 20 #endif |
16 fPtr = const_cast<void*>(ptr); | 21 fPtr = const_cast<void*>(ptr); |
17 fSize = size; | 22 fSize = size; |
18 fReleaseProc = proc; | 23 fReleaseProc = proc; |
19 fReleaseProcContext = context; | 24 fReleaseProcContext = context; |
| 25 #ifdef SK_SUPPORT_LEGACY_DATARELEASEPROC_PARAMS |
| 26 fLegacyReleaseProc = legacyProc; |
| 27 #endif |
20 } | 28 } |
21 | 29 |
22 // This constructor means we are inline with our fPtr's contents. Thus we set fP
tr | 30 // This constructor means we are inline with our fPtr's contents. Thus we set fP
tr |
23 // to point right after this. We also set our releaseproc to sk_inplace_sentinel
_releaseproc, | 31 // to point right after this. We also set our releaseproc to sk_inplace_sentinel
_releaseproc, |
24 // since we need to handle "delete" ourselves. See internal_displose(). | 32 // since we need to handle "delete" ourselves. See internal_displose(). |
25 // | 33 // |
26 SkData::SkData(size_t size) { | 34 SkData::SkData(size_t size) { |
27 fPtr = (char*)(this + 1); // contents are immediately after this | 35 fPtr = (char*)(this + 1); // contents are immediately after this |
28 fSize = size; | 36 fSize = size; |
29 fReleaseProc = NULL; | 37 fReleaseProc = NULL; |
30 fReleaseProcContext = NULL; | 38 fReleaseProcContext = NULL; |
| 39 #ifdef SK_SUPPORT_LEGACY_DATARELEASEPROC_PARAMS |
| 40 fLegacyReleaseProc = NULL; |
| 41 #endif |
31 } | 42 } |
32 | 43 |
33 SkData::~SkData() { | 44 SkData::~SkData() { |
34 if (fReleaseProc) { | 45 if (fReleaseProc) { |
35 fReleaseProc(fPtr, fSize, fReleaseProcContext); | 46 fReleaseProc(fPtr, fReleaseProcContext); |
36 } | 47 } |
| 48 #ifdef SK_SUPPORT_LEGACY_DATARELEASEPROC_PARAMS |
| 49 if (fLegacyReleaseProc) { |
| 50 fLegacyReleaseProc(fPtr, fSize, fReleaseProcContext); |
| 51 } |
| 52 #endif |
37 } | 53 } |
38 | 54 |
39 bool SkData::equals(const SkData* other) const { | 55 bool SkData::equals(const SkData* other) const { |
40 if (NULL == other) { | 56 if (NULL == other) { |
41 return false; | 57 return false; |
42 } | 58 } |
43 | 59 |
44 return fSize == other->fSize && !memcmp(fPtr, other->fPtr, fSize); | 60 return fSize == other->fSize && !memcmp(fPtr, other->fPtr, fSize); |
45 } | 61 } |
46 | 62 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
84 SkData* sk_new_empty_data() { return new SkData(NULL, 0, NULL, NULL); } | 100 SkData* sk_new_empty_data() { return new SkData(NULL, 0, NULL, NULL); } |
85 namespace { void sk_unref_data(SkData* ptr) { return SkSafeUnref(ptr); } } | 101 namespace { void sk_unref_data(SkData* ptr) { return SkSafeUnref(ptr); } } |
86 | 102 |
87 SK_DECLARE_STATIC_LAZY_PTR(SkData, empty, sk_new_empty_data, sk_unref_data); | 103 SK_DECLARE_STATIC_LAZY_PTR(SkData, empty, sk_new_empty_data, sk_unref_data); |
88 | 104 |
89 SkData* SkData::NewEmpty() { | 105 SkData* SkData::NewEmpty() { |
90 return SkRef(empty.get()); | 106 return SkRef(empty.get()); |
91 } | 107 } |
92 | 108 |
93 // assumes fPtr was allocated via sk_malloc | 109 // assumes fPtr was allocated via sk_malloc |
94 static void sk_free_releaseproc(const void* ptr, size_t, void*) { | 110 static void sk_free_releaseproc(const void* ptr, void*) { |
95 sk_free((void*)ptr); | 111 sk_free((void*)ptr); |
96 } | 112 } |
97 | 113 |
98 SkData* SkData::NewFromMalloc(const void* data, size_t length) { | 114 SkData* SkData::NewFromMalloc(const void* data, size_t length) { |
99 return new SkData(data, length, sk_free_releaseproc, NULL); | 115 return new SkData(data, length, sk_free_releaseproc, NULL); |
100 } | 116 } |
101 | 117 |
102 SkData* SkData::NewWithCopy(const void* src, size_t length) { | 118 SkData* SkData::NewWithCopy(const void* src, size_t length) { |
103 SkASSERT(src); | 119 SkASSERT(src); |
104 return PrivateNewWithCopy(src, length); | 120 return PrivateNewWithCopy(src, length); |
105 } | 121 } |
106 | 122 |
107 SkData* SkData::NewUninitialized(size_t length) { | 123 SkData* SkData::NewUninitialized(size_t length) { |
108 return PrivateNewWithCopy(NULL, length); | 124 return PrivateNewWithCopy(NULL, length); |
109 } | 125 } |
110 | 126 |
111 SkData* SkData::NewWithProc(const void* data, size_t length, | 127 SkData* SkData::NewWithProc(const void* ptr, size_t length, ReleaseProc proc, vo
id* context) { |
112 ReleaseProc proc, void* context) { | 128 return new SkData(ptr, length, proc, context); |
113 return new SkData(data, length, proc, context); | |
114 } | 129 } |
115 | 130 |
| 131 #ifdef SK_SUPPORT_LEGACY_DATARELEASEPROC_PARAMS |
| 132 SkData* SkData::NewWithProc(const void* ptr, size_t length, LegacyReleaseProc pr
oc, void* ctx) { |
| 133 return new SkData(ptr, length, NULL, ctx, proc); |
| 134 } |
| 135 #endif |
| 136 |
116 // assumes fPtr was allocated with sk_fmmap | 137 // assumes fPtr was allocated with sk_fmmap |
117 static void sk_mmap_releaseproc(const void* addr, size_t length, void*) { | 138 static void sk_mmap_releaseproc(const void* addr, void* ctx) { |
| 139 size_t length = reinterpret_cast<size_t>(ctx); |
118 sk_fmunmap(addr, length); | 140 sk_fmunmap(addr, length); |
119 } | 141 } |
120 | 142 |
121 SkData* SkData::NewFromFILE(SkFILE* f) { | 143 SkData* SkData::NewFromFILE(SkFILE* f) { |
122 size_t size; | 144 size_t size; |
123 void* addr = sk_fmmap(f, &size); | 145 void* addr = sk_fmmap(f, &size); |
124 if (NULL == addr) { | 146 if (NULL == addr) { |
125 return NULL; | 147 return NULL; |
126 } | 148 } |
127 | 149 |
128 return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL); | 150 return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast
<void*>(size)); |
129 } | 151 } |
130 | 152 |
131 SkData* SkData::NewFromFileName(const char path[]) { | 153 SkData* SkData::NewFromFileName(const char path[]) { |
132 SkFILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : NULL; | 154 SkFILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : NULL; |
133 if (NULL == f) { | 155 if (NULL == f) { |
134 return NULL; | 156 return NULL; |
135 } | 157 } |
136 SkData* data = NewFromFILE(f); | 158 SkData* data = NewFromFILE(f); |
137 sk_fclose(f); | 159 sk_fclose(f); |
138 return data; | 160 return data; |
139 } | 161 } |
140 | 162 |
141 SkData* SkData::NewFromFD(int fd) { | 163 SkData* SkData::NewFromFD(int fd) { |
142 size_t size; | 164 size_t size; |
143 void* addr = sk_fdmmap(fd, &size); | 165 void* addr = sk_fdmmap(fd, &size); |
144 if (NULL == addr) { | 166 if (NULL == addr) { |
145 return NULL; | 167 return NULL; |
146 } | 168 } |
147 | 169 |
148 return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL); | 170 return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL); |
149 } | 171 } |
150 | 172 |
151 // assumes context is a SkData | 173 // assumes context is a SkData |
152 static void sk_dataref_releaseproc(const void*, size_t, void* context) { | 174 static void sk_dataref_releaseproc(const void*, void* context) { |
153 SkData* src = reinterpret_cast<SkData*>(context); | 175 SkData* src = reinterpret_cast<SkData*>(context); |
154 src->unref(); | 176 src->unref(); |
155 } | 177 } |
156 | 178 |
157 SkData* SkData::NewSubset(const SkData* src, size_t offset, size_t length) { | 179 SkData* SkData::NewSubset(const SkData* src, size_t offset, size_t length) { |
158 /* | 180 /* |
159 We could, if we wanted/need to, just make a deep copy of src's data, | 181 We could, if we wanted/need to, just make a deep copy of src's data, |
160 rather than referencing it. This would duplicate the storage (of the | 182 rather than referencing it. This would duplicate the storage (of the |
161 subset amount) but would possibly allow src to go out of scope sooner. | 183 subset amount) but would possibly allow src to go out of scope sooner. |
162 */ | 184 */ |
(...skipping 27 matching lines...) Expand all Loading... |
190 /////////////////////////////////////////////////////////////////////////////// | 212 /////////////////////////////////////////////////////////////////////////////// |
191 | 213 |
192 SkData* SkData::NewFromStream(SkStream* stream, size_t size) { | 214 SkData* SkData::NewFromStream(SkStream* stream, size_t size) { |
193 SkAutoDataUnref data(SkData::NewUninitialized(size)); | 215 SkAutoDataUnref data(SkData::NewUninitialized(size)); |
194 if (stream->read(data->writable_data(), size) != size) { | 216 if (stream->read(data->writable_data(), size) != size) { |
195 return NULL; | 217 return NULL; |
196 } | 218 } |
197 return data.detach(); | 219 return data.detach(); |
198 } | 220 } |
199 | 221 |
OLD | NEW |