Home | History | Annotate | Download | only in loader 
      1 // Copyright (c) 2013 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/stream_resource_handler.h"
      6 
      7 #include "base/guid.h"
      8 #include "base/logging.h"
      9 #include "content/browser/streams/stream.h"
     10 #include "content/browser/streams/stream_registry.h"
     11 #include "content/public/browser/resource_controller.h"
     12 #include "content/public/common/url_constants.h"
     13 #include "net/base/io_buffer.h"
     14 #include "net/url_request/url_request_status.h"
     15 
     16 namespace content {
     17 
     18 StreamResourceHandler::StreamResourceHandler(
     19     net::URLRequest* request,
     20     StreamRegistry* registry,
     21     const GURL& origin)
     22     : request_(request),
     23       read_buffer_(NULL) {
     24   // TODO(tyoshino): Find a way to share this with the blob URL creation in
     25   // WebKit.
     26   GURL url(std::string(chrome::kBlobScheme) + ":" +
     27            origin.spec() + base::GenerateGUID());
     28   stream_ = new Stream(registry, this, url);
     29 }
     30 
     31 StreamResourceHandler::~StreamResourceHandler() {
     32   stream_->RemoveWriteObserver(this);
     33 }
     34 
     35 bool StreamResourceHandler::OnUploadProgress(int request_id,
     36                                              uint64 position,
     37                                              uint64 size) {
     38   return true;
     39 }
     40 
     41 bool StreamResourceHandler::OnRequestRedirected(int request_id,
     42                                                 const GURL& url,
     43                                                 ResourceResponse* resp,
     44                                                 bool* defer) {
     45   return true;
     46 }
     47 
     48 bool StreamResourceHandler::OnResponseStarted(int request_id,
     49                                               ResourceResponse* resp,
     50                                               bool* defer) {
     51   return true;
     52 }
     53 
     54 bool StreamResourceHandler::OnWillStart(int request_id,
     55                                         const GURL& url,
     56                                         bool* defer) {
     57   return true;
     58 }
     59 
     60 bool StreamResourceHandler::OnWillRead(int request_id,
     61                                        net::IOBuffer** buf,
     62                                        int* buf_size,
     63                                        int min_size) {
     64   static const int kReadBufSize = 32768;
     65 
     66   DCHECK(buf && buf_size);
     67   if (!read_buffer_.get())
     68     read_buffer_ = new net::IOBuffer(kReadBufSize);
     69   *buf = read_buffer_.get();
     70   *buf_size = kReadBufSize;
     71 
     72   return true;
     73 }
     74 
     75 bool StreamResourceHandler::OnReadCompleted(int request_id,
     76                                             int bytes_read,
     77                                             bool* defer) {
     78   if (!bytes_read)
     79     return true;
     80 
     81   // We have more data to read.
     82   DCHECK(read_buffer_.get());
     83 
     84   // Release the ownership of the buffer, and store a reference
     85   // to it. A new one will be allocated in OnWillRead().
     86   net::IOBuffer* buffer = NULL;
     87   read_buffer_.swap(&buffer);
     88   stream_->AddData(buffer, bytes_read);
     89 
     90   if (!stream_->can_add_data())
     91     *defer = true;
     92 
     93   return true;
     94 }
     95 
     96 bool StreamResourceHandler::OnResponseCompleted(
     97     int request_id,
     98     const net::URLRequestStatus& status,
     99     const std::string& sec_info) {
    100   stream_->Finalize();
    101   return status.status() == net::URLRequestStatus::SUCCESS;
    102 }
    103 
    104 void StreamResourceHandler::OnDataDownloaded(
    105     int request_id,
    106     int bytes_downloaded) {
    107   NOTREACHED();
    108 }
    109 
    110 void StreamResourceHandler::OnSpaceAvailable(Stream* stream) {
    111   controller()->Resume();
    112 }
    113 
    114 void StreamResourceHandler::OnClose(Stream* stream) {
    115   controller()->Cancel();
    116 }
    117 
    118 }  // namespace content
    119