gfx/skia/trunk/src/core/SkDataTable.cpp@129ffea94266
gfx/skia/trunk/src/core/SkDataTable.cpp
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
8 #include "SkData.h"
9 #include "SkDataTable.h"
11 static void malloc_freeproc(void* context) {
12 sk_free(context);
13 }
15 // Makes empty table
16 SkDataTable::SkDataTable() {
17 fCount = 0;
18 fElemSize = 0; // 0 signals that we use fDir instead of fElems
19 fU.fDir = NULL;
20 fFreeProc = NULL;
21 fFreeProcContext = NULL;
22 }
24 SkDataTable::SkDataTable(const void* array, size_t elemSize, int count,
25 FreeProc proc, void* context) {
26 SkASSERT(count > 0);
28 fCount = count;
29 fElemSize = elemSize; // non-zero signals we use fElems instead of fDir
30 fU.fElems = (const char*)array;
31 fFreeProc = proc;
32 fFreeProcContext = context;
33 }
35 SkDataTable::SkDataTable(const Dir* dir, int count, FreeProc proc, void* ctx) {
36 SkASSERT(count > 0);
38 fCount = count;
39 fElemSize = 0; // 0 signals that we use fDir instead of fElems
40 fU.fDir = dir;
41 fFreeProc = proc;
42 fFreeProcContext = ctx;
43 }
45 SkDataTable::~SkDataTable() {
46 if (fFreeProc) {
47 fFreeProc(fFreeProcContext);
48 }
49 }
51 size_t SkDataTable::atSize(int index) const {
52 SkASSERT((unsigned)index < (unsigned)fCount);
54 if (fElemSize) {
55 return fElemSize;
56 } else {
57 return fU.fDir[index].fSize;
58 }
59 }
61 const void* SkDataTable::at(int index, size_t* size) const {
62 SkASSERT((unsigned)index < (unsigned)fCount);
64 if (fElemSize) {
65 if (size) {
66 *size = fElemSize;
67 }
68 return fU.fElems + index * fElemSize;
69 } else {
70 if (size) {
71 *size = fU.fDir[index].fSize;
72 }
73 return fU.fDir[index].fPtr;
74 }
75 }
77 ///////////////////////////////////////////////////////////////////////////////
79 SkDataTable* SkDataTable::NewEmpty() {
80 static SkDataTable* gEmpty;
81 if (NULL == gEmpty) {
82 gEmpty = SkNEW(SkDataTable);
83 }
84 gEmpty->ref();
85 return gEmpty;
86 }
88 SkDataTable* SkDataTable::NewCopyArrays(const void * const * ptrs,
89 const size_t sizes[], int count) {
90 if (count <= 0) {
91 return SkDataTable::NewEmpty();
92 }
94 size_t dataSize = 0;
95 for (int i = 0; i < count; ++i) {
96 dataSize += sizes[i];
97 }
99 size_t bufferSize = count * sizeof(Dir) + dataSize;
100 void* buffer = sk_malloc_throw(bufferSize);
102 Dir* dir = (Dir*)buffer;
103 char* elem = (char*)(dir + count);
104 for (int i = 0; i < count; ++i) {
105 dir[i].fPtr = elem;
106 dir[i].fSize = sizes[i];
107 memcpy(elem, ptrs[i], sizes[i]);
108 elem += sizes[i];
109 }
111 return SkNEW_ARGS(SkDataTable, (dir, count, malloc_freeproc, buffer));
112 }
114 SkDataTable* SkDataTable::NewCopyArray(const void* array, size_t elemSize,
115 int count) {
116 if (count <= 0) {
117 return SkDataTable::NewEmpty();
118 }
120 size_t bufferSize = elemSize * count;
121 void* buffer = sk_malloc_throw(bufferSize);
122 memcpy(buffer, array, bufferSize);
124 return SkNEW_ARGS(SkDataTable,
125 (buffer, elemSize, count, malloc_freeproc, buffer));
126 }
128 SkDataTable* SkDataTable::NewArrayProc(const void* array, size_t elemSize,
129 int count, FreeProc proc, void* ctx) {
130 if (count <= 0) {
131 return SkDataTable::NewEmpty();
132 }
133 return SkNEW_ARGS(SkDataTable, (array, elemSize, count, proc, ctx));
134 }
136 ///////////////////////////////////////////////////////////////////////////////
138 static void chunkalloc_freeproc(void* context) {
139 SkDELETE((SkChunkAlloc*)context);
140 }
142 SkDataTableBuilder::SkDataTableBuilder(size_t minChunkSize)
143 : fHeap(NULL)
144 , fMinChunkSize(minChunkSize) {}
146 SkDataTableBuilder::~SkDataTableBuilder() { this->reset(); }
148 void SkDataTableBuilder::reset(size_t minChunkSize) {
149 fMinChunkSize = minChunkSize;
150 fDir.reset();
151 if (fHeap) {
152 SkDELETE(fHeap);
153 fHeap = NULL;
154 }
155 }
157 void SkDataTableBuilder::append(const void* src, size_t size) {
158 if (NULL == fHeap) {
159 fHeap = SkNEW_ARGS(SkChunkAlloc, (fMinChunkSize));
160 }
162 void* dst = fHeap->alloc(size, SkChunkAlloc::kThrow_AllocFailType);
163 memcpy(dst, src, size);
165 SkDataTable::Dir* dir = fDir.append();
166 dir->fPtr = dst;
167 dir->fSize = size;
168 }
170 SkDataTable* SkDataTableBuilder::detachDataTable() {
171 const int count = fDir.count();
172 if (0 == count) {
173 return SkDataTable::NewEmpty();
174 }
176 // Copy the dir into the heap;
177 void* dir = fHeap->alloc(count * sizeof(SkDataTable::Dir),
178 SkChunkAlloc::kThrow_AllocFailType);
179 memcpy(dir, fDir.begin(), count * sizeof(SkDataTable::Dir));
181 SkDataTable* table = SkNEW_ARGS(SkDataTable,
182 ((SkDataTable::Dir*)dir, count,
183 chunkalloc_freeproc, fHeap));
184 // we have to detach our fHeap, since we are giving that to the table
185 fHeap = NULL;
186 fDir.reset();
187 return table;
188 }
