1 /*
2 * Copyright 2012 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 */
7
8 #include "GrProcessor.h"
9 #include "GrContext.h"
10 #include "GrContextPriv.h"
11 #include "GrGeometryProcessor.h"
12 #include "GrMemoryPool.h"
13 #include "GrSamplerState.h"
14 #include "GrTextureProxy.h"
15 #include "GrXferProcessor.h"
16 #include "SkSpinlock.h"
17
18 #if GR_TEST_UTILS
19
resourceProvider()20 GrResourceProvider* GrProcessorTestData::resourceProvider() {
21 return fContext->priv().resourceProvider();
22 }
23
proxyProvider()24 GrProxyProvider* GrProcessorTestData::proxyProvider() {
25 return fContext->priv().proxyProvider();
26 }
27
caps()28 const GrCaps* GrProcessorTestData::caps() { return fContext->priv().caps(); }
29
30 #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
31 class GrFragmentProcessor;
32 class GrGeometryProcessor;
33
34 /*
35 * Originally these were both in the processor unit test header, but then it seemed to cause linker
36 * problems on android.
37 */
38 template <>
GetFactories()39 SkTArray<GrFragmentProcessorTestFactory*, true>* GrFragmentProcessorTestFactory::GetFactories() {
40 static SkTArray<GrFragmentProcessorTestFactory*, true> gFactories;
41 return &gFactories;
42 }
43
44 template <>
GetFactories()45 SkTArray<GrGeometryProcessorTestFactory*, true>* GrGeometryProcessorTestFactory::GetFactories() {
46 static SkTArray<GrGeometryProcessorTestFactory*, true> gFactories;
47 return &gFactories;
48 }
49
GetFactories()50 SkTArray<GrXPFactoryTestFactory*, true>* GrXPFactoryTestFactory::GetFactories() {
51 static SkTArray<GrXPFactoryTestFactory*, true> gFactories;
52 return &gFactories;
53 }
54
55 /*
56 * To ensure we always have successful static initialization, before creating from the factories
57 * we verify the count is as expected. If a new factory is added, then these numbers must be
58 * manually adjusted.
59 */
60 static const int kFPFactoryCount = 36;
61 static const int kGPFactoryCount = 14;
62 static const int kXPFactoryCount = 4;
63
64 template <>
VerifyFactoryCount()65 void GrFragmentProcessorTestFactory::VerifyFactoryCount() {
66 if (kFPFactoryCount != GetFactories()->count()) {
67 SkDebugf("\nExpected %d fragment processor factories, found %d.\n",
68 kFPFactoryCount, GetFactories()->count());
69 SK_ABORT("Wrong number of fragment processor factories!");
70 }
71 }
72
73 template <>
VerifyFactoryCount()74 void GrGeometryProcessorTestFactory::VerifyFactoryCount() {
75 if (kGPFactoryCount != GetFactories()->count()) {
76 SkDebugf("\nExpected %d geometry processor factories, found %d.\n",
77 kGPFactoryCount, GetFactories()->count());
78 SK_ABORT("Wrong number of geometry processor factories!");
79 }
80 }
81
VerifyFactoryCount()82 void GrXPFactoryTestFactory::VerifyFactoryCount() {
83 if (kXPFactoryCount != GetFactories()->count()) {
84 SkDebugf("\nExpected %d xp factory factories, found %d.\n",
85 kXPFactoryCount, GetFactories()->count());
86 SK_ABORT("Wrong number of xp factory factories!");
87 }
88 }
89
90 #endif
91 #endif
92
93
94 // We use a global pool protected by a mutex(spinlock). Chrome may use the same GrContext on
95 // different threads. The GrContext is not used concurrently on different threads and there is a
96 // memory barrier between accesses of a context on different threads. Also, there may be multiple
97 // GrContexts and those contexts may be in use concurrently on different threads.
98 namespace {
99 #if !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
100 static SkSpinlock gProcessorSpinlock;
101 #endif
102 class MemoryPoolAccessor {
103 public:
104
105 // We know in the Android framework there is only one GrContext.
106 #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
MemoryPoolAccessor()107 MemoryPoolAccessor() {}
~MemoryPoolAccessor()108 ~MemoryPoolAccessor() {}
109 #else
110 MemoryPoolAccessor() { gProcessorSpinlock.acquire(); }
111 ~MemoryPoolAccessor() { gProcessorSpinlock.release(); }
112 #endif
113
pool() const114 GrMemoryPool* pool() const {
115 static GrMemoryPool gPool(4096, 4096);
116 return &gPool;
117 }
118 };
119 }
120
121 ///////////////////////////////////////////////////////////////////////////////
122
operator new(size_t size)123 void* GrProcessor::operator new(size_t size) { return MemoryPoolAccessor().pool()->allocate(size); }
124
operator delete(void * target)125 void GrProcessor::operator delete(void* target) {
126 return MemoryPoolAccessor().pool()->release(target);
127 }
128