Fix handling of user and CA certificates on Android.

content/browser/renderer_host/x509_user_cert_resource_handler.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/x509_user_cert_resource_handler.h"
 
 #include "base/string_util.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/x509_certificate.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace content {
 
 X509UserCertResourceHandler::X509UserCertResourceHandler(
     net::URLRequest* request,
     int render_process_host_id,
     int render_view_id)
     : request_(request),
       content_length_(0),
       read_buffer_(NULL),
       resource_buffer_(NULL),
       render_process_host_id_(render_process_host_id),
-      render_view_id_(render_view_id) {
+      render_view_id_(render_view_id),
+      is_pkcs12_(false) {
 }
 
 X509UserCertResourceHandler::~X509UserCertResourceHandler() {
 }
 
 bool X509UserCertResourceHandler::OnUploadProgress(int request_id,
                                                    uint64 position,
                                                    uint64 size) {
   return true;
 }
 
 bool X509UserCertResourceHandler::OnRequestRedirected(int request_id,
                                                       const GURL& url,
                                                       ResourceResponse* resp,
                                                       bool* defer) {
   url_ = url;
   return true;
 }
 
 bool X509UserCertResourceHandler::OnResponseStarted(int request_id,
                                                     ResourceResponse* resp,
                                                     bool* defer) {
+#if defined(OS_ANDROID)
+  is_pkcs12_ = (resp->head.mime_type == "application/x-pkcs12");
+  return (is_pkcs12_ ||
+          resp->head.mime_type == "application/x-x509-user-cert" ||
+          resp->head.mime_type == "application/x-x509-ca-cert");
+#else
   return (resp->head.mime_type == "application/x-x509-user-cert");
+#endif
 }
 
 bool X509UserCertResourceHandler::OnWillStart(int request_id,
                                               const GURL& url,
                                               bool* defer) {
   return true;
 }
 
 bool X509UserCertResourceHandler::OnWillRead(int request_id,
                                              net::IOBuffer** buf,
@@ skipping 33 matching lines @@
 }
 
 bool X509UserCertResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& urs,
     const std::string& sec_info) {
   if (urs.status() != net::URLRequestStatus::SUCCESS)
     return false;
 
   AssembleResource();
+#if defined(OS_ANDROID)
+  if (resource_buffer_ && content_length_ > 0) {
+    std::string cert_data(resource_buffer_->data(), content_length_);
+    content::GetContentClient()->browser()->AddNewCertificateOrKeychainAndroid(
+        request_, cert_data.c_str(), cert_data.length(), is_pkcs12_);
+  }
+#else  // OS_ANDROID
   scoped_refptr<net::X509Certificate> cert;
   if (resource_buffer_) {
       cert = net::X509Certificate::CreateFromBytes(resource_buffer_->data(),
                                                    content_length_);
   }
   GetContentClient()->browser()->AddNewCertificate(
       request_, cert, render_process_host_id_, render_view_id_);
+#endif  // OS_ANDROID
   return true;
 }
 
 void X509UserCertResourceHandler::AssembleResource() {
   // 0-length IOBuffers are not allowed.
   if (content_length_ == 0) {
     resource_buffer_ = NULL;
     return;
   }
 
   // Create the new buffer.
   resource_buffer_ = new net::IOBuffer(content_length_);
 
   // Copy the data into it.
   size_t bytes_copied = 0;
   for (size_t i = 0; i < buffer_.size(); ++i) {
     net::IOBuffer* data = buffer_[i].first;
     size_t data_len = buffer_[i].second;
     DCHECK(data != NULL);
     DCHECK_LE(bytes_copied + data_len, content_length_);
     memcpy(resource_buffer_->data() + bytes_copied, data->data(), data_len);
     bytes_copied += data_len;
   }
   DCHECK_EQ(content_length_, bytes_copied);
 }
 
 }  // namespace content