Implement HTTP headers sniffing in the ProtocolSinkWrap, instead of relying o...

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 165 matching lines @@
   if (!status_text)
     return false;
   size_t status_text_length = lstrlenW(status_text);
   const wchar_t* status_text_end = status_text +
       std::min(status_text_length, arraysize(kTextHtmlMimeType) - 1);
   bool is_text_html = LowerCaseEqualsASCII(status_text, status_text_end,
                                            kTextHtmlMimeType);
   return is_text_html;
 }
 
+// Returns:
+// CHROME: if suggested mime type is "text/html" and at least one of the
+//         following is true: 1) X-UA-Compatible tag is in HTTP headers.
+//                            2) Url is listed in OptInURLs registry key.
+// OTHER: if suggested mime type is not text/html.
+// UNDETERMINED: if suggested mime type is text/html.
+RendererType DetermineRendererTypeFromMetaData(
+    const wchar_t* suggested_mime_type,
+    const std::wstring& url,
+    IWinInetHttpInfo* info) {
+  if (!IsTextHtml(suggested_mime_type)) {
+    return OTHER;
+  }
+
+  if (!url.empty() && IsOptInUrl(url.c_str())) {
+    return CHROME;
+  }
+
+  if (info) {
+    char buffer[32] = "x-ua-compatible";
+    DWORD len = sizeof(buffer);
+    DWORD flags = 0;
+    HRESULT hr = info->QueryInfo(HTTP_QUERY_CUSTOM, buffer, &len, &flags, NULL);
+    if (hr == S_OK && len > 0) {
+      if (StrStrIA(buffer, "chrome=1")) {
+        return CHROME;
+      }
+    }
+  }
+  return UNDETERMINED;
+}
+
 RendererType DetermineRendererType(void* buffer, DWORD size, bool last_chance) {
   RendererType type = UNDETERMINED;
   if (last_chance)
     type = OTHER;
 
   std::wstring html_contents;
   // TODO(joshia): detect and handle different content encodings
   UTF8ToWide(reinterpret_cast<char*>(buffer), size, &html_contents);
 
   // Note that document_contents_ may have NULL characters in it. While
   // browsers may handle this properly, we don't and will stop scanning
   // for the XUACompat content value if we encounter one.
   std::wstring xua_compat_content;
   UtilGetXUACompatContentValue(html_contents, &xua_compat_content);
   if (StrStrI(xua_compat_content.c_str(), kChromeContentPrefix)) {
     type = CHROME;
   }
 
   return type;
 }
 
 // ProtData
 ProtData::ProtData(IInternetProtocol* protocol,
                    InternetProtocol_Read_Fn read_fun, const wchar_t* url)
     : has_suggested_mime_type_(false), has_server_mime_type_(false),
-      report_data_received_(false), buffer_size_(0), buffer_pos_(0),
+      buffer_size_(0), buffer_pos_(0),
       renderer_type_(UNDETERMINED), protocol_(protocol), read_fun_(read_fun),
       url_(url) {
   memset(buffer_, 0, arraysize(buffer_));
   DLOG(INFO) << __FUNCTION__ << " " << this;
 
   // Add to map.
   AutoLock lock(datamap_lock_);
   DCHECK(datamap_.end() == datamap_.find(protocol_));
   datamap_[protocol] = this;
 }
@@ skipping 30 matching lines @@
     }
 
     if (size_read)
       *size_read = bytes_to_copy + new_data;
     return hr;
   }
 
   return read_fun_(protocol_, buffer, size, size_read);
 }
 
-
 HRESULT ProtData::ReportProgress(IInternetProtocolSink* delegate,
                                  ULONG status_code, LPCWSTR status_text) {
   switch (status_code) {
     case BINDSTATUS_DIRECTBIND:
       renderer_type_ = OTHER;
       break;
 
     case BINDSTATUS_REDIRECTING:
       url_.empty();
       if (status_text)
         url_ = status_text;
       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);
+
+      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;
+        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_);
+      }
       return S_OK;
   }
 
   return delegate->ReportProgress(status_code, status_text);
 }
 
 HRESULT ProtData::ReportData(IInternetProtocolSink* delegate,
                               DWORD flags, ULONG progress, ULONG max_progress) {
   if (renderer_type_ != UNDETERMINED) {
     return delegate->ReportData(flags, progress, max_progress);
   }
 
-  // Do these checks only once.
-  if (!report_data_received_) {
-    report_data_received_ = true;
-
-    DLOG_IF(INFO, (flags & BSCF_FIRSTDATANOTIFICATION) == 0) <<
-      "BUGBUG: BSCF_FIRSTDATANOTIFICATION is not set properly!";
-
-
-    // We check here, instead in ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE)
-    // to be safe when following multiple redirects.?
-    if (!IsTextHtml(suggested_mime_type_)) {
-      renderer_type_ = OTHER;
-      FireSugestedMimeType(delegate);
-      return delegate->ReportData(flags, progress, max_progress);
-    }
-
-    if (!url_.empty() && IsOptInUrl(url_.c_str())) {
-      // TODO(stoyan): We may attempt to remove ourselves from the bind context.
-      renderer_type_ = CHROME;
-      delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
-      return delegate->ReportData(flags, progress, max_progress);
-    }
-  }
-
   HRESULT hr = FillBuffer();
 
   bool last_chance = false;
   if (hr == S_OK || hr == S_FALSE) {
     last_chance = true;
   }
 
   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;
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
   }
 
   if (renderer_type_ == OTHER) {
     FireSugestedMimeType(delegate);
   }
 
-  // This is the first data notification we forward.
+  // This is the first data notification we forward, since up to now we hold
+  // the content received.
   flags |= BSCF_FIRSTDATANOTIFICATION;
 
   if (hr == S_FALSE) {
     flags |= (BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE);
   }
 
   return delegate->ReportData(flags, progress, max_progress);
 }
 
 HRESULT ProtData::ReportResult(IInternetProtocolSink* delegate, HRESULT result,
@@ skipping 271 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);
 }