e6ffd9946ef707dab8ac17f9a9b1dbbd9651cad2
[WebKit-https.git] / Source / WebCore / loader / icon / IconDatabaseBase.h
1 /*
2  * Copyright (C) 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25  
26 #ifndef IconDatabaseBase_h
27 #define IconDatabaseBase_h
28
29 #include "Image.h"
30 #include "ImageSource.h"
31 #include "SharedBuffer.h"
32
33 #include <wtf/Forward.h>
34 #include <wtf/Noncopyable.h>
35 #include <wtf/PassRefPtr.h>
36
37 namespace WebCore {
38
39 class DocumentLoader;
40 class IconDatabaseClient;
41 class Image;
42 class IntSize;
43
44 enum IconLoadDecision {
45     IconLoadYes,
46     IconLoadNo,
47     IconLoadUnknown
48 };
49
50 class CallbackBase : public RefCounted<CallbackBase> {
51 public:
52     virtual ~CallbackBase()
53     {
54     }
55
56     uint64_t callbackID() const { return m_callbackID; }
57
58 protected:
59     CallbackBase(void* context)
60         : m_context(context)
61         , m_callbackID(generateCallbackID())
62     {
63     }
64
65     void* context() const { return m_context; }
66
67 private:
68     static uint64_t generateCallbackID()
69     {
70         static uint64_t uniqueCallbackID = 1;
71         return uniqueCallbackID++;
72     }
73
74     void* m_context;
75     uint64_t m_callbackID;
76 };
77
78 template<typename EnumType> 
79 class EnumCallback : public CallbackBase {
80 public:
81     typedef void (*CallbackFunction)(EnumType, void*);
82
83     static PassRefPtr<EnumCallback> create(void* context, CallbackFunction callback)
84     {
85         return adoptRef(new EnumCallback(context, callback));
86     }
87
88     virtual ~EnumCallback()
89     {
90         ASSERT(!m_callback);
91     }
92
93     void performCallback(EnumType result)
94     {
95         if (!m_callback)
96             return;
97         m_callback(result, context());
98         m_callback = 0;
99     }
100     
101     void invalidate()
102     {
103         m_callback = 0;
104     }
105
106 private:
107     EnumCallback(void* context, CallbackFunction callback)
108         : CallbackBase(context)
109         , m_callback(callback)
110     {
111         ASSERT(m_callback);
112     }
113
114     CallbackFunction m_callback;
115 };
116
117 template<typename ObjectType> 
118 class ObjectCallback : public CallbackBase {
119 public:
120     typedef void (*CallbackFunction)(ObjectType, void*);
121
122     static PassRefPtr<ObjectCallback> create(void* context, CallbackFunction callback)
123     {
124         return adoptRef(new ObjectCallback(context, callback));
125     }
126
127     virtual ~ObjectCallback()
128     {
129         ASSERT(!m_callback);
130     }
131
132     void performCallback(ObjectType result)
133     {
134         if (!m_callback)
135             return;
136         m_callback(result, context());
137         m_callback = 0;
138     }
139     
140     void invalidate()
141     {
142         m_callback = 0;
143     }
144
145 private:
146     ObjectCallback(void* context, CallbackFunction callback)
147         : CallbackBase(context)
148         , m_callback(callback)
149     {
150         ASSERT(m_callback);
151     }
152
153     CallbackFunction m_callback;
154 };
155
156 typedef EnumCallback<IconLoadDecision> IconLoadDecisionCallback;
157 typedef ObjectCallback<SharedBuffer*> IconDataCallback;
158
159 class IconDatabaseBase {
160     WTF_MAKE_NONCOPYABLE(IconDatabaseBase);
161
162 protected:
163     IconDatabaseBase() { }
164
165 public:
166     virtual ~IconDatabaseBase() { }
167
168     // Used internally by WebCore
169     virtual bool isEnabled() const { return false; }
170         
171     virtual void retainIconForPageURL(const String&) { }
172     virtual void releaseIconForPageURL(const String&) { }
173
174     virtual void setIconURLForPageURL(const String&, const String&) { }
175     virtual void setIconDataForIconURL(PassRefPtr<SharedBuffer>, const String&) { }
176     virtual void setIconBitmapForIconURL(PassRefPtr<Image>, const String&) { }
177
178     // Synchronous calls used internally by WebCore.
179     // Usage should be replaced by asynchronous calls.
180     virtual String synchronousIconURLForPageURL(const String&);
181     virtual bool synchronousIconDataKnownForIconURL(const String&) { return false; }
182     virtual IconLoadDecision synchronousLoadDecisionForIconURL(const String&, DocumentLoader*) { return IconLoadNo; }
183     virtual Image* synchronousIconForPageURL(const String&, const IntSize&) { return 0; }
184     virtual PassNativeImagePtr synchronousNativeIconForPageURL(const String&, const IntSize&) { return 0; }
185
186     // Asynchronous calls we should use to replace the above when supported.
187     virtual bool supportsAsynchronousMode() { return false; }
188     virtual void loadDecisionForIconURL(const String&, PassRefPtr<IconLoadDecisionCallback>) { }
189     virtual void iconDataForIconURL(const String&, PassRefPtr<IconDataCallback>) { }
190     
191
192     // Used within one or more WebKit ports.
193     // We should try to remove these dependencies from the IconDatabaseBase class.
194     virtual void setEnabled(bool) { }
195
196     virtual Image* defaultIcon(const IntSize&) { return 0; }
197
198     virtual size_t pageURLMappingCount() { return 0; }
199     virtual size_t retainedPageURLCount() { return 0; }
200     virtual size_t iconRecordCount() { return 0; }
201     virtual size_t iconRecordCountWithData() { return 0; }
202
203     virtual bool shouldStopThreadActivity() const { return true; }
204
205     virtual bool open(const String& directory, const String& filename);
206     virtual void close() { }
207     virtual void removeAllIcons() { }
208
209     virtual void setPrivateBrowsingEnabled(bool) { }
210     virtual void setClient(IconDatabaseClient*) { }
211     
212     virtual bool isOpen() const { return false; }
213     virtual String databasePath() const;
214
215 };
216
217 // Functions to get/set the global icon database.
218 IconDatabaseBase& iconDatabase();
219 void setGlobalIconDatabase(IconDatabaseBase*);
220 bool documentCanHaveIcon(const String&);
221
222 } // namespace WebCore
223
224 #endif // IconDatabaseBase_h