gfx/skia/trunk/src/core/SkPtrRecorder.h@129ffea94266
gfx/skia/trunk/src/core/SkPtrRecorder.h
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 2008 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 #ifndef SkPtrSet_DEFINED
11 #define SkPtrSet_DEFINED
13 #include "SkRefCnt.h"
14 #include "SkFlattenable.h"
15 #include "SkTDArray.h"
17 /**
18 * Maintains a set of ptrs, assigning each a unique ID [1...N]. Duplicate ptrs
19 * return the same ID (since its a set). Subclasses can override inPtr()
20 * and decPtr(). incPtr() is called each time a unique ptr is added ot the
21 * set. decPtr() is called on each ptr when the set is destroyed or reset.
22 */
23 class SkPtrSet : public SkRefCnt {
24 public:
25 SK_DECLARE_INST_COUNT(SkPtrSet)
27 /**
28 * Search for the specified ptr in the set. If it is found, return its
29 * 32bit ID [1..N], or if not found, return 0. Always returns 0 for NULL.
30 */
31 uint32_t find(void*) const;
33 /**
34 * Add the specified ptr to the set, returning a unique 32bit ID for it
35 * [1...N]. Duplicate ptrs will return the same ID.
36 *
37 * If the ptr is NULL, it is not added, and 0 is returned.
38 */
39 uint32_t add(void*);
41 /**
42 * Return the number of (non-null) ptrs in the set.
43 */
44 int count() const { return fList.count(); }
46 /**
47 * Copy the ptrs in the set into the specified array (allocated by the
48 * caller). The ptrs are assgined to the array based on their corresponding
49 * ID. e.g. array[ptr.ID - 1] = ptr.
50 *
51 * incPtr() and decPtr() are not called during this operation.
52 */
53 void copyToArray(void* array[]) const;
55 /**
56 * Call decPtr() on each ptr in the set, and the reset the size of the set
57 * to 0.
58 */
59 void reset();
61 protected:
62 virtual void incPtr(void*) {}
63 virtual void decPtr(void*) {}
65 private:
66 struct Pair {
67 void* fPtr; // never NULL
68 uint32_t fIndex; // 1...N
69 };
71 // we store the ptrs in sorted-order (using Cmp) so that we can efficiently
72 // detect duplicates when add() is called. Hence we need to store the
73 // ptr and its ID/fIndex explicitly, since the ptr's position in the array
74 // is not related to its "index".
75 SkTDArray<Pair> fList;
77 static bool Less(const Pair& a, const Pair& b);
79 typedef SkRefCnt INHERITED;
80 };
82 /**
83 * Templated wrapper for SkPtrSet, just meant to automate typecasting
84 * parameters to and from void* (which the base class expects).
85 */
86 template <typename T> class SkTPtrSet : public SkPtrSet {
87 public:
88 uint32_t find(T ptr) {
89 return this->INHERITED::find((void*)ptr);
90 }
91 uint32_t add(T ptr) {
92 return this->INHERITED::add((void*)ptr);
93 }
95 void copyToArray(T* array) const {
96 this->INHERITED::copyToArray((void**)array);
97 }
99 private:
100 typedef SkPtrSet INHERITED;
101 };
103 /**
104 * Subclass of SkTPtrSet specialed to call ref() and unref() when the
105 * base class's incPtr() and decPtr() are called. This makes it a valid owner
106 * of each ptr, which is released when the set is reset or destroyed.
107 */
108 class SkRefCntSet : public SkTPtrSet<SkRefCnt*> {
109 public:
110 virtual ~SkRefCntSet();
112 protected:
113 // overrides
114 virtual void incPtr(void*);
115 virtual void decPtr(void*);
116 };
118 class SkFactorySet : public SkTPtrSet<SkFlattenable::Factory> {};
120 /**
121 * Similar to SkFactorySet, but only allows Factorys that have registered names.
122 * Also has a function to return the next added Factory's name.
123 */
124 class SkNamedFactorySet : public SkRefCnt {
125 public:
126 SK_DECLARE_INST_COUNT(SkNamedFactorySet)
128 SkNamedFactorySet();
130 /**
131 * Find the specified Factory in the set. If it is not already in the set,
132 * and has registered its name, add it to the set, and return its index.
133 * If the Factory has no registered name, return 0.
134 */
135 uint32_t find(SkFlattenable::Factory);
137 /**
138 * If new Factorys have been added to the set, return the name of the first
139 * Factory added after the Factory name returned by the last call to this
140 * function.
141 */
142 const char* getNextAddedFactoryName();
143 private:
144 int fNextAddedFactory;
145 SkFactorySet fFactorySet;
146 SkTDArray<const char*> fNames;
148 typedef SkRefCnt INHERITED;
149 };
151 #endif
