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 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 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 "NativeImagePtr.h"
30#include <wtf/Forward.h>
31#include <wtf/Noncopyable.h>
32#include <wtf/PassRefPtr.h>
33#include <wtf/RefCounted.h>
34
35namespace WebCore {
36
37class DocumentLoader;
38class IconDatabaseClient;
39class Image;
40class IntSize;
41class SharedBuffer;
42
43enum IconLoadDecision {
44    IconLoadYes,
45    IconLoadNo,
46    IconLoadUnknown
47};
48
49class CallbackBase : public RefCounted<CallbackBase> {
50public:
51    virtual ~CallbackBase()
52    {
53    }
54
55    uint64_t callbackID() const { return m_callbackID; }
56
57protected:
58    CallbackBase(void* context)
59        : m_context(context)
60        , m_callbackID(generateCallbackID())
61    {
62    }
63
64    void* context() const { return m_context; }
65
66private:
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
77template<typename EnumType>
78class EnumCallback : public CallbackBase {
79public:
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
105private:
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
116template<typename ObjectType>
117class ObjectCallback : public CallbackBase {
118public:
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
144private:
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
155typedef EnumCallback<IconLoadDecision> IconLoadDecisionCallback;
156typedef ObjectCallback<SharedBuffer*> IconDataCallback;
157
158class IconDatabaseBase {
159    WTF_MAKE_NONCOPYABLE(IconDatabaseBase);
160
161protected:
162    IconDatabaseBase() { }
163
164public:
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.
216IconDatabaseBase& iconDatabase();
217void setGlobalIconDatabase(IconDatabaseBase*);
218bool documentCanHaveIcon(const String&);
219
220} // namespace WebCore
221
222#endif // IconDatabaseBase_h
223