Unreviewed, rolling out r148034, r148052, r148097, and
[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 "ImageSource.h"
30 #include "SharedBuffer.h"
31
32 #include <wtf/Forward.h>
33 #include <wtf/Noncopyable.h>
34 #include <wtf/PassRefPtr.h>
35
36 namespace WebCore {
37
38 class DocumentLoader;
39 class IconDatabaseClient;
40 class Image;
41 class IntSize;
42
43 enum IconLoadDecision {
44     IconLoadYes,
45     IconLoadNo,
46     IconLoadUnknown
47 };
48
49 class CallbackBase : public RefCounted<CallbackBase> {
50 public:
51     virtual ~CallbackBase()
52     {
53     }
54
55     uint64_t callbackID() const { return m_callbackID; }
56
57 protected:
58     CallbackBase(void* context)
59         : m_context(context)
60         , m_callbackID(generateCallbackID())
61     {
62     }
63
64     void* context() const { return m_context; }
65
66 private:
67     static uint64_t generateCallbackID()
68     {
69         static uint64_t uniqueCallbackID = 1;
70         return uniqueCallbackID++;
71     }
72
73     void* m_context;
74     uint64_t m_callbackID;
75 };
76
77 template<typename EnumType> 
78 class EnumCallback : public CallbackBase {
79 public:
80     typedef void (*CallbackFunction)(EnumType, void*);
81
82     static PassRefPtr<EnumCallback> create(void* context, CallbackFunction callback)
83     {
84         return adoptRef(new EnumCallback(context, callback));
85     }
86
87     virtual ~EnumCallback()
88     {
89         ASSERT(!m_callback);
90     }
91
92     void performCallback(EnumType result)
93     {
94         if (!m_callback)
95             return;
96         m_callback(result, context());
97         m_callback = 0;
98     }
99     
100     void invalidate()
101     {
102         m_callback = 0;
103     }
104
105 private:
106     EnumCallback(void* context, CallbackFunction callback)
107         : CallbackBase(context)
108         , m_callback(callback)
109     {
110         ASSERT(m_callback);
111     }
112
113     CallbackFunction m_callback;
114 };
115
116 template<typename ObjectType> 
117 class ObjectCallback : public CallbackBase {
118 public:
119     typedef void (*CallbackFunction)(ObjectType, void*);
120
121     static PassRefPtr<ObjectCallback> create(void* context, CallbackFunction callback)
122     {
123         return adoptRef(new ObjectCallback(context, callback));
124     }
125
126     virtual ~ObjectCallback()
127     {
128         ASSERT(!m_callback);
129     }
130
131     void performCallback(ObjectType result)
132     {
133         if (!m_callback)
134             return;
135         m_callback(result, context());
136         m_callback = 0;
137     }
138     
139     void invalidate()
140     {
141         m_callback = 0;
142     }
143
144 private:
145     ObjectCallback(void* context, CallbackFunction callback)
146         : CallbackBase(context)
147         , m_callback(callback)
148     {
149         ASSERT(m_callback);
150     }
151
152     CallbackFunction m_callback;
153 };
154
155 typedef EnumCallback<IconLoadDecision> IconLoadDecisionCallback;
156 typedef ObjectCallback<SharedBuffer*> IconDataCallback;
157
158 class IconDatabaseBase {
159     WTF_MAKE_NONCOPYABLE(IconDatabaseBase);
160
161 protected:
162     IconDatabaseBase() { }
163
164 public:
165     virtual ~IconDatabaseBase() { }
166
167     // Used internally by WebCore
168     virtual bool isEnabled() const { return false; }
169         
170     virtual void retainIconForPageURL(const String&) { }
171     virtual void releaseIconForPageURL(const String&) { }
172
173     virtual void setIconURLForPageURL(const String&, const String&) { }
174     virtual void setIconDataForIconURL(PassRefPtr<SharedBuffer>, const String&) { }
175
176     // Synchronous calls used internally by WebCore.
177     // Usage should be replaced by asynchronous calls.
178     virtual String synchronousIconURLForPageURL(const String&);
179     virtual bool synchronousIconDataKnownForIconURL(const String&) { return false; }
180     virtual IconLoadDecision synchronousLoadDecisionForIconURL(const String&, DocumentLoader*) { return IconLoadNo; }
181     virtual Image* synchronousIconForPageURL(const String&, const IntSize&) { return 0; }
182     virtual PassNativeImagePtr synchronousNativeIconForPageURL(const String&, const IntSize&) { return 0; }
183
184     // Asynchronous calls we should use to replace the above when supported.
185     virtual bool supportsAsynchronousMode() { return false; }
186     virtual void loadDecisionForIconURL(const String&, PassRefPtr<IconLoadDecisionCallback>) { }
187     virtual void iconDataForIconURL(const String&, PassRefPtr<IconDataCallback>) { }
188     
189
190     // Used within one or more WebKit ports.
191     // We should try to remove these dependencies from the IconDatabaseBase class.
192     virtual void setEnabled(bool) { }
193
194     virtual Image* defaultIcon(const IntSize&) { return 0; }
195
196     virtual size_t pageURLMappingCount() { return 0; }
197     virtual size_t retainedPageURLCount() { return 0; }
198     virtual size_t iconRecordCount() { return 0; }
199     virtual size_t iconRecordCountWithData() { return 0; }
200
201     virtual bool shouldStopThreadActivity() const { return true; }
202
203     virtual bool open(const String& directory, const String& filename);
204     virtual void close() { }
205     virtual void removeAllIcons() { }
206
207     virtual void setPrivateBrowsingEnabled(bool) { }
208     virtual void setClient(IconDatabaseClient*) { }
209     
210     virtual bool isOpen() const { return false; }
211     virtual String databasePath() const;
212
213 };
214
215 // Functions to get/set the global icon database.
216 IconDatabaseBase& iconDatabase();
217 void setGlobalIconDatabase(IconDatabaseBase*);
218 bool documentCanHaveIcon(const String&);
219
220 } // namespace WebCore
221
222 #endif // IconDatabaseBase_h