Nicely steal moniker and bind context from the urlmon url request.

chrome_frame/urlmon_url_request.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 "chrome_frame/urlmon_url_request.h"
 
 #include <wininet.h>
 #include <urlmon.h>
 
 #include "base/scoped_ptr.h"
@@ skipping 120 matching lines @@
     cached_data_.Append(cache);
 
   // Request has already started and data is fetched. We will get the
   // GetBindInfo call as per contract but the return values are
   // ignored. So just set "get" as a method to make our GetBindInfo
   // implementation happy.
   method_ = "get";
   return S_OK;
 }
 
-void UrlmonUrlRequest::StealMoniker(IMoniker** moniker, IBindCtx** bctx) {
-  // Could be called in any thread. There should be no race
-  // since moniker_ is not released while we are in manager's request map.
+void UrlmonUrlRequest::TerminateBind(TerminateBindCallback* callback) {
+  DCHECK_EQ(thread_, PlatformThread::CurrentId());
   DLOG(INFO) << __FUNCTION__ << " id: " << id();
-  DLOG_IF(WARNING, moniker == NULL) << __FUNCTION__ << " no moniker";
-  *moniker = moniker_.Detach();
-  *bctx = bind_context_.Detach();
+
+  if (status_.get_state() == Status::DONE) {
+    // Binding is stopped. Note result could be an error.
+    callback->Run(moniker_, bind_context_);
+    delete callback;
+  } else {
+    // WORKING (ABORTING?). Save the callback.
+    // Now we will return INET_TERMINATE_BIND from ::OnDataAvailable() and in
+    // ::OnStopBinding will invoke the callback passing our moniker and
+    // bind context.
+    terminate_bind_callback_.reset(callback);
+  }
 }
 
 size_t UrlmonUrlRequest::SendDataToDelegate(size_t bytes_to_read) {
   size_t bytes_copied = 0;
   if (delegate_) {
     // We can optimize a bit by setting this string as a class member
     // and avoid frequent memory reallocations.
     std::string data;
 
     size_t bytes = std::min(static_cast<size_t>(bytes_to_read),
@@ skipping 107 matching lines @@
   DLOG(INFO) << StringPrintf("URL: %s Obj: %X", url().c_str(), this) <<
       " - Request stopped, Result: " << std::hex << result;
   DCHECK(status_.get_state() == Status::WORKING ||
          status_.get_state() == Status::ABORTING);
 
   Status::State state = status_.get_state();
 
   // Mark we a are done.
   status_.Done();
 
+  if (result == INET_E_TERMINATED_BIND && terminate_requested()) {
+    terminate_bind_callback_->Run(moniker_, bind_context_);
+  }
+
   // We always return INET_E_TERMINATED_BIND from OnDataAvailable
   if (result == INET_E_TERMINATED_BIND)
     result = S_OK;
 
   if (state == Status::WORKING) {
     status_.set_result(result);
 
     // Special case. If the last request was a redirect and the current OS
     // error value is E_ACCESSDENIED, that means an unsafe redirect was
     // attempted. In that case, correct the OS error value to be the more
@@ skipping 104 matching lines @@
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnDataAvailable(DWORD flags, DWORD size,
                                                FORMATETC* formatetc,
                                                STGMEDIUM* storage) {
   DLOG(INFO) << StringPrintf("URL: %s Obj: %X - Bytes available: %d",
                              url().c_str(), this, size);
 
+  if (terminate_requested())
+    return INET_E_TERMINATED_BIND;
+
   if (!storage || (storage->tymed != TYMED_ISTREAM)) {
     NOTREACHED();
     return E_INVALIDARG;
   }
 
   IStream* read_stream = storage->pstm;
   if (!read_stream) {
     NOTREACHED();
     return E_UNEXPECTED;
   }
@@ skipping 609 matching lines @@
   if (request) {
     request->Read(bytes_to_read);
   }
 }
 
 void UrlmonUrlRequestManager::DownloadRequestInHost(int request_id) {
   DLOG(INFO) << __FUNCTION__ << " " << request_id;
   if (IsWindow(notification_window_)) {
     scoped_refptr<UrlmonUrlRequest> request(LookupRequest(request_id));
     if (request) {
-      ScopedComPtr<IMoniker> moniker;
-      ScopedComPtr<IBindCtx> bind_context;
-      request->StealMoniker(moniker.Receive(), bind_context.Receive());
-      DLOG_IF(ERROR, moniker == NULL) << __FUNCTION__ << " No moniker!";
-      if (moniker) {
-        // We use SendMessage and not PostMessage to make sure that if the
-        // notification window does not handle the message we won't leak
-        // the moniker.
-        ::SendMessage(notification_window_, WM_DOWNLOAD_IN_HOST,
-            reinterpret_cast<WPARAM>(bind_context.get()),
-            reinterpret_cast<LPARAM>(moniker.get()));
-      }
+      UrlmonUrlRequest::TerminateBindCallback* callback = NewCallback(this,
+          &UrlmonUrlRequestManager::BindTerminated);
+      request->TerminateBind(callback);
     }
   } else {
     NOTREACHED()
         << "Cannot handle download if we don't have anyone to hand it to.";
   }
 }
 
+void UrlmonUrlRequestManager::BindTerminated(IMoniker* moniker,
+                                             IBindCtx* bind_ctx) {
+  // We use SendMessage and not PostMessage to make sure that if the
+  // notification window does not handle the message we won't leak
+  // the moniker.
+  ::SendMessage(notification_window_, WM_DOWNLOAD_IN_HOST,
+        reinterpret_cast<WPARAM>(bind_ctx),
+        reinterpret_cast<LPARAM>(moniker));
+}
+
+
 void UrlmonUrlRequestManager::GetCookiesForUrl(const GURL& url, int cookie_id) {
   DWORD cookie_size = 0;
   bool success = true;
   std::string cookie_string;
 
   int32 cookie_action = COOKIEACTION_READ;
   BOOL result = InternetGetCookieA(url.spec().c_str(), NULL, NULL,
                                    &cookie_size);
   DWORD error = 0;
   if (cookie_size) {
@@ skipping 154 matching lines @@
       privacy_info_.privacy_records[UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
   privacy_entry.policy_ref = UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }