Committing http://codereview.chromium.org/3420004/show for grt@...

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 255 matching lines @@
     return true;
   if (LowerCaseEqualsASCII(str, "video/webm"))
     return true;
   if (LowerCaseEqualsASCII(str, "video/mp4"))
     return true;
 
   return false;
 }
 
 // Returns:
-// CHROME: if suggested mime type is a supported one 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.
+// RENDERER_TYPE_OTHER: if suggested mime type is not text/html.
+// RENDERER_TYPE_UNDETERMINED: if suggested mime type is text/html.
+// RENDERER_TYPE_CHROME_RESPONSE_HEADER: X-UA-Compatible tag is in HTTP headers.
+// RENDERER_TYPE_CHROME_DEFAULT_RENDERER: GCF is the default renderer and the
+//                                        Url is not listed in the
+//                                        RenderInHostUrls registry key.
+// RENDERER_TYPE_CHROME_OPT_IN_URL: GCF is not the default renderer and the Url
+//                                  is listed in the RenderInGcfUrls registry
+//                                  key.
 RendererType DetermineRendererTypeFromMetaData(
     const wchar_t* suggested_mime_type,
     const std::wstring& url,
     IWinInetHttpInfo* info) {
 
   bool is_text_html = IsTextHtml(suggested_mime_type);
   bool is_supported_content_type = is_text_html ||
       IsAdditionallySupportedContentType(suggested_mime_type);
 
   if (!is_supported_content_type)
-    return OTHER;
+    return RENDERER_TYPE_OTHER;
 
-  if (!url.empty() && IsOptInUrl(url.c_str())) {
-    return CHROME;
+  if (!url.empty()) {
+    RendererType renderer_type = RendererTypeForUrl(url);
+    if (IsChrome(renderer_type)) {
+      return renderer_type;
+    }
   }
 
   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 RENDERER_TYPE_CHROME_RESPONSE_HEADER;
       }
     }
   }
 
   // We can (and want) to sniff the content.
   if (is_text_html) {
-    return UNDETERMINED;
+    return RENDERER_TYPE_UNDETERMINED;
   }
 
   // We cannot sniff the content.
-  return OTHER;
+  return RENDERER_TYPE_OTHER;
 }
 
 RendererType DetermineRendererType(void* buffer, DWORD size, bool last_chance) {
-  RendererType type = UNDETERMINED;
+  RendererType renderer_type = RENDERER_TYPE_UNDETERMINED;
   if (last_chance)
-    type = OTHER;
+    renderer_type = RENDERER_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;
+    renderer_type = RENDERER_TYPE_CHROME_HTTP_EQUIV;
   }
 
-  return type;
+  return renderer_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),
       buffer_size_(0), buffer_pos_(0),
