--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebKit/win/WebURLProtectionSpace.cpp Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 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 "WebKit.h"
+#include "WebKitDLL.h"
+#include "WebURLProtectionSpace.h"
+
+#pragma warning(push, 0)
+#include <WebCore/BString.h>
+#pragma warning(pop)
+
+using namespace WebCore;
+
+// WebURLProtectionSpace ----------------------------------------------------------------
+
+WebURLProtectionSpace::WebURLProtectionSpace(const ProtectionSpace& protectionSpace)
+ : m_refCount(0)
+ , m_protectionSpace(protectionSpace)
+{
+ gClassCount++;
+}
+
+WebURLProtectionSpace::~WebURLProtectionSpace()
+{
+ gClassCount--;
+}
+
+WebURLProtectionSpace* WebURLProtectionSpace::createInstance()
+{
+ WebURLProtectionSpace* instance = new WebURLProtectionSpace(ProtectionSpace());
+ instance->AddRef();
+ return instance;
+}
+
+WebURLProtectionSpace* WebURLProtectionSpace::createInstance(const ProtectionSpace& protectionSpace)
+{
+ WebURLProtectionSpace* instance = new WebURLProtectionSpace(protectionSpace);
+ instance->AddRef();
+ return instance;
+}
+
+// IUnknown -------------------------------------------------------------------
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::QueryInterface(REFIID riid, void** ppvObject)
+{
+ *ppvObject = 0;
+ if (IsEqualGUID(riid, IID_IUnknown))
+ *ppvObject = static_cast<IUnknown*>(this);
+ else if (IsEqualGUID(riid, CLSID_WebURLProtectionSpace))
+ *ppvObject = static_cast<WebURLProtectionSpace*>(this);
+ else if (IsEqualGUID(riid, IID_IWebURLProtectionSpace))
+ *ppvObject = static_cast<IWebURLProtectionSpace*>(this);
+ else
+ return E_NOINTERFACE;
+
+ AddRef();
+ return S_OK;
+}
+
+ULONG STDMETHODCALLTYPE WebURLProtectionSpace::AddRef(void)
+{
+ return ++m_refCount;
+}
+
+ULONG STDMETHODCALLTYPE WebURLProtectionSpace::Release(void)
+{
+ ULONG newRef = --m_refCount;
+ if (!newRef)
+ delete(this);
+
+ return newRef;
+}
+
+// IWebURLProtectionSpace -------------------------------------------------------------------
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::authenticationMethod(
+ /* [out, retval] */ BSTR* result)
+{
+ switch (m_protectionSpace.authenticationScheme()) {
+ case ProtectionSpaceAuthenticationSchemeDefault:
+ *result = SysAllocString(WebURLAuthenticationMethodDefault);
+ break;
+ case ProtectionSpaceAuthenticationSchemeHTTPBasic:
+ *result = SysAllocString(WebURLAuthenticationMethodHTTPBasic);
+ break;
+ case ProtectionSpaceAuthenticationSchemeHTTPDigest:
+ *result = SysAllocString(WebURLAuthenticationMethodHTTPDigest);
+ break;
+ case ProtectionSpaceAuthenticationSchemeHTMLForm:
+ *result = SysAllocString(WebURLAuthenticationMethodHTMLForm);
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::host(
+ /* [out, retval] */ BSTR* result)
+{
+ BString str = m_protectionSpace.host();
+ *result = str.release();
+ return S_OK;
+}
+
+static ProtectionSpaceAuthenticationScheme coreScheme(BSTR authenticationMethod)
+{
+ ProtectionSpaceAuthenticationScheme scheme = ProtectionSpaceAuthenticationSchemeDefault;
+ if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodDefault))
+ scheme = ProtectionSpaceAuthenticationSchemeDefault;
+ else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPBasic))
+ scheme = ProtectionSpaceAuthenticationSchemeHTTPBasic;
+ else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTTPDigest))
+ scheme = ProtectionSpaceAuthenticationSchemeHTTPDigest;
+ else if (BString(authenticationMethod) == BString(WebURLAuthenticationMethodHTMLForm))
+ scheme = ProtectionSpaceAuthenticationSchemeHTMLForm;
+ else
+ ASSERT_NOT_REACHED();
+ return scheme;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithHost(
+ /* [in] */ BSTR host,
+ /* [in] */ int port,
+ /* [in] */ BSTR protocol,
+ /* [in] */ BSTR realm,
+ /* [in] */ BSTR authenticationMethod)
+{
+ ProtectionSpaceServerType serverType = ProtectionSpaceServerHTTP;
+ if (BString(protocol) == WebURLProtectionSpaceHTTP)
+ serverType = ProtectionSpaceServerHTTP;
+ else if (BString(protocol) == WebURLProtectionSpaceHTTPS)
+ serverType = ProtectionSpaceServerHTTPS;
+ else if (BString(protocol) == WebURLProtectionSpaceFTP)
+ serverType = ProtectionSpaceServerFTP;
+ else if (BString(protocol) == WebURLProtectionSpaceFTPS)
+ serverType = ProtectionSpaceServerFTPS;
+ else
+ ASSERT_NOT_REACHED();
+
+ m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
+ String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
+
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::initWithProxyHost(
+ /* [in] */ BSTR host,
+ /* [in] */ int port,
+ /* [in] */ BSTR proxyType,
+ /* [in] */ BSTR realm,
+ /* [in] */ BSTR authenticationMethod)
+{
+ ProtectionSpaceServerType serverType = ProtectionSpaceProxyHTTP;
+ if (BString(proxyType) == WebURLProtectionSpaceHTTPProxy)
+ serverType = ProtectionSpaceProxyHTTP;
+ else if (BString(proxyType) == WebURLProtectionSpaceHTTPSProxy)
+ serverType = ProtectionSpaceProxyHTTPS;
+ else if (BString(proxyType) == WebURLProtectionSpaceFTPProxy)
+ serverType = ProtectionSpaceProxyFTP;
+ else if (BString(proxyType) == WebURLProtectionSpaceSOCKSProxy)
+ serverType = ProtectionSpaceProxySOCKS;
+ else
+ ASSERT_NOT_REACHED();
+
+ m_protectionSpace = ProtectionSpace(String(host, SysStringLen(host)), port, serverType,
+ String(realm, SysStringLen(realm)), coreScheme(authenticationMethod));
+
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::isProxy(
+ /* [out, retval] */ BOOL* result)
+{
+ *result = m_protectionSpace.isProxy();
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::port(
+ /* [out, retval] */ int* result)
+{
+ *result = m_protectionSpace.port();
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::protocol(
+ /* [out, retval] */ BSTR* result)
+{
+ switch (m_protectionSpace.serverType()) {
+ case ProtectionSpaceServerHTTP:
+ *result = SysAllocString(WebURLProtectionSpaceHTTP);
+ break;
+ case ProtectionSpaceServerHTTPS:
+ *result = SysAllocString(WebURLProtectionSpaceHTTPS);
+ break;
+ case ProtectionSpaceServerFTP:
+ *result = SysAllocString(WebURLProtectionSpaceFTP);
+ break;
+ case ProtectionSpaceServerFTPS:
+ *result = SysAllocString(WebURLProtectionSpaceFTPS);
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::proxyType(
+ /* [out, retval] */ BSTR* result)
+{
+ switch (m_protectionSpace.serverType()) {
+ case ProtectionSpaceProxyHTTP:
+ *result = SysAllocString(WebURLProtectionSpaceHTTPProxy);
+ break;
+ case ProtectionSpaceProxyHTTPS:
+ *result = SysAllocString(WebURLProtectionSpaceHTTPSProxy);
+ break;
+ case ProtectionSpaceProxyFTP:
+ *result = SysAllocString(WebURLProtectionSpaceFTPProxy);
+ break;
+ case ProtectionSpaceProxySOCKS:
+ *result = SysAllocString(WebURLProtectionSpaceSOCKSProxy);
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::realm(
+ /* [out, retval] */ BSTR* result)
+{
+ BString bstring = m_protectionSpace.realm();
+ *result = bstring.release();
+ return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebURLProtectionSpace::receivesCredentialSecurely(
+ /* [out, retval] */ BOOL* result)
+{
+ *result = m_protectionSpace.receivesCredentialSecurely();
+ return S_OK;
+}
+
+// WebURLProtectionSpace -------------------------------------------------------------------
+const ProtectionSpace& WebURLProtectionSpace::protectionSpace() const
+{
+ return m_protectionSpace;
+}