Home | History | Annotate | Download | only in loader 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/loader/certificate_resource_handler.h"
      6 
      7 #include "base/strings/string_util.h"
      8 #include "content/browser/loader/resource_request_info_impl.h"
      9 #include "content/public/browser/content_browser_client.h"
     10 #include "content/public/common/resource_response.h"
     11 #include "net/base/io_buffer.h"
     12 #include "net/base/mime_sniffer.h"
     13 #include "net/base/mime_util.h"
     14 #include "net/http/http_response_headers.h"
     15 #include "net/url_request/redirect_info.h"
     16 #include "net/url_request/url_request.h"
     17 #include "net/url_request/url_request_status.h"
     18 
     19 namespace content {
     20 
     21 CertificateResourceHandler::CertificateResourceHandler(
     22     net::URLRequest* request)
     23     : ResourceHandler(request),
     24       content_length_(0),
     25       read_buffer_(NULL),
     26       resource_buffer_(NULL),
     27       cert_type_(net::CERTIFICATE_MIME_TYPE_UNKNOWN) {
     28 }
     29 
     30 CertificateResourceHandler::~CertificateResourceHandler() {
     31 }
     32 
     33 bool CertificateResourceHandler::OnUploadProgress(uint64 position,
     34                                                   uint64 size) {
     35   return true;
     36 }
     37 
     38 bool CertificateResourceHandler::OnRequestRedirected(
     39     const net::RedirectInfo& redirect_info,
     40     ResourceResponse* resp,
     41     bool* defer) {
     42   return true;
     43 }
     44 
     45 bool CertificateResourceHandler::OnResponseStarted(ResourceResponse* resp,
     46                                                    bool* defer) {
     47   cert_type_ = net::GetCertificateMimeTypeForMimeType(resp->head.mime_type);
     48   return cert_type_ != net::CERTIFICATE_MIME_TYPE_UNKNOWN;
     49 }
     50 
     51 bool CertificateResourceHandler::OnWillStart(const GURL& url, bool* defer) {
     52   return true;
     53 }
     54 
     55 bool CertificateResourceHandler::OnBeforeNetworkStart(const GURL& url,
     56                                                       bool* defer) {
     57   return true;
     58 }
     59 
     60 bool CertificateResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
     61                                             int* buf_size,
     62                                             int min_size) {
     63   static const int kReadBufSize = 32768;
     64 
     65   // TODO(gauravsh): Should we use 'min_size' here?
     66   DCHECK(buf && buf_size);
     67   if (!read_buffer_.get()) {
     68     read_buffer_ = new net::IOBuffer(kReadBufSize);
     69   }
     70   *buf = read_buffer_.get();
     71   *buf_size = kReadBufSize;
     72 
     73   return true;
     74 }
     75 
     76 bool CertificateResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
     77   if (!bytes_read)
     78     return true;
     79 
     80   // We have more data to read.
     81   DCHECK(read_buffer_.get());
     82   content_length_ += bytes_read;
     83 
     84   // Release the ownership of the buffer, and store a reference
     85   // to it. A new one will be allocated in OnWillRead().
     86   scoped_refptr<net::IOBuffer> buffer;
     87   read_buffer_.swap(buffer);
     88   // TODO(gauravsh): Should this be handled by a separate thread?
     89   buffer_.push_back(std::make_pair(buffer, bytes_read));
     90 
     91   return true;
     92 }
     93 
     94 void CertificateResourceHandler::OnResponseCompleted(
     95     const net::URLRequestStatus& urs,
     96     const std::string& sec_info,
     97     bool* defer) {
     98   if (urs.status() != net::URLRequestStatus::SUCCESS)
     99     return;
    100 
    101   AssembleResource();
    102 
    103   const void* content_bytes = NULL;
    104   if (resource_buffer_.get())
    105     content_bytes = resource_buffer_->data();
    106 
    107   // Note that it's up to the browser to verify that the certificate
    108   // data is well-formed.
    109   const ResourceRequestInfo* info = GetRequestInfo();
    110   GetContentClient()->browser()->AddCertificate(
    111       cert_type_, content_bytes, content_length_,
    112       info->GetChildID(), info->GetRenderFrameID());
    113 }
    114 
    115 void CertificateResourceHandler::AssembleResource() {
    116   // 0-length IOBuffers are not allowed.
    117   if (content_length_ == 0) {
    118     resource_buffer_ = NULL;
    119     return;
    120   }
    121 
    122   // Create the new buffer.
    123   resource_buffer_ = new net::IOBuffer(content_length_);
    124 
    125   // Copy the data into it.
    126   size_t bytes_copied = 0;
    127   for (size_t i = 0; i < buffer_.size(); ++i) {
    128     net::IOBuffer* data = buffer_[i].first.get();
    129     size_t data_len = buffer_[i].second;
    130     DCHECK(data != NULL);
    131     DCHECK_LE(bytes_copied + data_len, content_length_);
    132     memcpy(resource_buffer_->data() + bytes_copied, data->data(), data_len);
    133     bytes_copied += data_len;
    134   }
    135   DCHECK_EQ(content_length_, bytes_copied);
    136 }
    137 
    138 void CertificateResourceHandler::OnDataDownloaded(int bytes_downloaded) {
    139   NOTREACHED();
    140 }
    141 
    142 }  // namespace content
    143