src/content/browser/loader/stream_resource_handler.cc

   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     : ResourceHandler(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                                        scoped_refptr<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