Chromeframe user-agent without need of HttpNegotiate patch.

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 <mshtml.h>
 
 #include "chrome_frame/protocol_sink_wrap.h"
 
 #include "base/logging.h"
@@ skipping 73 matching lines @@
     IInternetProtocolSink* sink, ProtData* data) {
   DCHECK(sink != NULL);
   DCHECK(data != NULL);
   CComObject<ProtocolSinkWrap>* new_sink = NULL;
   CComObject<ProtocolSinkWrap>::CreateInstance(&new_sink);
   new_sink->delegate_ = sink;
   new_sink->prot_data_ = data;
   return ScopedComPtr<IInternetProtocolSink>(new_sink);
 }
 
+HRESULT ProtocolSinkWrap::ObtainServiceProvider() {
+  HRESULT hr = S_OK;
+  if (!delegate_service_provider_) {
+    hr = delegate_service_provider_.QueryFrom(delegate_);
+  }
+  return hr;
+}
+
+HRESULT ProtocolSinkWrap::ObtainHttpNegotiate() {
+  if (UserAgentAddOn::has_delegate())
+    return S_OK;
+
+  HRESULT hr = ObtainServiceProvider();
+  if (hr == S_OK) {
+    ScopedComPtr<IHttpNegotiate> http_negotiate;
+    hr = delegate_service_provider_->QueryService(
+        IID_IHttpNegotiate,
+        IID_IHttpNegotiate,
+        reinterpret_cast<void**>(http_negotiate.Receive()));
+    UserAgentAddOn::set_delegate(http_negotiate);
+  }
+  return hr;
+}
+
+STDMETHODIMP ProtocolSinkWrap::QueryService(REFGUID guidService, REFIID riid,
+                                            void** ppvObject) {
+  // We really insist to append "chromeframe" user-agent header, even in the
+  // very unlikely case when delegate does not support IServiceProvider and/or
+  // IHttpNegotiate.
+  if (guidService == IID_IHttpNegotiate && riid == IID_IHttpNegotiate) {
+    ObtainHttpNegotiate();
+    AddRef();
+    *ppvObject = reinterpret_cast<void**>(static_cast<IHttpNegotiate*>(this));
+    return S_OK;
+  }
+
+  HRESULT hr = ObtainServiceProvider();
+  if (hr == S_OK)
+    hr = delegate_service_provider_->QueryService(guidService, riid, ppvObject);
+  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) {
@@ skipping 207 matching lines @@
       break;
 
     case BINDSTATUS_SERVER_MIMETYPEAVAILABLE:
       has_server_mime_type_ = true;
       SaveSuggestedMimeType(status_text);
       return S_OK;
 
     // TODO(stoyan): BINDSTATUS_RAWMIMETYPE
     case BINDSTATUS_MIMETYPEAVAILABLE:
     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
-      SaveSuggestedMimeType(status_text);
-
-      ScopedComPtr<IWinInetHttpInfo> info;
-      info.QueryFrom(delegate);
-      renderer_type_ = DetermineRendererTypeFromMetaData(suggested_mime_type_,
-                                                         url_, info);
+      // When Transaction is attached i.e. when existing BTS it terminated
+      // and "converted" to BTO, events will be re-fired for the new sink,
+      // but we may skip the renderer_type_ determination since it's already
+      // done.
+      if (renderer_type_ == UNDETERMINED) {
+        SaveSuggestedMimeType(status_text);
+        // This may seem awkward. CBinding's implementation of IWinInetHttpInfo
+        // will forward to CTransaction that will forward to the real protocol.
+        // We may ask CTransaction (our protocol_ member) for IWinInetHttpInfo.
+        ScopedComPtr<IWinInetHttpInfo> info;
+        info.QueryFrom(delegate);
+        renderer_type_ = DetermineRendererTypeFromMetaData(suggested_mime_type_,
+                                                           url_, info);
+      }
 
       if (renderer_type_ == CHROME) {
         // Suggested mime type is "text/html" and we either have OptInUrl
         // or X-UA-Compatible HTTP headers.
         DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
                    << kChromeMimeType;
+        SaveReferrer(delegate);
         delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
       } else if (renderer_type_ == OTHER) {
         // Suggested mime type is not "text/html" - we are not interested in
         // this request anymore.
         FireSugestedMimeType(delegate);
       } else {
         // Suggested mime type is "text/html"; We will try to sniff the
         // HTML content in ReportData.
         DCHECK_EQ(UNDETERMINED, renderer_type_);
       }
@@ skipping 19 matching lines @@
   renderer_type_ = DetermineRendererType(buffer_, buffer_size_, last_chance);
 
   if (renderer_type_ == UNDETERMINED) {
     // do not report anything, we need more data.
     return S_OK;
   }
 
   if (renderer_type_ == CHROME) {
     DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
         << kChromeMimeType;
+    SaveReferrer(delegate);
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
   }
 
   if (renderer_type_ == OTHER) {
     FireSugestedMimeType(delegate);
   }
 
   // This is the first data notification we forward, since up to now we hold
   // the content received.
   flags |= BSCF_FIRSTDATANOTIFICATION;
@@ skipping 57 matching lines @@
   }
 
   if (has_suggested_mime_type_) {
     DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
         << suggested_mime_type_;
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE,
                              suggested_mime_type_);
   }
 }
 
+void ProtData::SaveReferrer(IInternetProtocolSink* delegate) {
+  DCHECK_EQ(CHROME, renderer_type_);
+  ScopedComPtr<IWinInetHttpInfo> info;
+  info.QueryFrom(delegate);
+  DCHECK(info);
+  if (info) {
+    char buffer[4096] = {0};
+    DWORD len = sizeof(buffer);
+    DWORD flags = 0;
+    HRESULT hr = info->QueryInfo(
+        HTTP_QUERY_REFERER | HTTP_QUERY_FLAG_REQUEST_HEADERS,
+        buffer, &len, &flags, 0);
+    if (hr == S_OK && len > 0)
+      referrer_.assign(buffer);
+  }
+}
+
 scoped_refptr<ProtData> ProtData::DataFromProtocol(
     IInternetProtocol* protocol) {
   scoped_refptr<ProtData> instance;
   AutoLock lock(datamap_lock_);
   ProtocolDataMap::iterator it = datamap_.find(protocol);
   if (datamap_.end() != it)
     instance = it->second;
   return instance;
 }
 
@@ skipping 203 matching lines @@
     // Explicit release, otherwise ~CComObjectStackEx will complain about
     // outstanding reference to us, because it runs before ~FakeProtocol
     prot.transaction_.Release();
   }
 }
 
 void TransactionHooks::RevertHooks() {
   vtable_patch::UnpatchInterfaceMethods(CTransaction_PatchInfo);
   vtable_patch::UnpatchInterfaceMethods(CTransaction2_PatchInfo);
 }