| /* |
| * Copyright (C) 2006, 2007 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "WebKitDLL.h" |
| #include "WebNotificationCenter.h" |
| |
| #include "WebNotification.h" |
| #pragma warning( push, 0 ) |
| #include <WebCore/StringImpl.h> |
| #include <wtf/HashMap.h> |
| #include <wtf/HashTraits.h> |
| #pragma warning(pop) |
| #include <tchar.h> |
| |
| using namespace WebCore; |
| |
| // ---------------------------------------------------------------------------- |
| |
| struct ObserverHash; |
| |
| class ObserverKey |
| { |
| friend ObserverHash; |
| public: |
| ObserverKey(BSTR n = 0, IUnknown* o = 0); |
| ObserverKey(const ObserverKey& key); |
| ~ObserverKey(); |
| |
| bool operator==(const ObserverKey &) const; |
| ObserverKey& operator=(const ObserverKey &); |
| |
| private: |
| BSTR m_notificationName; |
| IUnknown* m_anObject; |
| }; |
| |
| ObserverKey::ObserverKey(BSTR n, IUnknown* o) |
| : m_notificationName(0) |
| , m_anObject(o) |
| { |
| if (n == (BSTR)-1) |
| m_notificationName = n; |
| else if (n) |
| m_notificationName = SysAllocString(n); |
| if (o) |
| o->AddRef(); |
| } |
| |
| ObserverKey::ObserverKey(const ObserverKey& other) |
| : m_notificationName(0) |
| , m_anObject(0) |
| { |
| *this = other; |
| } |
| |
| ObserverKey::~ObserverKey() |
| { |
| if (m_notificationName && m_notificationName != (BSTR)-1) |
| SysFreeString(m_notificationName); |
| if (m_anObject) |
| m_anObject->Release(); |
| } |
| |
| bool ObserverKey::operator==(const ObserverKey &other) const |
| { |
| if (m_anObject && other.m_anObject && m_anObject != other.m_anObject) |
| return false; // only fail to match anObject if both are non-null (treat null as a wildcard) |
| |
| if (m_notificationName == other.m_notificationName) |
| return true; |
| |
| if (!m_notificationName || m_notificationName == (BSTR)-1 || !other.m_notificationName || other.m_notificationName == (BSTR)-1) |
| return false; |
| |
| return !_tcscmp(m_notificationName, other.m_notificationName); |
| } |
| |
| ObserverKey& ObserverKey::operator=(const ObserverKey& other) |
| { |
| if (m_notificationName && m_notificationName != (BSTR)-1) |
| SysFreeString(m_notificationName); |
| m_notificationName = other.m_notificationName; |
| if (m_notificationName && m_notificationName != (BSTR)-1) |
| m_notificationName = SysAllocString(m_notificationName); |
| if (m_anObject != other.m_anObject) { |
| if (m_anObject) |
| m_anObject->Release(); |
| m_anObject = other.m_anObject; |
| if (m_anObject) |
| m_anObject->AddRef(); |
| } |
| return *this; |
| } |
| |
| struct ObserverKeyTraits : WTF::GenericHashTraits<ObserverKey> { |
| static const bool emptyValueIsZero = true; |
| static const bool needsDestruction = true; |
| static ObserverKey deletedValue() { return ObserverKey((BSTR)-1, 0); } |
| }; |
| |
| struct ObserverHash { |
| static unsigned hash(const ObserverKey&); |
| static bool equal(const ObserverKey& a, const ObserverKey& b) { return a == b; } |
| }; |
| |
| unsigned ObserverHash::hash(const ObserverKey& key) |
| { |
| unsigned h = 0; |
| |
| if (key.m_notificationName) { |
| if (key.m_notificationName == (BSTR)-1) |
| h = (unsigned)-1; |
| else |
| h = StringImpl::computeHash(key.m_notificationName, SysStringLen(key.m_notificationName)); |
| } |
| |
| // DO NOT take m_anObject into account for the hash. We need to match based on m_notificationName only. |
| // We ensure a match in operator== if both of the values are non-null. This matches semantics of |
| // NSNotificationCenter. |
| |
| return h; |
| } |
| |
| typedef HashMap<ObserverKey, Vector<IWebNotificationObserver*>, ObserverHash, ObserverKeyTraits> MappedObservers; |
| |
| struct WebNotificationCenterPrivate |
| { |
| MappedObservers m_mappedObservers; |
| }; |
| |
| // WebNotificationCenter ---------------------------------------------------------------- |
| |
| IWebNotificationCenter* WebNotificationCenter::m_defaultCenter = 0; |
| |
| WebNotificationCenter::WebNotificationCenter() |
| : m_refCount(0) |
| , d(new WebNotificationCenterPrivate) |
| { |
| gClassCount++; |
| } |
| |
| WebNotificationCenter::~WebNotificationCenter() |
| { |
| delete d; |
| gClassCount--; |
| } |
| |
| WebNotificationCenter* WebNotificationCenter::createInstance() |
| { |
| WebNotificationCenter* instance = new WebNotificationCenter(); |
| instance->AddRef(); |
| return instance; |
| } |
| |
| // IUnknown ------------------------------------------------------------------- |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::QueryInterface(REFIID riid, void** ppvObject) |
| { |
| *ppvObject = 0; |
| if (IsEqualGUID(riid, IID_IUnknown)) |
| *ppvObject = static_cast<IWebNotificationCenter*>(this); |
| else if (IsEqualGUID(riid, IID_IWebNotificationCenter)) |
| *ppvObject = static_cast<IWebNotificationCenter*>(this); |
| else |
| return E_NOINTERFACE; |
| |
| AddRef(); |
| return S_OK; |
| } |
| |
| ULONG STDMETHODCALLTYPE WebNotificationCenter::AddRef(void) |
| { |
| return ++m_refCount; |
| } |
| |
| ULONG STDMETHODCALLTYPE WebNotificationCenter::Release(void) |
| { |
| ULONG newRef = --m_refCount; |
| if (!newRef) |
| delete(this); |
| |
| return newRef; |
| } |
| |
| IWebNotificationCenter* WebNotificationCenter::defaultCenterInternal() |
| { |
| if (!m_defaultCenter) |
| m_defaultCenter = WebNotificationCenter::createInstance(); |
| return m_defaultCenter; |
| } |
| |
| void WebNotificationCenter::postNotificationInternal(IWebNotification* notification, BSTR notificationName, IUnknown* anObject) |
| { |
| ObserverKey key(notificationName, anObject); |
| MappedObservers::iterator it = d->m_mappedObservers.find(key); |
| if (it != d->m_mappedObservers.end()) { |
| Vector<IWebNotificationObserver*> list = it->second; |
| |
| Vector<IWebNotificationObserver*>::iterator end = list.end(); |
| for (Vector<IWebNotificationObserver*>::iterator it2 = list.begin(); it2 != end; ++it2) { |
| (*it2)->onNotify(notification); |
| } |
| } |
| } |
| |
| // IWebNotificationCenter ----------------------------------------------------- |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::defaultCenter( |
| /* [retval][out] */ IWebNotificationCenter** center) |
| { |
| *center = defaultCenterInternal(); |
| (*center)->AddRef(); |
| return S_OK; |
| } |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::addObserver( |
| /* [in] */ IWebNotificationObserver* observer, |
| /* [in] */ BSTR notificationName, |
| /* [in] */ IUnknown* anObject) |
| { |
| ObserverKey key(notificationName, anObject); |
| MappedObservers::iterator it = d->m_mappedObservers.find(key); |
| observer->AddRef(); |
| if (it != d->m_mappedObservers.end()) |
| it->second.append(observer); |
| else { |
| Vector<IWebNotificationObserver*> list; |
| list.append(observer); |
| d->m_mappedObservers.add(key, list); |
| } |
| |
| return S_OK; |
| } |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::postNotification( |
| /* [in] */ IWebNotification* notification) |
| { |
| BSTR name; |
| HRESULT hr = notification->name(&name); |
| if (SUCCEEDED(hr)) { |
| IUnknown* obj; |
| hr = notification->getObject(&obj); |
| if (SUCCEEDED(hr)) { |
| postNotificationInternal(notification, name, obj); |
| if (obj) |
| obj->Release(); |
| } |
| SysFreeString(name); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::postNotificationName( |
| /* [in] */ BSTR notificationName, |
| /* [in] */ IUnknown* anObject, |
| /* [optional][in] */ IPropertyBag* userInfo) |
| { |
| WebNotification* notification = WebNotification::createInstance(notificationName, anObject, userInfo); |
| postNotificationInternal(notification, notificationName, anObject); |
| notification->Release(); |
| return S_OK; |
| } |
| |
| HRESULT STDMETHODCALLTYPE WebNotificationCenter::removeObserver( |
| /* [in] */ IWebNotificationObserver* anObserver, |
| /* [in] */ BSTR notificationName, |
| /* [optional][in] */ IUnknown* anObject) |
| { |
| ObserverKey key(notificationName, anObject); |
| MappedObservers::iterator it = d->m_mappedObservers.find(key); |
| if (it == d->m_mappedObservers.end()) |
| return E_FAIL; |
| |
| Vector<IWebNotificationObserver*>& observerList = it->second; |
| Vector<IWebNotificationObserver*>::iterator end = observerList.end(); |
| int i=0; |
| for (Vector<IWebNotificationObserver*>::iterator it2 = observerList.begin(); it2 != end; ++it2, i++) { |
| if (*it2 == anObserver) { |
| (*it2)->Release(); |
| observerList.remove(i); |
| break; |
| } |
| } |
| |
| if (observerList.isEmpty()) |
| d->m_mappedObservers.remove(key); |
| |
| return S_OK; |
| } |