8996b6dca6f65e4ab4f670b5ea6107c9756f01dd
[WebKit-https.git] / Source / WebKit / win / COMPropertyBag.h
1 /*
2  * Copyright (C) 2008 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 COMPropertyBag_h
27 #define COMPropertyBag_h
28
29 #ifndef NOMINMAX
30 #define NOMINMAX
31 #endif
32 #include <ocidl.h>
33 #include <unknwn.h>
34
35 #include <wtf/Noncopyable.h>
36 #include <wtf/HashMap.h>
37
38 #include "COMVariantSetter.h"
39
40 template<typename ValueType, typename KeyType = typename WTF::String, typename HashType = typename WTF::StringHash>
41 class COMPropertyBag : public IPropertyBag, public IPropertyBag2 {
42     WTF_MAKE_NONCOPYABLE(COMPropertyBag);
43 public:
44     typedef HashMap<KeyType, ValueType, HashType> HashMapType;
45
46     static COMPropertyBag* createInstance(const HashMapType&);
47     static COMPropertyBag* adopt(HashMapType&);
48
49     // IUnknown
50     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
51     virtual ULONG STDMETHODCALLTYPE AddRef();
52     virtual ULONG STDMETHODCALLTYPE Release();
53
54     // IPropertyBag
55     virtual HRESULT STDMETHODCALLTYPE Read(LPCOLESTR pszPropName, VARIANT*, IErrorLog*);
56     virtual HRESULT STDMETHODCALLTYPE Write(LPCOLESTR pszPropName, VARIANT*);
57
58     // IPropertyBag2
59     virtual HRESULT STDMETHODCALLTYPE Read(ULONG cProperties, PROPBAG2*, IErrorLog*, VARIANT* pvarValue, HRESULT* phrError);
60     virtual HRESULT STDMETHODCALLTYPE Write(ULONG cProperties, PROPBAG2*, VARIANT*);
61     virtual HRESULT STDMETHODCALLTYPE CountProperties(ULONG* pcProperties);
62     virtual HRESULT STDMETHODCALLTYPE GetPropertyInfo(ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG* pcProperties);
63     virtual HRESULT STDMETHODCALLTYPE LoadObject(LPCOLESTR pstrName, DWORD dwHint, IUnknown*, IErrorLog*);
64
65 private:
66     COMPropertyBag()
67         : m_refCount(0)
68     {
69     }
70
71     COMPropertyBag(const HashMapType& hashMap)
72         : m_refCount(0)
73         , m_hashMap(hashMap)
74     {
75     }
76
77     ~COMPropertyBag() {}
78
79     ULONG m_refCount;
80     HashMapType m_hashMap;
81 };
82
83 // COMPropertyBag ------------------------------------------------------------------
84 template<typename ValueType, typename KeyType, typename HashType>
85 COMPropertyBag<ValueType, KeyType, HashType>* COMPropertyBag<typename ValueType, typename KeyType, HashType>::createInstance(const HashMapType& hashMap)
86 {
87     COMPropertyBag* instance = new COMPropertyBag(hashMap);
88     instance->AddRef();
89     return instance;
90 }
91
92 template<typename ValueType, typename KeyType, typename HashType>
93 COMPropertyBag<ValueType, KeyType, HashType>* COMPropertyBag<typename ValueType, typename KeyType, HashType>::adopt(HashMapType& hashMap)
94 {
95     COMPropertyBag* instance = new COMPropertyBag;
96     instance->m_hashMap.swap(hashMap);
97     instance->AddRef();
98     return instance;
99 }
100
101 // IUnknown ------------------------------------------------------------------------
102 template<typename ValueType, typename KeyType, typename HashType>
103 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::QueryInterface(REFIID riid, void** ppvObject)
104 {
105     *ppvObject = 0;
106     if (IsEqualGUID(riid, IID_IUnknown))
107         *ppvObject = static_cast<IPropertyBag*>(this);
108     else if (IsEqualGUID(riid, IID_IPropertyBag))
109         *ppvObject = static_cast<IPropertyBag*>(this);
110     else if (IsEqualGUID(riid, IID_IPropertyBag2))
111         *ppvObject = static_cast<IPropertyBag2*>(this);
112     else
113         return E_NOINTERFACE;
114
115     AddRef();
116     return S_OK;
117 }
118
119 template<typename ValueType, typename KeyType, typename HashType>
120 ULONG STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::AddRef()
121 {
122     return ++m_refCount;
123 }
124
125 template<typename ValueType, typename KeyType, typename HashType>
126 ULONG STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::Release()
127 {
128     ULONG newRef = --m_refCount;
129     if (!newRef)
130         delete this;
131
132     return newRef;
133 }
134
135 // IPropertyBag --------------------------------------------------------------------
136
137 template<typename ValueType, typename KeyType, typename HashType>
138 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::Read(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog)
139 {
140     if (!pszPropName)
141         return E_POINTER;
142
143     HashMapType::const_iterator it = m_hashMap.find(String(pszPropName));
144     HashMapType::const_iterator end = m_hashMap.end();
145     if (it == end)
146         return E_INVALIDARG;
147
148     VARTYPE requestedType = V_VT(pVar);
149     V_VT(pVar) = VT_EMPTY;
150     COMVariantSetter<ValueType>::setVariant(pVar, it->value);
151
152     if (requestedType != COMVariantSetter<ValueType>::variantType(it->value) && requestedType != VT_EMPTY)
153         return ::VariantChangeType(pVar, pVar, VARIANT_NOUSEROVERRIDE | VARIANT_ALPHABOOL, requestedType);
154
155     return S_OK;
156 }
157
158 template<typename ValueType, typename KeyType, typename HashType>
159 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::Write(LPCOLESTR pszPropName, VARIANT* pVar)
160 {
161     return E_FAIL;
162 }
163
164 template<typename ValueType, typename KeyType, typename HashType>
165 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::Read(ULONG cProperties, PROPBAG2* pPropBag, IErrorLog* pErrorLog, VARIANT* pvarValue, HRESULT* phrError)
166 {
167     if (!pPropBag || !pvarValue || !phrError)
168         return E_POINTER;
169
170     HRESULT hr = S_OK;
171
172     for (ULONG i = 0; i < cProperties; ++i) {
173         ::VariantInit(&pvarValue[i]);
174         pvarValue[i].vt = pPropBag[i].vt;
175         phrError[i] = Read(pPropBag[i].pstrName, &pvarValue[i], pErrorLog);
176         if (FAILED(phrError[i]))
177             hr = E_FAIL;
178     }
179
180     return hr;
181 }
182
183 template<typename ValueType, typename KeyType, typename HashType>
184 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::Write(ULONG cProperties, PROPBAG2*, VARIANT*)
185 {
186     return E_NOTIMPL;
187 }
188
189 template<typename ValueType, typename KeyType, typename HashType>
190 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::CountProperties(ULONG* pcProperties)
191 {
192     if (!pcProperties)
193         return E_POINTER;
194
195     *pcProperties = m_hashMap.size();
196     return S_OK;
197 }
198
199 template<typename ValueType, typename KeyType, typename HashType>
200 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::GetPropertyInfo(ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG* pcProperties)
201 {
202     if (!pPropBag || !pcProperties)
203         return E_POINTER;
204
205     if (m_hashMap.size() <= iProperty)
206         return E_INVALIDARG;
207
208     *pcProperties = 0;
209     typedef HashMapType::const_iterator Iterator;
210     Iterator current = m_hashMap.begin();
211     Iterator end = m_hashMap.end();
212     for (ULONG i = 0; i < iProperty; ++i, ++current)
213         ;
214     for (ULONG j = 0; j < cProperties && current != end; ++j, ++current) {
215         // FIXME: the following fields aren't filled in
216         //pPropBag[j].cfType;   // (CLIPFORMAT) Clipboard format or MIME type of the property.
217         //pPropBag[j].clsid;    // (CLSID) CLSID of the object. This member is valid only if dwType is PROPBAG2_TYPE_OBJECT.
218
219         pPropBag[j].dwType = PROPBAG2_TYPE_DATA;
220         pPropBag[j].vt = COMVariantSetter<ValueType>::variantType(current->value);
221         pPropBag[j].dwHint = iProperty + j;
222         pPropBag[j].pstrName = (LPOLESTR)CoTaskMemAlloc(sizeof(wchar_t)*(current->key.length()+1));
223         if (!pPropBag[j].pstrName)
224             return E_OUTOFMEMORY;
225         wcscpy_s(pPropBag[j].pstrName, current->key.length()+1, static_cast<String>(current->key).charactersWithNullTermination().data());
226         ++*pcProperties;
227     }
228     return S_OK;
229 }
230
231 template<typename ValueType, typename KeyType, typename HashType>
232 HRESULT STDMETHODCALLTYPE COMPropertyBag<ValueType, KeyType, HashType>::LoadObject(LPCOLESTR pstrName, DWORD dwHint, IUnknown*, IErrorLog*)
233 {
234     return E_NOTIMPL;
235 }
236
237 #endif // COMPropertyBag_h