Adds support for the <keygen> tag for client certificate enrollment...

chrome/browser/renderer_host/buffered_resource_handler.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/browser/renderer_host/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/renderer_host/download_throttling_resource_handler.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
+#include "chrome/browser/renderer_host/x509_user_cert_resource_handler.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/glue/plugins/plugin_list.h"
 
 namespace {
 
@@ skipping 259 matching lines @@
   return false;
 }
 
 bool BufferedResourceHandler::CompleteResponseStarted(int request_id,
                                                       bool in_complete) {
   // Check to see if we should forward the data from this request to the
   // download thread.
   // TODO(paulg): Only download if the context from the renderer allows it.
   ResourceDispatcherHostRequestInfo* info =
       ResourceDispatcherHost::InfoForRequest(request_);
+  std::string mime_type;
+  request_->GetMimeType(&mime_type);
+
+  // Check if this is an X.509 certificate, if yes, let it be handled
+  // by X509UserCertResourceHandler.
+  if (mime_type == "application/x-x509-user-cert") {
+
+    // This is entirely similar to how DownloadThrottlingResourceHandler
+    // works except we are doing it for an X.509 client certificates.
+
+    if (response_->response_head.headers &&  // Can be NULL if FTP.
+        response_->response_head.headers->response_code() / 100 != 2) {
+      // The response code indicates that this is an error page, but we are
+      // expecting an X.509 user certificate. We follow Firefox here and show
+      // our own error page instead of handling the error page as a
+      // certificate.
+      // TODO(abarth): We should abstract the response_code test, but this kind
+      //               of check is scattered throughout our codebase.
+      request_->SimulateError(net::ERR_FILE_NOT_FOUND);
+      return false;
+    }
+
+    scoped_refptr<X509UserCertResourceHandler> x509_cert_handler =
+        new X509UserCertResourceHandler(host_, request_);
+
+    if (bytes_read_) {
+      // A Read has already occured and we need to copy the data into the
+      // EventHandler.
+      net::IOBuffer* buf = NULL;
+      int buf_len = 0;
+      x509_cert_handler->OnWillRead(request_id, &buf, &buf_len, bytes_read_);
+      CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
+      memcpy(buf->data(), read_buffer_->data(), bytes_read_);
+    }
+
+    // Inform the renderer that this will be handled entirely by the browser.
+    real_handler_->OnResponseStarted(info->request_id(), response_);
+    URLRequestStatus status(URLRequestStatus::HANDLED_EXTERNALLY, 0);
+    real_handler_->OnResponseCompleted(info->request_id(), status,
+                                       std::string());
+
+    // This is handled entirely within the browser, so just reset the handler.
+    real_handler_ = x509_cert_handler;
+  }
 
   if (info->allow_download() && ShouldDownload(NULL)) {
     if (response_->response_head.headers &&  // Can be NULL if FTP.
         response_->response_head.headers->response_code() / 100 != 2) {
       // The response code indicates that this is an error page, but we don't
       // know how to display the content.  We follow Firefox here and show our
       // own error page instead of triggering a download.
       // TODO(abarth): We should abstract the response_code test, but this kind
       //               of check is scattered throughout our codebase.
       request_->SimulateError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     info->set_is_download(true);
 
     scoped_refptr<DownloadThrottlingResourceHandler> download_handler =
         new DownloadThrottlingResourceHandler(host_,
-                                             request_,
-                                             request_->url(),
-                                             info->child_id(),
-                                             info->route_id(),
-                                             request_id,
-                                             in_complete);
+                                              request_,
+                                              request_->url(),
+                                              info->child_id(),
+                                              info->route_id(),
+                                              request_id,
+                                              in_complete);
     if (bytes_read_) {
-      // a Read has already occurred and we need to copy the data into the
+      // A Read has already occurred and we need to copy the data into the
       // EventHandler.
       net::IOBuffer* buf = NULL;
       int buf_len = 0;
       download_handler->OnWillRead(request_id, &buf, &buf_len, bytes_read_);
       CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
       memcpy(buf->data(), read_buffer_->data(), bytes_read_);
     }
 
     // Send the renderer a response that indicates that the request will be
     // handled by an external source (the browser's DownloadManager).
@@ skipping 116 matching lines @@
   wait_for_plugins_ = false;
   if (request_) {
     ResourceDispatcherHostRequestInfo* info =
         ResourceDispatcherHost::InfoForRequest(request_);
     host_->PauseRequest(info->child_id(), info->request_id(), false);
     if (!CompleteResponseStarted(info->request_id(), false))
       host_->CancelRequest(info->child_id(), info->request_id(), false);
   }
   Release();
 }