chrome_frame/bind_status_callback_impl.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome_frame/bind_status_callback_impl.h"
   6
   7 #include "base/logging.h"
   8 #include "base/string_util.h"
   9 #include "base/stringprintf.h"
  10 #include "base/threading/platform_thread.h"
  11
  12 BSCBImpl::BSCBImpl() {
  13   DVLOG(1) << __FUNCTION__ << me();
  14 }
  15
  16 BSCBImpl::~BSCBImpl() {
  17   DVLOG(1) << __FUNCTION__ << me();
  18 }
  19
  20 std::string BSCBImpl::me() {
  21   return base::StringPrintf(" obj=0x%08X", static_cast<BSCBImpl*>(this));
  22 }
  23
  24 HRESULT BSCBImpl::DelegateQI(void* obj, REFIID iid, void** ret, DWORD cookie) {
  25   BSCBImpl* me = reinterpret_cast<BSCBImpl*>(obj);
  26   HRESULT hr = E_NOINTERFACE;
  27   if (me->delegate_)
  28     hr = me->delegate_.QueryInterface(iid, ret);
  29   return hr;
  30 }
  31
  32 void BSCBImpl::Initialize(IBindStatusCallback* original) {
  33   DCHECK(!delegate_);
  34   delegate_ = original;
  35 }
  36
  37 HRESULT BSCBImpl::AttachToBind(IBindCtx* bind_ctx) {
  38   HRESULT hr = S_OK;
  39   hr = ::RegisterBindStatusCallback(bind_ctx, this, delegate_.Receive(), 0);
  40   if (SUCCEEDED(hr)) {
  41     bind_ctx_ = bind_ctx;
  42   }
  43
  44   return hr;
  45 }
  46
  47 HRESULT BSCBImpl::ReleaseBind() {
  48   // AddRef ourselves while we release these objects as we might
  49   // perish during this operation.
  50   AddRef();
  51
  52   HRESULT hr = S_OK;
  53   if (bind_ctx_) {
  54     hr = ::RevokeBindStatusCallback(bind_ctx_, this);
  55   }
  56   delegate_.Release();
  57   bind_ctx_.Release();
  58
  59   Release();
  60
  61   return hr;
  62 }
  63
  64 // IServiceProvider
  65 HRESULT BSCBImpl::QueryService(REFGUID service, REFIID iid, void** object) {
  66   HRESULT hr = E_NOINTERFACE;
  67   if (delegate_) {
  68     base::win::ScopedComPtr<IServiceProvider> svc;
  69     svc.QueryFrom(delegate_);
  70     if (svc) {
  71       hr = svc->QueryService(service, iid, object);
  72     }
  73   }
  74   return hr;
  75 }
  76
  77 // IBindStatusCallback
  78 HRESULT BSCBImpl::OnStartBinding(DWORD reserved, IBinding* binding) {
  79   DVLOG(1) << __FUNCTION__ << me()
  80            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
  81   HRESULT hr = S_OK;
  82   if (delegate_)
  83     hr = delegate_->OnStartBinding(reserved, binding);
  84   return hr;
  85 }
  86
  87 HRESULT BSCBImpl::GetPriority(LONG* priority) {
  88   DVLOG(1) << __FUNCTION__ << me()
  89            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
  90   HRESULT hr = S_OK;
  91   if (delegate_)
  92     hr = delegate_->GetPriority(priority);
  93   return hr;
  94 }
  95
  96 HRESULT BSCBImpl::OnLowResource(DWORD reserved) {
  97   DVLOG(1) << __FUNCTION__ << me()
  98            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
  99   HRESULT hr = S_OK;
 100   if (delegate_)
 101     hr = delegate_->OnLowResource(reserved);
 102   return hr;
 103 }
 104
 105 HRESULT BSCBImpl::OnProgress(ULONG progress, ULONG progress_max,
 106                               ULONG status_code, LPCWSTR status_text) {
 107   DVLOG(1) << __FUNCTION__ << me()
 108            << base::StringPrintf(" status=%i tid=%i %ls", status_code,
 109                                  base::PlatformThread::CurrentId(),
 110                                  status_text);
 111   HRESULT hr = S_OK;
 112   if (delegate_)
 113     delegate_->OnProgress(progress, progress_max, status_code, status_text);
 114   return hr;
 115 }
 116
 117 HRESULT BSCBImpl::OnStopBinding(HRESULT hresult, LPCWSTR error) {
 118   DVLOG(1) << __FUNCTION__ << me()
 119            << base::StringPrintf(" hr=0x%08X '%ls' tid=%i", hresult, error,
 120                                  base::PlatformThread::CurrentId());
 121   HRESULT hr = S_OK;
 122   if (delegate_)
 123     delegate_->OnStopBinding(hresult, error);
 124   return hr;
 125 }
 126
 127 HRESULT BSCBImpl::GetBindInfo(DWORD* bindf, BINDINFO* bind_info) {
 128   DVLOG(1) << __FUNCTION__ << me()
 129            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 130   HRESULT hr = S_OK;
 131   if (delegate_)
 132     delegate_->GetBindInfo(bindf, bind_info);
 133   return hr;
 134 }
 135
 136 HRESULT BSCBImpl::OnDataAvailable(DWORD bscf, DWORD size,
 137                                    FORMATETC* format_etc, STGMEDIUM* stgmed) {
 138   DVLOG(1) << __FUNCTION__ << me()
 139            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 140   HRESULT hr = S_OK;
 141   if (delegate_)
 142     hr = delegate_->OnDataAvailable(bscf, size, format_etc, stgmed);
 143   return hr;
 144 }
 145
 146 HRESULT BSCBImpl::OnObjectAvailable(REFIID iid, IUnknown* unk) {
 147   DVLOG(1) << __FUNCTION__ << me()
 148            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 149   HRESULT hr = S_OK;
 150   if (delegate_)
 151     delegate_->OnObjectAvailable(iid, unk);
 152   return hr;
 153 }
 154
 155 // IBindStatusCallbackEx
 156 HRESULT BSCBImpl::GetBindInfoEx(DWORD* bindf, BINDINFO* bind_info,
 157                                 DWORD* bindf2, DWORD* reserved) {
 158   DVLOG(1) << __FUNCTION__ << me()
 159            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 160   HRESULT hr = S_OK;
 161   if (delegate_) {
 162     base::win::ScopedComPtr<IBindStatusCallbackEx> bscbex;
 163     bscbex.QueryFrom(delegate_);
 164     if (bscbex)
 165       hr = bscbex->GetBindInfoEx(bindf, bind_info, bindf2, reserved);
 166   }
 167   return hr;
 168 }
 169
 170 HRESULT BSCBImpl::BeginningTransaction(LPCWSTR url, LPCWSTR headers,
 171                                        DWORD reserved,
 172                                        LPWSTR* additional_headers) {
 173   DVLOG(1) << __FUNCTION__ << me()
 174            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 175
 176   HRESULT hr = S_OK;
 177   if (delegate_) {
 178     base::win::ScopedComPtr<IHttpNegotiate> http_negotiate;
 179     http_negotiate.QueryFrom(delegate_);
 180     if (http_negotiate) {
 181       hr = http_negotiate->BeginningTransaction(url, headers, reserved,
 182                                                 additional_headers);
 183     }
 184   }
 185
 186   DLOG_IF(ERROR, FAILED(hr)) << __FUNCTION__;
 187   return hr;
 188 }
 189
 190 HRESULT BSCBImpl::OnResponse(DWORD response_code, LPCWSTR response_headers,
 191                              LPCWSTR request_headers,
 192                              LPWSTR* additional_headers) {
 193   DVLOG(1) << __FUNCTION__ << me()
 194            << base::StringPrintf(" tid=%i", base::PlatformThread::CurrentId());
 195
 196   HRESULT hr = S_OK;
 197   if (delegate_) {
 198     base::win::ScopedComPtr<IHttpNegotiate> http_negotiate;
 199     http_negotiate.QueryFrom(delegate_);
 200     if (http_negotiate) {
 201       hr = http_negotiate->OnResponse(response_code, response_headers,
 202                                       request_headers, additional_headers);
 203     }
 204   }
 205   return hr;
 206 }
 207
 208 HRESULT BSCBImpl::GetRootSecurityId(BYTE* security_id, DWORD* security_id_size,
 209                                     DWORD_PTR reserved) {
 210   HRESULT hr = S_OK;
 211   if (delegate_) {
 212     base::win::ScopedComPtr<IHttpNegotiate2> http_negotiate;
 213     http_negotiate.QueryFrom(delegate_);
 214     if (http_negotiate) {
 215       hr = http_negotiate->GetRootSecurityId(security_id, security_id_size,
 216                                              reserved);
 217     }
 218   }
 219   return hr;
 220 }
 221
 222 HRESULT BSCBImpl::GetSerializedClientCertContext(BYTE** cert,
 223                                                  DWORD* cert_size) {
 224   HRESULT hr = S_OK;
 225   if (delegate_) {
 226     base::win::ScopedComPtr<IHttpNegotiate3> http_negotiate;
 227     http_negotiate.QueryFrom(delegate_);
 228     if (http_negotiate) {
 229       return http_negotiate->GetSerializedClientCertContext(cert, cert_size);
 230     }
 231   }
 232   return hr;
 233 }