Source/WebKit/win/WebMutableURLRequest.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 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 COMPUTER, 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 COMPUTER, 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 #include "config.h"
  27 #include "WebKitDLL.h"
  28 #include "WebMutableURLRequest.h"
  29
  30 #include "WebKit.h"
  31 #include "MarshallingHelpers.h"
  32 #include "WebKit.h"
  33 #include <WebCore/BString.h>
  34 #include <WebCore/COMPtr.h>
  35 #include <WebCore/FormData.h>
  36 #include <WebCore/NotImplemented.h>
  37 #include <WebCore/ResourceHandle.h>
  38 #include <wtf/text/CString.h>
  39 #include <wtf/RetainPtr.h>
  40
  41 #if USE(CF)
  42 #include <WebCore/CertificateCFWin.h>
  43 #endif
  44
  45 #if USE(CFNETWORK)
  46 #include <CFNetwork/CFURLRequestPriv.h>
  47 #endif
  48
  49 using namespace WebCore;
  50
  51 // IWebURLRequest ----------------------------------------------------------------
  52
  53 WebMutableURLRequest::WebMutableURLRequest(bool isMutable)
  54     : m_refCount(0)
  55     , m_isMutable(isMutable)
  56 {
  57     gClassCount++;
  58     gClassNameCount.add("WebMutableURLRequest");
  59 }
  60
  61 WebMutableURLRequest* WebMutableURLRequest::createInstance()
  62 {
  63     WebMutableURLRequest* instance = new WebMutableURLRequest(true);
  64     instance->AddRef();
  65     return instance;
  66 }
  67
  68 WebMutableURLRequest* WebMutableURLRequest::createInstance(IWebMutableURLRequest* req)
  69 {
  70     WebMutableURLRequest* instance = new WebMutableURLRequest(true);
  71     instance->AddRef();
  72     instance->m_request = static_cast<WebMutableURLRequest*>(req)->m_request;
  73     return instance;
  74 }
  75
  76 WebMutableURLRequest* WebMutableURLRequest::createInstance(const ResourceRequest& request)
  77 {
  78     WebMutableURLRequest* instance = new WebMutableURLRequest(true);
  79     instance->AddRef();
  80     instance->m_request = request;
  81     return instance;
  82 }
  83
  84 WebMutableURLRequest* WebMutableURLRequest::createImmutableInstance()
  85 {
  86     WebMutableURLRequest* instance = new WebMutableURLRequest(false);
  87     instance->AddRef();
  88     return instance;
  89 }
  90
  91 WebMutableURLRequest* WebMutableURLRequest::createImmutableInstance(const ResourceRequest& request)
  92 {
  93     WebMutableURLRequest* instance = new WebMutableURLRequest(false);
  94     instance->AddRef();
  95     instance->m_request = request;
  96     return instance;
  97 }
  98
  99 WebMutableURLRequest::~WebMutableURLRequest()
 100 {
 101     gClassCount--;
 102     gClassNameCount.remove("WebMutableURLRequest");
 103 }
 104
 105 // IUnknown -------------------------------------------------------------------
 106
 107 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::QueryInterface(REFIID riid, void** ppvObject)
 108 {
 109     *ppvObject = 0;
 110     if (IsEqualGUID(riid, CLSID_WebMutableURLRequest))
 111         *ppvObject = this;
 112     else if (IsEqualGUID(riid, IID_IUnknown))
 113         *ppvObject = static_cast<IWebURLRequest*>(this);
 114     else if (IsEqualGUID(riid, IID_IWebMutableURLRequest) && m_isMutable)
 115         *ppvObject = static_cast<IWebMutableURLRequest*>(this);
 116     else if (IsEqualGUID(riid, __uuidof(IWebMutableURLRequestPrivate)) && m_isMutable)
 117         *ppvObject = static_cast<IWebMutableURLRequestPrivate*>(this);
 118     else if (IsEqualGUID(riid, IID_IWebURLRequest))
 119         *ppvObject = static_cast<IWebURLRequest*>(this);
 120     else
 121         return E_NOINTERFACE;
 122
 123     AddRef();
 124     return S_OK;
 125 }
 126
 127 ULONG STDMETHODCALLTYPE WebMutableURLRequest::AddRef(void)
 128 {
 129     return ++m_refCount;
 130 }
 131
 132 ULONG STDMETHODCALLTYPE WebMutableURLRequest::Release(void)
 133 {
 134     ULONG newRef = --m_refCount;
 135     if (!newRef)
 136         delete(this);
 137
 138     return newRef;
 139 }
 140
 141 // IWebURLRequest --------------------------------------------------------------------
 142
 143 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::requestWithURL(
 144     /* [in] */ BSTR /*theURL*/,
 145     /* [optional][in] */ WebURLRequestCachePolicy /*cachePolicy*/,
 146     /* [optional][in] */ double /*timeoutInterval*/)
 147 {
 148     ASSERT_NOT_REACHED();
 149     return E_NOTIMPL;
 150 }
 151
 152 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::allHTTPHeaderFields(
 153     /* [retval][out] */ IPropertyBag** /*result*/)
 154 {
 155     ASSERT_NOT_REACHED();
 156     return E_NOTIMPL;
 157 }
 158
 159 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::cachePolicy(
 160     /* [retval][out] */ WebURLRequestCachePolicy* result)
 161 {
 162     *result = kit(m_request.cachePolicy());
 163     return S_OK;
 164 }
 165
 166 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::HTTPBody(
 167     /* [retval][out] */ IStream** /*result*/)
 168 {
 169     ASSERT_NOT_REACHED();
 170     return E_NOTIMPL;
 171 }
 172
 173 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::HTTPBodyStream(
 174     /* [retval][out] */ IStream** /*result*/)
 175 {
 176     ASSERT_NOT_REACHED();
 177     return E_NOTIMPL;
 178 }
 179
 180 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::HTTPMethod(
 181     /* [retval][out] */ BSTR* result)
 182 {
 183     BString httpMethod = BString(m_request.httpMethod());
 184     *result = httpMethod.release();
 185     return S_OK;
 186 }
 187
 188 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::HTTPShouldHandleCookies(
 189     /* [retval][out] */ BOOL* /*result*/)
 190 {
 191     ASSERT_NOT_REACHED();
 192     return E_NOTIMPL;
 193 }
 194
 195 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::initWithURL(
 196     /* [in] */ BSTR url,
 197     /* [optional][in] */ WebURLRequestCachePolicy cachePolicy,
 198     /* [optional][in] */ double timeoutInterval)
 199 {
 200     m_request.setURL(MarshallingHelpers::BSTRToKURL(url));
 201     m_request.setCachePolicy(core(cachePolicy));
 202     m_request.setTimeoutInterval(timeoutInterval);
 203
 204     return S_OK;
 205 }
 206
 207 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::mainDocumentURL(
 208     /* [retval][out] */ BSTR* result)
 209 {
 210     *result = MarshallingHelpers::KURLToBSTR(m_request.firstPartyForCookies());
 211     return S_OK;
 212 }
 213
 214 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::timeoutInterval(
 215     /* [retval][out] */ double* result)
 216 {
 217     *result = m_request.timeoutInterval();
 218     return S_OK;
 219 }
 220
 221 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::URL(
 222     /* [retval][out] */ BSTR* result)
 223 {
 224     *result = MarshallingHelpers::KURLToBSTR(m_request.url());
 225     return S_OK;
 226 }
 227
 228 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::valueForHTTPHeaderField(
 229     /* [in] */ BSTR field,
 230     /* [retval][out] */ BSTR* result)
 231 {
 232     if (!result) {
 233         ASSERT_NOT_REACHED();
 234         return E_POINTER;
 235     }
 236
 237     *result = BString(m_request.httpHeaderField(String(field, SysStringLen(field)))).release();
 238     return S_OK;
 239 }
 240
 241 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::isEmpty(
 242     /* [retval][out] */ BOOL* result)
 243 {
 244     *result = m_request.isEmpty();
 245     return S_OK;
 246 }
 247
 248 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::isEqual(
 249         /* [in] */ IWebURLRequest* other,
 250         /* [out, retval] */ BOOL* result)
 251 {
 252     COMPtr<WebMutableURLRequest> requestImpl(Query, other);
 253
 254     if (!requestImpl) {
 255         *result = FALSE;
 256         return S_OK;
 257     }
 258
 259     *result = m_request == requestImpl->resourceRequest();
 260     return S_OK;
 261 }
 262
 263
 264 // IWebMutableURLRequest --------------------------------------------------------
 265
 266 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::addValue(
 267     /* [in] */ BSTR /*value*/,
 268     /* [in] */ BSTR /*field*/)
 269 {
 270     ASSERT_NOT_REACHED();
 271     return E_NOTIMPL;
 272 }
 273
 274 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setAllHTTPHeaderFields(
 275     /* [in] */ IPropertyBag* /*headerFields*/)
 276 {
 277     ASSERT_NOT_REACHED();
 278     return E_NOTIMPL;
 279 }
 280
 281 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setCachePolicy(
 282     /* [in] */ WebURLRequestCachePolicy policy)
 283 {
 284     m_request.setCachePolicy(core(policy));
 285     return S_OK;
 286 }
 287
 288 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setHTTPBody(
 289     /* [in] */ IStream* /*data*/)
 290 {
 291     ASSERT_NOT_REACHED();
 292     return E_NOTIMPL;
 293 }
 294
 295 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setHTTPBodyStream(
 296     /* [in] */ IStream* /*data*/)
 297 {
 298     ASSERT_NOT_REACHED();
 299     return E_NOTIMPL;
 300 }
 301
 302 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setHTTPMethod(
 303     /* [in] */ BSTR method)
 304 {
 305     m_request.setHTTPMethod(String(method));
 306     return S_OK;
 307 }
 308
 309 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setHTTPShouldHandleCookies(
 310     /* [in] */ BOOL handleCookies)
 311 {
 312     m_request.setAllowCookies(handleCookies);
 313     return S_OK;
 314 }
 315
 316 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setMainDocumentURL(
 317     /* [in] */ BSTR /*theURL*/)
 318 {
 319     ASSERT_NOT_REACHED();
 320     return E_NOTIMPL;
 321 }
 322
 323 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setTimeoutInterval(
 324     /* [in] */ double timeoutInterval)
 325 {
 326     m_request.setTimeoutInterval(timeoutInterval);
 327     return S_OK;
 328 }
 329
 330 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setURL(
 331     /* [in] */ BSTR url)
 332 {
 333     m_request.setURL(MarshallingHelpers::BSTRToKURL(url));
 334     return S_OK;
 335 }
 336
 337 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setValue(
 338     /* [in] */ BSTR value,
 339     /* [in] */ BSTR field)
 340 {
 341     String valueString(value, SysStringLen(value));
 342     String fieldString(field, SysStringLen(field));
 343     m_request.setHTTPHeaderField(fieldString, valueString);
 344     return S_OK;
 345 }
 346
 347 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setAllowsAnyHTTPSCertificate(void)
 348 {
 349     ResourceHandle::setHostAllowsAnyHTTPSCertificate(m_request.url().host());
 350
 351     return S_OK;
 352 }
 353
 354 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::setClientCertificate(
 355     /* [in] */ OLE_HANDLE cert)
 356 {
 357     if (!cert)
 358         return E_POINTER;
 359
 360     PCCERT_CONTEXT certContext = reinterpret_cast<PCCERT_CONTEXT>((ULONG64)cert);
 361     RetainPtr<CFDataRef> certData = WebCore::copyCertificateToData(certContext);
 362     ResourceHandle::setClientCertificate(m_request.url().host(), certData.get());
 363     return S_OK;
 364 }
 365
 366 CFURLRequestRef STDMETHODCALLTYPE WebMutableURLRequest::cfRequest()
 367 {
 368     return m_request.cfURLRequest();
 369 }
 370
 371 HRESULT STDMETHODCALLTYPE WebMutableURLRequest::mutableCopy(
 372         /* [out, retval] */ IWebMutableURLRequest** result)
 373 {
 374     if (!result)
 375         return E_POINTER;
 376
 377 #if USE(CFNETWORK)
 378     RetainPtr<CFMutableURLRequestRef> mutableRequest(AdoptCF, CFURLRequestCreateMutableCopy(kCFAllocatorDefault, m_request.cfURLRequest()));
 379     *result = createInstance(ResourceRequest(mutableRequest.get()));
 380     return S_OK;
 381 #else
 382     *result = createInstance(m_request);
 383     return S_OK;
 384 #endif
 385 }
 386
 387 // IWebMutableURLRequest ----------------------------------------------------
 388
 389 void WebMutableURLRequest::setFormData(const PassRefPtr<FormData> data)
 390 {
 391     m_request.setHTTPBody(data);
 392 }
 393
 394 const PassRefPtr<FormData> WebMutableURLRequest::formData() const
 395 {
 396     return m_request.httpBody();
 397 }
 398
 399 void WebMutableURLRequest::addHTTPHeaderFields(const HTTPHeaderMap& headerFields)
 400 {
 401     m_request.addHTTPHeaderFields(headerFields);
 402 }
 403
 404 const HTTPHeaderMap& WebMutableURLRequest::httpHeaderFields() const
 405 {
 406     return m_request.httpHeaderFields();
 407 }
 408
 409 const ResourceRequest& WebMutableURLRequest::resourceRequest() const
 410 {
 411     return m_request;
 412 }