-      renderer_type_(UNDETERMINED), protocol_(protocol), read_fun_(read_fun),
-      url_(url) {
+      renderer_type_(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;
 }
 
 ProtData::~ProtData() {
   DLOG(INFO) << __FUNCTION__ << " " << this;
   Invalidate();
 }
 
 HRESULT ProtData::Read(void* buffer, ULONG size, ULONG* size_read) {
-  if (renderer_type_ == UNDETERMINED) {
+  if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
     return E_PENDING;
   }
 
   const ULONG bytes_available = buffer_size_ - buffer_pos_;
   const ULONG bytes_to_copy = std::min(bytes_available, size);
   if (bytes_to_copy) {
     // Copy from the local buffer.
     memcpy(buffer, buffer_ + buffer_pos_, bytes_to_copy);
     *size_read = bytes_to_copy;
     buffer_pos_ += bytes_to_copy;
@@ skipping 10 matching lines @@
     if (size_read)
       *size_read = bytes_to_copy + new_data;
     return hr;
   }
 
   return read_fun_(protocol_, buffer, size, size_read);
 }
 
 // Attempt to detect ChromeFrame from HTTP headers when
 // BINDSTATUS_MIMETYPEAVAILABLE is received.
-// There are three possible outcomes: CHROME/OTHER/UNDETERMINED.
-// If UNDETERMINED we are going to sniff the content later in ReportData().
+// There are three possible outcomes: CHROME_*/OTHER/UNDETERMINED.
+// If RENDERER_TYPE_UNDETERMINED we are going to sniff the content later in
+// ReportData().
 //
 // With not-so-well-written software (mime filters/protocols/protocol patchers)
 // BINDSTATUS_MIMETYPEAVAILABLE might be fired multiple times with different
 // values for the same client.
 // If the renderer_type_ member is:
-// CHROME - 2nd (and any subsequent) BINDSTATUS_MIMETYPEAVAILABLE is ignored.
-// OTHER  - 2nd (and any subsequent) BINDSTATUS_MIMETYPEAVAILABLE is
-//          passed through.
-// UNDETERMINED - Try to detect ChromeFrame from HTTP headers (acts as if this
-//                is the first time BINDSTATUS_MIMETYPEAVAILABLE is received).
+// RENDERER_TYPE_CHROME_* - 2nd (and any subsequent)
+//                          BINDSTATUS_MIMETYPEAVAILABLE is ignored.
+// RENDERER_TYPE_OTHER  - 2nd (and any subsequent) BINDSTATUS_MIMETYPEAVAILABLE
+//                        is passed through.
+// RENDERER_TYPE_UNDETERMINED - Try to detect ChromeFrame from HTTP headers
+//                              (acts as if this is the first time
+//                              BINDSTATUS_MIMETYPEAVAILABLE is received).
 HRESULT ProtData::ReportProgress(IInternetProtocolSink* delegate,
                                  ULONG status_code, LPCWSTR status_text) {
   switch (status_code) {
     case BINDSTATUS_DIRECTBIND:
-      renderer_type_ = OTHER;
+      renderer_type_ = 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);
       // 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) {
+      if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
         // 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.
+      if (IsChrome(renderer_type_)) {
+        // Suggested mime type is "text/html" and we have DEFAULT_RENDERER,
+        // OPT_IN_URL, or RESPONSE_HEADER.
         DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
                    << kChromeMimeType;
         SaveReferrer(delegate);
         delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
-      } else if (renderer_type_ == OTHER) {
+      } else if (renderer_type_ == RENDERER_TYPE_OTHER) {
         // Suggested mime type is not "text/html" - we are not interested in
         // this request anymore.
         FireSuggestedMimeType(delegate);
       } else {
         // Suggested mime type is "text/html"; We will try to sniff the
         // HTML content in ReportData.
-        DCHECK_EQ(UNDETERMINED, renderer_type_);
+        DCHECK_EQ(RENDERER_TYPE_UNDETERMINED, renderer_type_);
       }
       return S_OK;
   }
 
   // We are just pass through at this point, avoid false positive crash reports.
   ExceptionBarrierReportOnlyModule barrier;
   return delegate->ReportProgress(status_code, status_text);
 }
 
 HRESULT ProtData::ReportData(IInternetProtocolSink* delegate,
                               DWORD flags, ULONG progress, ULONG max_progress) {
-  if (renderer_type_ != UNDETERMINED) {
+  if (renderer_type_ != RENDERER_TYPE_UNDETERMINED) {
     // We are just pass through now, avoid false positive crash reports.
     ExceptionBarrierReportOnlyModule barrier;
     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) {
+  if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
     // do not report anything, we need more data.
     return S_OK;
   }
 
-  if (renderer_type_ == CHROME) {
+  if (IsChrome(renderer_type_)) {
     DLOG(INFO) << "Forwarding BINDSTATUS_MIMETYPEAVAILABLE "
         << kChromeMimeType;
     SaveReferrer(delegate);
     delegate->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, kChromeMimeType);
   }
 
-  if (renderer_type_ == OTHER) {
+  if (renderer_type_ == RENDERER_TYPE_OTHER) {
     FireSuggestedMimeType(delegate);
   }
 
   // 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,
                                DWORD error, LPCWSTR result_text) {
   // We may receive ReportResult without ReportData, if the connection fails
   // for example.
-  if (renderer_type_ == UNDETERMINED) {
+  if (renderer_type_ == RENDERER_TYPE_UNDETERMINED) {
     DLOG(INFO) << "ReportResult received but renderer type is yet unknown.";
-    renderer_type_ = OTHER;
+    renderer_type_ = RENDERER_TYPE_OTHER;
     FireSuggestedMimeType(delegate);
   }
 
   HRESULT hr = S_OK;
   if (delegate)
     hr = delegate->ReportResult(result, error, result_text);
   return hr;
 }
 
 
@@ skipping 33 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_);
+  DCHECK(IsChrome(renderer_type_));
   ScopedComPtr<IWinInetHttpInfo> info;
   info.QueryFrom(delegate);
   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)
@@ skipping 356 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);
 }