gfx/skia/trunk/src/core/SkTObjectPool.h@129ffea94266
gfx/skia/trunk/src/core/SkTObjectPool.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.
1 /*
2 * Copyright 2014 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 #ifndef SkFreeList_DEFINED
9 #define SkFreeList_DEFINED
11 #include "SkTInternalSList.h"
13 /**
14 * An implementation of a self growing pool of objects.
15 * It maintains a pool of fully initialized objects. If an attempt is made to
16 * acquire one, and there are none left, it makes some more.
17 * It does not automatically reclaim them, they have to be given back to it.
18 * Constructors will be called on objects allocated by the pool at allocation
19 * time.
20 * All allocated objects will be destroyed and memory will be reclaimed when
21 * the pool is destroyed, so the pool must survive longer than you are using
22 * any item taken from it.
23 */
24 template<typename T, int numItemsPerBlock = 4096/sizeof(T)> class SkTObjectPool {
25 public:
26 SkTObjectPool() {}
27 ~SkTObjectPool() {
28 while (!fBlocks.isEmpty()) {
29 SkDELETE(fBlocks.pop());
30 }
31 }
33 /**
34 * Get an item from the pool.
35 * If the pool has no free items, it will allocate and construct some more.
36 * The returned item is only valid as long as the pool has not been
37 * destroyed, at that point all memory allocated by grow will have been
38 * reclaimed.
39 * This method is *not* thread safe.
40 */
41 T* acquire() {
42 if (fAvailable.isEmpty()) {
43 grow();
44 }
45 return fAvailable.pop();
46 }
48 /**
49 * Release an item into the pool.
50 * The item does not have to have come from the pool, but if it did not
51 * it must have a lifetime greater than the pool does.
52 * This method is *not* thread safe.
53 */
54 void release(T* entry) {
55 fAvailable.push(entry);
56 }
58 /**
59 * Takes all the items from an SkTInternalSList and adds them back to this
60 * pool. The other list will be left empty.
61 */
62 void releaseAll(SkTInternalSList<T>* other) {
63 fAvailable.pushAll(other);
64 }
66 /**
67 * Returns the number of items immediately available without having to
68 * construct any new ones.
69 */
70 int available() const { return fAvailable.getCount(); }
72 /**
73 * Returns the number of blocks of items the pool has allocated so far.
74 */
75 int blocks() const { return fBlocks.getCount(); }
77 private:
78 /**
79 * The type for a new block of entries for the list.
80 */
81 struct Block {
82 T entries[numItemsPerBlock];
83 SK_DECLARE_INTERNAL_SLIST_INTERFACE(Block);
84 };
85 SkTInternalSList<Block> fBlocks;
86 SkTInternalSList<T> fAvailable;
88 /**
89 * When the free list runs out of items, this method is called to allocate
90 * a new block of them.
91 * It calls the constructors and then pushes the nodes into the available
92 * list.
93 */
94 void grow() {
95 Block* block = SkNEW(Block);
96 fBlocks.push(block);
97 for(int index = 0; index < numItemsPerBlock; ++index) {
98 fAvailable.push(&block->entries[index]);
99 }
100 }
102 };
104 #endif
