Add the chromeframe tag to the user agent header at runtime instead of static...

chrome_frame/protocol_sink_wrap.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <htiframe.h>
 
 #include "chrome_frame/protocol_sink_wrap.h"
 
-#include "base/scoped_bstr_win.h"
 #include "base/logging.h"
 #include "base/registry.h"
 #include "base/scoped_bstr_win.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 
 #include "chrome_frame/utils.h"
 
 // BINDSTATUS_SERVER_MIMETYPEAVAILABLE == 54. Introduced in IE 8, so
 // not in everyone's headers yet. See:
@@ skipping 206 matching lines @@
   if (url)
     url_ = url;
 
   CComCritSecLock<CComAutoCriticalSection> lock(sink_map_lock_);
   DCHECK(sink_map_.end() == sink_map_.find(protocol));
   sink_map_[protocol] = this;
   DLOG(INFO) << "ProtocolSinkWrap: active sinks: " << sink_map_.size();
   return true;
 }
 
-HRESULT WINAPI ProtocolSinkWrap::CheckOutgoingInterface(void* obj,
-    REFIID iid, LPVOID* ret, DWORD cookie) {
-  ProtocolSinkWrap* instance = reinterpret_cast<ProtocolSinkWrap*>(obj);
-  HRESULT hr = E_NOINTERFACE;
-  if (instance && instance->delegate_)
-    hr = instance->delegate_->QueryInterface(iid, ret);
-
-#ifndef NDEBUG
-  if (SUCCEEDED(hr)) {
-    wchar_t iid_string[64] = {0};
-    StringFromGUID2(iid, iid_string, arraysize(iid_string));
-    DLOG(INFO) << "Giving out wrapped interface: " << iid_string;
-  }
-#endif
-
-  return hr;
-}
-
-HRESULT WINAPI ProtocolSinkWrap::IfDelegateSupports(void* obj,
-    REFIID iid, LPVOID* ret, DWORD cookie) {
-  HRESULT hr = E_NOINTERFACE;
-  ProtocolSinkWrap* instance = reinterpret_cast<ProtocolSinkWrap*>(obj);
-  if (instance && instance->delegate_) {
-    ScopedComPtr<IUnknown> original;
-    hr = instance->delegate_->QueryInterface(iid,
-        reinterpret_cast<void**>(original.Receive()));
-    if (original) {
-      IUnknown* supported_interface = reinterpret_cast<IUnknown*>(
-          reinterpret_cast<DWORD_PTR>(obj) + cookie);
-      supported_interface->AddRef();
-      *ret = supported_interface;
-      hr = S_OK;
-    }
-  }
-
-  return hr;
-}
-
 // IInternetProtocolSink methods
 STDMETHODIMP ProtocolSinkWrap::Switch(PROTOCOLDATA* protocol_data) {
   HRESULT hr = E_FAIL;
   if (delegate_)
     hr = delegate_->Switch(protocol_data);
   return hr;
 }
 
 STDMETHODIMP ProtocolSinkWrap::ReportProgress(ULONG status_code,
     LPCWSTR status_text) {
   DLOG(INFO) << "ProtocolSinkWrap::ReportProgress: Code:" << status_code <<
-    " Text: " << (status_text ? status_text : L"");
+      " Text: " << (status_text ? status_text : L"");
   if ((BINDSTATUS_MIMETYPEAVAILABLE == status_code) ||
       (BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE == status_code)) {
     // If we have a MIMETYPE and that MIMETYPE is not "text/html". we don't
     // want to do anything with this.
     if (status_text) {
       size_t status_text_length = lstrlenW(status_text);
       const wchar_t* status_text_end = status_text + std::min(
           status_text_length, arraysize(kTextHtmlMimeType) - 1);
       if (!LowerCaseEqualsASCII(status_text, status_text_end,
                                 kTextHtmlMimeType)) {
@@ skipping 109 matching lines @@
   }
 
   HRESULT hr = E_FAIL;
   if (delegate_)
     hr = delegate_->ReportResult(result, error, result_text);
 
   return hr;
 }
 
 // IInternetBindInfoEx
-STDMETHODIMP ProtocolSinkWrap::GetBindInfo(
-    DWORD* flags, BINDINFO* bind_info_ret) {
+STDMETHODIMP ProtocolSinkWrap::GetBindInfo(DWORD* flags,
+    BINDINFO* bind_info_ret) {
   ScopedComPtr<IInternetBindInfo> bind_info;
   HRESULT hr = bind_info.QueryFrom(delegate_);
   if (bind_info)
     hr = bind_info->GetBindInfo(flags, bind_info_ret);
   return hr;
 }
 
 STDMETHODIMP ProtocolSinkWrap::GetBindString(ULONG string_type,
     LPOLESTR* string_array, ULONG array_size, ULONG* size_returned) {
   ScopedComPtr<IInternetBindInfo> bind_info;
   HRESULT hr = bind_info.QueryFrom(delegate_);
   if (bind_info)
     hr = bind_info->GetBindString(string_type, string_array,
         array_size, size_returned);
   return hr;
 }
 
-STDMETHODIMP ProtocolSinkWrap::GetBindInfoEx(DWORD *flags, BINDINFO* bind_info,
-    DWORD* bindf2, DWORD *reserved) {
+STDMETHODIMP ProtocolSinkWrap::GetBindInfoEx(DWORD* flags, BINDINFO* bind_info,
+    DWORD* bindf2, DWORD* reserved) {
   ScopedComPtr<IInternetBindInfoEx> bind_info_ex;
   HRESULT hr = bind_info_ex.QueryFrom(delegate_);
   if (bind_info_ex)
     hr = bind_info_ex->GetBindInfoEx(flags, bind_info, bindf2, reserved);
   return hr;
 }
 
 // IServiceProvider
 STDMETHODIMP ProtocolSinkWrap::QueryService(REFGUID service_guid,
     REFIID riid, void** service) {
@@ skipping 211 matching lines @@
   HRESULT hr = DoQueryService(GUID_NULL, sink, http_negotiate.Receive());
   if (http_negotiate)
     hr = DoQueryService(IID_ITargetFrame2, http_negotiate, web_browser);
 
   return hr;
 }
 
 ScopedComPtr<IInternetProtocolSink> ProtocolSinkWrap::MaybeWrapSink(
     IInternetProtocol* protocol, IInternetProtocolSink* prot_sink,
     const wchar_t* url) {
-  ScopedComPtr<IInternetProtocolSink> sink_to_use;
-  sink_to_use.QueryFrom(prot_sink);
+  ScopedComPtr<IInternetProtocolSink> sink_to_use(prot_sink);
   ScopedComPtr<IWebBrowser2> web_browser;
   WebBrowserFromProtocolSink(prot_sink, web_browser.Receive());
   if (web_browser) {
     CComObject<ProtocolSinkWrap>* wrap = NULL;
     CComObject<ProtocolSinkWrap>::CreateInstance(&wrap);
     DCHECK(wrap);
     if (wrap->Initialize(protocol, prot_sink, url)) {
       sink_to_use = wrap;
     }
   }
 
   return sink_to_use;
 }