gfx/skia/trunk/src/core/SkBuffer.cpp@129ffea94266
gfx/skia/trunk/src/core/SkBuffer.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.
2 /*
3 * Copyright 2006 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
10 #include "SkBuffer.h"
12 ////////////////////////////////////////////////////////////////////////////////////////
14 void SkRBuffer::readNoSizeCheck(void* buffer, size_t size)
15 {
16 SkASSERT((fData != 0 && fStop == 0) || fPos + size <= fStop);
17 if (buffer)
18 memcpy(buffer, fPos, size);
19 fPos += size;
20 }
22 const void* SkRBuffer::skip(size_t size)
23 {
24 const void* result = fPos;
25 readNoSizeCheck(NULL, size);
26 return result;
27 }
29 size_t SkRBuffer::skipToAlign4()
30 {
31 size_t pos = this->pos();
32 size_t n = SkAlign4(pos) - pos;
33 fPos += n;
34 return n;
35 }
37 bool SkRBufferWithSizeCheck::read(void* buffer, size_t size) {
38 fError = fError || (fPos + size > fStop);
39 if (!fError && (size > 0)) {
40 readNoSizeCheck(buffer, size);
41 }
42 return !fError;
43 }
45 void* SkWBuffer::skip(size_t size)
46 {
47 void* result = fPos;
48 writeNoSizeCheck(NULL, size);
49 return fData == NULL ? NULL : result;
50 }
52 void SkWBuffer::writeNoSizeCheck(const void* buffer, size_t size)
53 {
54 SkASSERT(fData == 0 || fStop == 0 || fPos + size <= fStop);
55 if (fData && buffer)
56 memcpy(fPos, buffer, size);
57 fPos += size;
58 }
60 size_t SkWBuffer::padToAlign4()
61 {
62 size_t pos = this->pos();
63 size_t n = SkAlign4(pos) - pos;
65 if (n && fData)
66 {
67 char* p = fPos;
68 char* stop = p + n;
69 do {
70 *p++ = 0;
71 } while (p < stop);
72 }
73 fPos += n;
74 return n;
75 }
77 #if 0
78 #ifdef SK_DEBUG
79 static void AssertBuffer32(const void* buffer)
80 {
81 SkASSERT(buffer);
82 SkASSERT(((size_t)buffer & 3) == 0);
83 }
84 #else
85 #define AssertBuffer32(buffer)
86 #endif
88 void* sk_buffer_write_int32(void* buffer, int32_t value)
89 {
90 AssertBuffer32(buffer);
91 *(int32_t*)buffer = value;
92 return (char*)buffer + sizeof(int32_t);
93 }
95 void* sk_buffer_write_int32(void* buffer, const int32_t values[], int count)
96 {
97 AssertBuffer32(buffer);
98 SkASSERT(count >= 0);
100 memcpy((int32_t*)buffer, values, count * sizeof(int32_t));
101 return (char*)buffer + count * sizeof(int32_t);
102 }
104 const void* sk_buffer_read_int32(const void* buffer, int32_t* value)
105 {
106 AssertBuffer32(buffer);
107 if (value)
108 *value = *(const int32_t*)buffer;
109 return (const char*)buffer + sizeof(int32_t);
110 }
112 const void* sk_buffer_read_int32(const void* buffer, int32_t values[], int count)
113 {
114 AssertBuffer32(buffer);
115 SkASSERT(count >= 0);
117 if (values)
118 memcpy(values, (const int32_t*)buffer, count * sizeof(int32_t));
119 return (const char*)buffer + count * sizeof(int32_t);
120 }
122 void* sk_buffer_write_ptr(void* buffer, void* ptr)
123 {
124 AssertBuffer32(buffer);
125 *(void**)buffer = ptr;
126 return (char*)buffer + sizeof(void*);
127 }
129 const void* sk_buffer_read_ptr(const void* buffer, void** ptr)
130 {
131 AssertBuffer32(buffer);
132 if (ptr)
133 *ptr = *(void**)buffer;
134 return (const char*)buffer + sizeof(void*);
135 }
137 #endif
