Ensure that window.open requests issued by ChromeFrame carry the correct cook...

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"
 #include "base/registry.h"
 #include "base/scoped_bstr_win.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 
+#include "chrome_frame/bho.h"
 #include "chrome_frame/bind_context_info.h"
 #include "chrome_frame/function_stub.h"
 #include "chrome_frame/utils.h"
 
 // BINDSTATUS_SERVER_MIMETYPEAVAILABLE == 54. Introduced in IE 8, so
 // not in everyone's headers yet. See:
 // http://msdn.microsoft.com/en-us/library/ms775133(VS.85,loband).aspx
 #ifndef BINDSTATUS_SERVER_MIMETYPEAVAILABLE
 #define BINDSTATUS_SERVER_MIMETYPEAVAILABLE 54
 #endif
 
 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;
 
 
 // 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);
+
+STDMETHODIMP Hook_UnlockRequest(InternetProtocol_UnlockRequest_Fn orig_req,
+                                IInternetProtocol* protocol);
+
 /////////////////////////////////////////////////////////////////////////////
 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)
 END_VTABLE_PATCHES()
 
 BEGIN_VTABLE_PATCHES(CTransaction2)
   VTABLE_PATCH_ENTRY(kInternetProtocolStartExIndex, Hook_StartEx)
 END_VTABLE_PATCHES()
 
 //
 // ProtocolSinkWrap implementation
 
 // Static map initialization
@@ skipping 423 matching lines @@
         << 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);
+  } else {
+    DLOG(WARNING) << "Failed to QI for IWinInetHttpInfo";
   }
 }
 
 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;
 }
 
+// This function looks for the url pattern indicating that this request needs
+// to be forced into chrome frame.
+// This hack is required because window.open requests from Chrome don't have
+// the URL up front. The URL comes in much later when the renderer initiates a
+// top level navigation for the url passed into window.open.
+// The new page must be rendered in ChromeFrame to preserve the opener
+// relationship with its parent even if the new page does not have the chrome
+// meta tag.
+bool HandleAttachToExistingExternalTab(LPCWSTR url,
+                                       IInternetProtocol* protocol,
+                                       IInternetProtocolSink* prot_sink,
+                                       IBindCtx* bind_ctx) {
+  if (MatchPatternWide(url, kChromeFrameAttachTabPattern)) {
+    scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
+    if (!prot_data) {
+      // Pass NULL as the read function which indicates that always return EOF
+      // without calling the underlying protocol.
+      prot_data = new ProtData(protocol, NULL, url);
+      PutProtData(bind_ctx, prot_data);
+    }
+
+    prot_sink->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
+
+    int data_flags = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION;
+    prot_sink->ReportData(data_flags, 0, 0);
+
+    prot_sink->ReportResult(S_OK, 0, NULL);
+    return true;
+  }
+  return false;
+}
+
 // IInternetProtocol/Ex hooks.
 STDMETHODIMP Hook_Start(InternetProtocol_Start_Fn orig_start,
     IInternetProtocol* protocol, LPCWSTR url, IInternetProtocolSink* prot_sink,
     IInternetBindInfo* bind_info, DWORD flags, HANDLE_PTR reserved) {
   DCHECK(orig_start);
   if (!url || !prot_sink || !bind_info)
     return E_INVALIDARG;
   DLOG_IF(INFO, url != NULL) << "OnStart: " << url << PiFlags2Str(flags);
 
   ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession
     DLOG(INFO) << "DirectBind for " << url;
     return orig_start(protocol, url, prot_sink, bind_info, flags, reserved);
   }
 
+  if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
+    return S_OK;
+  }
+
   if (IsCFRequest(bind_ctx)) {
     return orig_start(protocol, url, prot_sink, bind_info, flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data) {
     DLOG(INFO) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
     ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
@@ skipping 27 matching lines @@
   DLOG_IF(INFO, url != NULL) << "OnStartEx: " << url << PiFlags2Str(flags);
 
   ScopedComPtr<IBindCtx> bind_ctx = BindCtxFromIBindInfo(bind_info);
   if (!bind_ctx) {
     // MSHTML sometimes takes a short path, skips the creation of
     // moniker and binding, by directly grabbing protocol from InternetSession.
     DLOG(INFO) << "DirectBind for " << url;
     return orig_start_ex(protocol, uri, prot_sink, bind_info, flags, reserved);
   }
 
+  if (HandleAttachToExistingExternalTab(url, protocol, prot_sink, bind_ctx)) {
+    return S_OK;
+  }
+
   if (IsCFRequest(bind_ctx)) {
     return orig_start_ex(protocol, uri, prot_sink, bind_info, flags, reserved);
   }
 
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (prot_data) {
     DLOG(INFO) << "Found existing ProtData!";
     prot_data->UpdateUrl(url);
     ScopedComPtr<IInternetProtocolSink> new_sink =
         ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
@@ skipping 11 matching lines @@
   PutProtData(bind_ctx, prot_data);
 
   ScopedComPtr<IInternetProtocolSink> new_sink =
       ProtocolSinkWrap::CreateNewSink(prot_sink, prot_data);
   return orig_start_ex(protocol, uri, new_sink, bind_info, flags, reserved);
 }
 
 STDMETHODIMP Hook_Read(InternetProtocol_Read_Fn orig_read,
     IInternetProtocol* protocol, void* buffer, ULONG size, ULONG* size_read) {
   DCHECK(orig_read);
+  HRESULT hr = E_FAIL;
+
   scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
   if (!prot_data) {
-    return orig_read(protocol, buffer, size, size_read);
+    hr = orig_read(protocol, buffer, size, size_read);
+    return hr;
   }
 
-  HRESULT hr = prot_data->Read(buffer, size, size_read);
+  if (prot_data->is_attach_external_tab_request()) {
+    // return EOF always.
+    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) {
+  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;
+  }
+
+  return orig_req(protocol, options);
+}
+
+STDMETHODIMP Hook_UnlockRequest(InternetProtocol_UnlockRequest_Fn orig_req,
+                                IInternetProtocol* protocol) {
+  DCHECK(orig_req);
+
+  scoped_refptr<ProtData> prot_data = ProtData::DataFromProtocol(protocol);
+  if (prot_data && prot_data->is_attach_external_tab_request()) {
+    prot_data->Release();
+    return S_OK;
+  }
+
+  return orig_req(protocol);
+}
+
 // 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);
 }