With the ChromeFrame moniker patch on, the data cache maintained to indicate ...

chrome_frame/urlmon_bind_status_callback.cc

 // Copyright (c) 2010 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 "chrome_frame/urlmon_bind_status_callback.h"
 
 #include <mshtml.h>
 #include <shlguid.h>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 #include "chrome_frame/bind_context_info.h"
 #include "chrome_frame/urlmon_moniker.h"
 #include "chrome_tab.h"  // NOLINT
 
 
 // A helper to given feed data to the specified |bscb| using
 // CacheStream instance.
 HRESULT CacheStream::BSCBFeedData(IBindStatusCallback* bscb, const char* data,
                                   size_t size, CLIPFORMAT clip_format,
-                                  size_t flags) {
+                                  size_t flags, bool eof) {
   if (!bscb) {
     NOTREACHED() << "invalid IBindStatusCallback";
     return E_INVALIDARG;
   }
 
   // We can't use a CComObjectStackEx here since mshtml will hold
   // onto the stream pointer.
   CComObject<CacheStream>* cache_stream = NULL;
   HRESULT hr = CComObject<CacheStream>::CreateInstance(&cache_stream);
   if (FAILED(hr)) {
     NOTREACHED();
     return hr;
   }
 
   cache_stream->AddRef();
-  cache_stream->Initialize(data, size);
+  cache_stream->Initialize(data, size, eof);
 
   FORMATETC format_etc = { clip_format, NULL, DVASPECT_CONTENT, -1,
                            TYMED_ISTREAM };
   STGMEDIUM medium = {0};
   medium.tymed = TYMED_ISTREAM;
   medium.pstm = cache_stream;
 
   hr = bscb->OnDataAvailable(flags, size, &format_etc, &medium);
 
   cache_stream->Release();
   return hr;
 }
 
-void CacheStream::Initialize(const char* cache, size_t size) {
+void CacheStream::Initialize(const char* cache, size_t size, bool eof) {
   cache_ = cache;
   size_ = size;
   position_ = 0;
+  eof_ = eof;
 }
 
 // Read is the only call that we expect. Return E_PENDING if there
 // is no more data to serve. Otherwise this will result in a
 // read with 0 bytes indicating that no more data is available.
 STDMETHODIMP CacheStream::Read(void* pv, ULONG cb, ULONG* read) {
   if (!pv || !read)
     return E_INVALIDARG;
 
   // Default to E_PENDING to signal that this is a partial data.
-  HRESULT hr = E_PENDING;
+  HRESULT hr = eof_ ? S_FALSE : E_PENDING;
   if (position_ < size_) {
     *read = std::min(size_ - position_, size_t(cb));
     memcpy(pv, cache_ + position_, *read);
     position_ += *read;
     hr = S_OK;
   }
 
   return hr;
 }
 
@@ skipping 29 matching lines @@
       DWORD written = 0;
       cache_->Write(buffer, read, &written);
       size_ += written;
     }
 
     if ((S_FALSE == hr) || !read)
       break;
   }
 
   bool last_chance = force_determination || (size() >= kMaxSniffSize);
+  eof_ = force_determination;
   DetermineRendererType(last_chance);
   return hr;
 }
 
 HRESULT SniffData::DrainCache(IBindStatusCallback* bscb, DWORD bscf,
                               CLIPFORMAT clip_format) {
   if (!is_cache_valid()) {
     return S_OK;
   }
 
   // Ideally we could just use the cache_ IStream implementation but
   // can't use it here since we have to return E_PENDING for the
   // last call
   HGLOBAL memory = NULL;
   HRESULT hr = GetHGlobalFromStream(cache_, &memory);
   if (SUCCEEDED(hr) && memory) {
     char* buffer = reinterpret_cast<char*>(GlobalLock(memory));
-    hr = CacheStream::BSCBFeedData(bscb, buffer, size_, clip_format, bscf);
+    hr = CacheStream::BSCBFeedData(bscb, buffer, size_, clip_format, bscf,
+                                   eof_);
     GlobalUnlock(memory);
   }
 
   size_ = 0;
   cache_.Release();
   return hr;
 }
 
 // Scan the buffer or OptIn URL list and decide if the renderer is
 // to be switched.  Last chance means there's no more data.
@@ skipping 173 matching lines @@
     }
 
     hr = data_sniffer_.DrainCache(delegate(),
         flags | BSCF_FIRSTDATANOTIFICATION, clip_format_);
     DLOG_IF(WARNING, INET_E_TERMINATED_BIND != hr) << __FUNCTION__ <<
       " mshtml OnDataAvailable returned: " << std::hex << hr;
   }
 
   return hr;
 }