Ensure that ChromeFrame does not interfere with non ChromeFrame requests initiated by IE.

chrome_frame/protocol_sink_wrap.cc

 // Copyright (c) 2011 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 20 matching lines @@
 bool ProtocolSinkWrap::ignore_xua_ = false;
 
 static const char kTextHtmlMimeType[] = "text/html";
 const wchar_t kUrlMonDllName[] = L"urlmon.dll";
 
 static const int kInternetProtocolStartIndex = 3;
 static const int kInternetProtocolReadIndex = 9;
 static const int kInternetProtocolStartExIndex = 13;
 static const int kInternetProtocolLockRequestIndex = 11;
 static const int kInternetProtocolUnlockRequestIndex = 12;
+static const int kInternetProtocolAbortIndex = 5;
+static const int kInternetProtocolTerminateIndex = 6;
 
 
 // IInternetProtocol/Ex patches.
 STDMETHODIMP Hook_Start(InternetProtocol_Start_Fn orig_start,
                         IInternetProtocol* protocol,
                         LPCWSTR url,
                         IInternetProtocolSink* prot_sink,
                         IInternetBindInfo* bind_info,
                         DWORD flags,
                         HANDLE_PTR reserved);
 
 STDMETHODIMP Hook_StartEx(InternetProtocol_StartEx_Fn orig_start_ex,
                           IInternetProtocolEx* protocol,
                           IUri* uri,
                           IInternetProtocolSink* prot_sink,
                           IInternetBindInfo* bind_info,
                           DWORD flags,
                           HANDLE_PTR reserved);
 
 STDMETHODIMP Hook_Read(InternetProtocol_Read_Fn orig_read,
                        IInternetProtocol* protocol,
                        void* buffer,
                        ULONG size,
                        ULONG* size_read);
 
 STDMETHODIMP Hook_LockRequest(InternetProtocol_LockRequest_Fn orig_req,
-                              IInternetProtocol* protocol, DWORD dwOptions);
+                              IInternetProtocol* protocol,
+                              DWORD options);
 
 STDMETHODIMP Hook_UnlockRequest(InternetProtocol_UnlockRequest_Fn orig_req,
                                 IInternetProtocol* protocol);
 
+STDMETHODIMP Hook_Abort(InternetProtocol_Abort_Fn orig_req,
+                        IInternetProtocol* protocol,
+                        HRESULT hr,
+                        DWORD options);
+
+STDMETHODIMP Hook_Terminate(InternetProtocol_Terminate_Fn orig_req,
+                            IInternetProtocol* protocol,
+                            DWORD options);
+
 /////////////////////////////////////////////////////////////////////////////
 BEGIN_VTABLE_PATCHES(CTransaction)
   VTABLE_PATCH_ENTRY(kInternetProtocolStartIndex, Hook_Start)
   VTABLE_PATCH_ENTRY(kInternetProtocolReadIndex, Hook_Read)
   VTABLE_PATCH_ENTRY(kInternetProtocolLockRequestIndex, Hook_LockRequest)
   VTABLE_PATCH_ENTRY(kInternetProtocolUnlockRequestIndex, Hook_UnlockRequest)
+  VTABLE_PATCH_ENTRY(kInternetProtocolAbortIndex, Hook_Abort)
+  VTABLE_PATCH_ENTRY(kInternetProtocolTerminateIndex, Hook_Terminate)
 END_VTABLE_PATCHES()
 
 BEGIN_VTABLE_PATCHES(CTransaction2)
   VTABLE_PATCH_ENTRY(kInternetProtocolStartExIndex, Hook_StartEx)
 END_VTABLE_PATCHES()
 
 //
 // ProtocolSinkWrap implementation
 
 // Static map initialization
@@ skipping 712 matching lines @@
     if (size_read)
       *size_read = 0;
     return S_FALSE;
   }
 
   hr = prot_data->Read(buffer, size, size_read);
   return hr;
 }
 
 STDMETHODIMP Hook_LockRequest(InternetProtocol_LockRequest_Fn orig_req,
-                              IInternetProtocol* protocol, DWORD options) {
+                              IInternetProtocol* protocol,
+                              DWORD options) {
   DCHECK(orig_req);
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data && prot_data->is_attach_external_tab_request()) {
     prot_data->AddRef();
     return S_OK;
   }
 
   // We are just pass through at this point, avoid false positive crash
   // reports.
@@ skipping 10 matching lines @@
     prot_data->Release();
     return S_OK;
   }
 
   // We are just pass through at this point, avoid false positive crash
   // reports.
   ExceptionBarrierReportOnlyModule barrier;
   return orig_req(protocol);
 }
 
+STDMETHODIMP Hook_Abort(InternetProtocol_Abort_Fn orig_req,
+                        IInternetProtocol* protocol,
+                        HRESULT hr,
+                        DWORD options) {
+  scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
+  if (prot_data)
+    prot_data->Invalidate();
+
+  // We are just pass through at this point, avoid false positive crash
+  // reports.
+  ExceptionBarrierReportOnlyModule barrier;
+  return orig_req(protocol, hr, options);
+}
+
+STDMETHODIMP Hook_Terminate(InternetProtocol_Terminate_Fn orig_req,
+                            IInternetProtocol* protocol,
+                            DWORD options) {
+  scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
+  if (prot_data)
+    prot_data->Invalidate();
+
+  // We are just pass through at this point, avoid false positive crash
+  // reports.
+  ExceptionBarrierReportOnlyModule barrier;
+  return orig_req(protocol, options);
+}
+
 // Patching / Hooking code.
 class FakeProtocol : public CComObjectRootEx<CComSingleThreadModel>,
                      public IInternetProtocol {
  public:
   BEGIN_COM_MAP(FakeProtocol)
     COM_INTERFACE_ENTRY(IInternetProtocol)
     COM_INTERFACE_ENTRY(IInternetProtocolRoot)
   END_COM_MAP()
 
   STDMETHOD(Start)(LPCWSTR url, IInternetProtocolSink *protocol_sink,
@@ skipping 89 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);
 }