Adding support for HEAD requests....

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 128 matching lines @@
 }
 
 HRESULT UrlmonUrlRequest::SetRequestData(RequestData* data) {
   request_data_ = data;
   return S_OK;
 }
 
 void UrlmonUrlRequest::StealMoniker(IMoniker** moniker) {
   // Could be called in any thread. There should be no race
   // since moniker_ is not released while we are in manager's request map.
+  DLOG(INFO) << __FUNCTION__ << " id: " << id();
+  DLOG_IF(WARNING, moniker == NULL) << __FUNCTION__ << " no moniker";
   *moniker = moniker_.Detach();
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnStartBinding(DWORD reserved,
                                               IBinding *binding) {
   DCHECK_EQ(thread_, PlatformThread::CurrentId());
   binding_ = binding;
   return S_OK;
 }
 
@@ skipping 145 matching lines @@
   bool upload_data = false;
 
   if (LowerCaseEqualsASCII(method(), "get")) {
     bind_info->dwBindVerb = BINDVERB_GET;
   } else if (LowerCaseEqualsASCII(method(), "post")) {
     bind_info->dwBindVerb = BINDVERB_POST;
     upload_data = true;
   } else if (LowerCaseEqualsASCII(method(), "put")) {
     bind_info->dwBindVerb = BINDVERB_PUT;
     upload_data = true;
+  } else if (LowerCaseEqualsASCII(method(), "head")) {
+    std::wstring verb(ASCIIToWide(StringToUpperASCII(method())));
+    bind_info->dwBindVerb = BINDVERB_CUSTOM;
+    bind_info->szCustomVerb = reinterpret_cast<wchar_t*>(
+        ::CoTaskMemAlloc((verb.length() + 1) * sizeof(wchar_t)));
+    lstrcpyW(bind_info->szCustomVerb, verb.c_str());
   } else {
     NOTREACHED() << "Unknown HTTP method.";
     status_.set_result(URLRequestStatus::FAILED, net::ERR_METHOD_NOT_SUPPORTED);
     NotifyDelegateAndDie();
     return E_FAIL;
   }
 
   if (upload_data) {
     // Bypass caching proxies on POSTs and PUTs and avoid writing responses to
     // these requests to the browser's cache
@@ skipping 583 matching lines @@
     new_request->SetRequestData(request_for_url->request_data());
   }
 
   DCHECK(LookupRequest(request_id).get() == NULL);
   request_map_[request_id] = new_request;
   map_empty_.Reset();
   new_request->Start();
 }
 
 void UrlmonUrlRequestManager::ReadRequest(int request_id, int bytes_to_read) {
-  DLOG(INFO) << __FUNCTION__;
+  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
   ExecuteInWorkerThread(FROM_HERE, NewRunnableMethod(this,
       &UrlmonUrlRequestManager::ReadRequestWorker, request_id, bytes_to_read));
 }
 
 void UrlmonUrlRequestManager::ReadRequestWorker(int request_id,
                                                 int bytes_to_read) {
-  DLOG(INFO) << __FUNCTION__;
+  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(worker_thread_.thread_id(), PlatformThread::CurrentId());
   scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id);
   // if zero, it may just have had network error.
   if (request) {
     request->Read(bytes_to_read);
   }
 }
 
 void UrlmonUrlRequestManager::EndRequest(int request_id) {
-  DLOG(INFO) << __FUNCTION__;
+  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
   ExecuteInWorkerThread(FROM_HERE, NewRunnableMethod(this,
       &UrlmonUrlRequestManager::EndRequestWorker, request_id));
 }
 
 void UrlmonUrlRequestManager::EndRequestWorker(int request_id) {
-  DLOG(INFO) << __FUNCTION__;
+  DLOG(INFO) << __FUNCTION__ << " id: " << request_id;
   DCHECK_EQ(worker_thread_.thread_id(), PlatformThread::CurrentId());
   scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id);
   if (request) {
     request->Stop();
   }
 }
 
 void UrlmonUrlRequestManager::StopAll() {
   DLOG(INFO) << __FUNCTION__;
   do {
@@ skipping 112 matching lines @@
     done.Wait();
 }
 
 void UrlmonUrlRequestManager::StealMonikerFromRequestWorker(int request_id,
     IMoniker** moniker, base::WaitableEvent* done) {
   if (!stopping_) {
     scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id);
     if (request) {
       request->StealMoniker(moniker);
       request->Stop();
+    } else {
+      DLOG(INFO) << __FUNCTION__ << " request not found.";
     }
+  } else {
+    DLOG(INFO) << __FUNCTION__ << " request stopping.";
   }
 
   done->Signal();
 }
 
 bool UrlmonUrlRequestManager::ExecuteInWorkerThread(
     const tracked_objects::Location& from_here, Task* task) {
   AutoLock lock(worker_thread_access_);
   if (stopping_) {
     delete task;
@@ skipping 32 matching lines @@
     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);
   }
 }