ChromeFrame's host network stack implementation for IE full tab mode implicit...

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 "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome_frame/chrome_frame_activex_base.h"
 #include "chrome_frame/html_utils.h"
 #include "chrome_frame/urlmon_upload_data_stream.h"
 #include "chrome_frame/utils.h"
 #include "net/http/http_util.h"
 #include "net/http/http_response_headers.h"
 
 static const LARGE_INTEGER kZero = {0};
 static const ULARGE_INTEGER kUnsignedZero = {0};
 int UrlmonUrlRequest::instance_count_ = 0;
 
 UrlmonUrlRequest::UrlmonUrlRequest()
     : pending_read_size_(0),
       status_(URLRequestStatus::FAILED, net::ERR_FAILED),
       thread_(PlatformThread::CurrentId()),
       redirect_status_(0),
       parent_window_(NULL),
-      worker_thread_(NULL) {
+      worker_thread_(NULL),
+      ignore_redirect_stop_binding_error_(false) {
   DLOG(INFO) << StringPrintf("Created request. Obj: %X", this)
       << " Count: " << ++instance_count_;
 }
 
 UrlmonUrlRequest::~UrlmonUrlRequest() {
   DLOG(INFO) << StringPrintf("Deleted request. Obj: %X", this)
       << " Count: " << --instance_count_;
 }
 
 bool UrlmonUrlRequest::Start() {
@@ skipping 129 matching lines @@
   *priority = THREAD_PRIORITY_NORMAL;
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnLowResource(DWORD reserved) {
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnProgress(ULONG progress, ULONG max_progress,
     ULONG status_code, LPCWSTR status_text) {
+  static const int kDefaultHttpRedirectCode = 302;
+
   switch (status_code) {
-    case BINDSTATUS_REDIRECTING:
+    case BINDSTATUS_REDIRECTING: {
+      // Fetch the redirect status as they aren't all equal (307 in particular
+      // retains the HTTP request verb).
+      // We assume that valid redirect codes are 301, 302, 303 and 307. If we
+      // receive anything else we would abort the request which would
+      // eventually result in the request getting cancelled in Chrome.
+      int redirect_status = GetHttpResponseStatus();
       DCHECK(status_text != NULL);
       DLOG(INFO) << "URL: " << url() << " redirected to "
                  << status_text;
       redirect_url_ = status_text;
-      // Fetch the redirect status as they aren't all equal (307 in particular
-      // retains the HTTP request verb).
-      redirect_status_ = GetHttpResponseStatus();
-      // NOTE: Even though RFC 2616 says to preserve the request method when
-      // following a 302 redirect, normal browsers don't do that. Instead they
-      // all convert a POST into a GET in response to a 302 and so shall we.
-      // For 307 redirects, browsers preserve the method.  The RFC says to
-      // prompt the user to confirm the generation of a new POST request, but
-      // IE omits this prompt and so shall we.
-      if (redirect_status_ != 307 &&
-          LowerCaseEqualsASCII(method(), "post")) {
-        set_method("get");
-        ClearPostData();
-      }
-      break;
+      redirect_status_ =
+          redirect_status > 0 ? redirect_status : kDefaultHttpRedirectCode;
+      // Chrome should decide whether a redirect has to be followed. To achieve
+      // this we send over a fake response to Chrome and abort the redirect.
+      std::string headers = GetHttpHeaders();
+      OnResponse(0, UTF8ToWide(headers).c_str(), NULL, NULL);
+      ignore_redirect_stop_binding_error_ = true;
+      DCHECK(binding_ != NULL);
+      binding_->Abort();
+      binding_ = NULL;
+      return E_ABORT;
+    }
 
     default:
       DLOG(INFO) << " Obj: " << std::hex << this << " OnProgress(" << url()
           << StringPrintf(L") code: %i status: %ls", status_code, status_text);
       break;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnStopBinding(HRESULT result, LPCWSTR error) {
   DCHECK(worker_thread_ != NULL);
   DCHECK_EQ(PlatformThread::CurrentId(), worker_thread_->thread_id());
 
   DLOG(INFO) << StringPrintf("URL: %s Obj: %X", url().c_str(), this) <<
       " - Request stopped, Result: " << std::hex << result <<
       " Status: " << status_.status();
+
   if (FAILED(result)) {
     status_.set_status(URLRequestStatus::FAILED);
     status_.set_os_error(HresultToNetError(result));
     EndRequest();
   } else {
     status_.set_status(URLRequestStatus::SUCCESS);
     status_.set_os_error(0);
   }
 
   DLOG(INFO) << "OnStopBinding received for request id: " << id();
@@ skipping 372 matching lines @@
   }
 
   DLOG_IF(ERROR, FAILED(hr))
       << StringPrintf(L"StartAsyncDownload failed: 0x%08X", hr);
 
   return hr;
 }
 
 void UrlmonUrlRequest::EndRequest() {
   DLOG(INFO) << __FUNCTION__;
-  // 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 specific
-  // ERR_UNSAFE_REDIRECT error value.
-  if (!status_.is_success() && status_.os_error() == net::ERR_ACCESS_DENIED) {
-    int status = GetHttpResponseStatus();
-    if (status >= 300 && status < 400) {
-      redirect_status_ = status;  // store the latest redirect status value.
-      status_.set_os_error(net::ERR_UNSAFE_REDIRECT);
+
+  // In case of a redirect notification we prevent urlmon from following the
+  // redirect and rely on Chrome, in which case AutomationMsg_RequestEnd
+  // IPC will be sent over by Chrome to end this request.
+  if (!ignore_redirect_stop_binding_error_) {
+    // 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
+    // specific ERR_UNSAFE_REDIRECT error value.
+    if (!status_.is_success() && status_.os_error() == net::ERR_ACCESS_DENIED) {
+      int status = GetHttpResponseStatus();
+      if (status >= 300 && status < 400) {
+        redirect_status_ = status;  // store the latest redirect status value.
+        status_.set_os_error(net::ERR_UNSAFE_REDIRECT);
+      }
     }
+    OnResponseEnd(status_);
+  } else {
+    ignore_redirect_stop_binding_error_ = false;
   }
 
-  OnResponseEnd(status_);
-
   // Remove the request mapping and release the outstanding reference to us in
   // the context of the UI thread.
   PostTask(FROM_HERE,
            NewRunnableMethod(this, &UrlmonUrlRequest::EndRequestInternal));
 }
 
 void UrlmonUrlRequest::EndRequestInternal() {
   // The request object could have been removed from the map in the
   // OnRequestEnd callback which executes on receiving the
   // AutomationMsg_RequestEnd IPC from Chrome.
   request_handler()->RemoveRequest(this);
   // The current instance could get destroyed in the context of DestroyWindow.
   // We should not access the object after this.
   DestroyWindow();
 }
 
 int UrlmonUrlRequest::GetHttpResponseStatus() const {
   if (binding_ == NULL) {
     DLOG(WARNING) << "GetHttpResponseStatus - no binding_";
     return 0;
   }
 
   int http_status = 0;
 
   ScopedComPtr<IWinInetHttpInfo> info;
   if (SUCCEEDED(info.QueryFrom(binding_))) {
     char status[10] = {0};
     DWORD buf_size = sizeof(status);
+    DWORD flags = 0;
+    DWORD reserved = 0;
     if (SUCCEEDED(info->QueryInfo(HTTP_QUERY_STATUS_CODE, status, &buf_size,
-                                  0, NULL))) {
+                                  &flags, &reserved))) {
       http_status = StringToInt(status);
     } else {
       NOTREACHED() << "Failed to get HTTP status";
     }
   } else {
     NOTREACHED() << "failed to get IWinInetHttpInfo from binding_";
   }
 
   return http_status;
 }
 
+std::string UrlmonUrlRequest::GetHttpHeaders() const {
+  if (binding_ == NULL) {
+    DLOG(WARNING) << "GetHttpResponseStatus - no binding_";
+    return std::string();
+  }
+
+  ScopedComPtr<IWinInetHttpInfo> info;
+  if (FAILED(info.QueryFrom(binding_))) {
+    DLOG(WARNING) << "Failed to QI for IWinInetHttpInfo";
+    return std::string();
+  }
+
+  scoped_ptr<char> buffer;
+  DWORD size = 0;
+  DWORD flags = 0;
+  DWORD reserved = 0;
+  HRESULT hr = info->QueryInfo(HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &size,
+                               &flags, &reserved);
+  if (!size) {
+    DLOG(WARNING) << "Failed to query HTTP headers size. Error 0x%x" << hr;
+    return std::string();
+  }
+
+  buffer.reset(new char[size]);
+  memset(buffer.get(), 0, size);
+
+  hr = info->QueryInfo(HTTP_QUERY_RAW_HEADERS_CRLF, buffer.get(),
+                       &size, &flags, &reserved);
+  if (FAILED(hr)) {
+    DLOG(WARNING) << "Failed to query HTTP headers. Error 0x%x" << hr;
+    return std::string();
+  }
+
+  return buffer.get();
+}
+
 //
 // UrlmonUrlRequest::Cache implementation.
 //
 
 size_t UrlmonUrlRequest::Cache::Size() {
   size_t size = 0;
   if (stream_) {
     STATSTG cache_stat = {0};
     stream_->Stat(&cache_stat, STATFLAG_NONAME);
 
@@ skipping 150 matching lines @@
       ret = net::ERR_ACCESS_DENIED;
       break;
 
     default:
       DLOG(WARNING)
           << StringPrintf("TODO: translate HRESULT 0x%08X to net::Error", hr);
       break;
   }
   return ret;
 }