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