content/test/net/url_request_slow_download_job.cc

   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/test/net/url_request_slow_download_job.h"
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "net/base/io_buffer.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/http/http_response_headers.h"
  17 #include "net/url_request/url_request.h"
  18 #include "net/url_request/url_request_filter.h"
  19 #include "url/gurl.h"
  20
  21 namespace content {
  22
  23 const char URLRequestSlowDownloadJob::kUnknownSizeUrl[] =
  24   "http://url.handled.by.slow.download/download-unknown-size";
  25 const char URLRequestSlowDownloadJob::kKnownSizeUrl[] =
  26   "http://url.handled.by.slow.download/download-known-size";
  27 const char URLRequestSlowDownloadJob::kFinishDownloadUrl[] =
  28   "http://url.handled.by.slow.download/download-finish";
  29 const char URLRequestSlowDownloadJob::kErrorDownloadUrl[] =
  30   "http://url.handled.by.slow.download/download-error";
  31
  32 const int URLRequestSlowDownloadJob::kFirstDownloadSize = 1024 * 35;
  33 const int URLRequestSlowDownloadJob::kSecondDownloadSize = 1024 * 10;
  34
  35 // static
  36 base::LazyInstance<URLRequestSlowDownloadJob::SlowJobsSet>::Leaky
  37     URLRequestSlowDownloadJob::pending_requests_ = LAZY_INSTANCE_INITIALIZER;
  38
  39 void URLRequestSlowDownloadJob::Start() {
  40   base::MessageLoop::current()->PostTask(
  41       FROM_HERE,
  42       base::Bind(&URLRequestSlowDownloadJob::StartAsync,
  43                  weak_factory_.GetWeakPtr()));
  44 }
  45
  46 // static
  47 void URLRequestSlowDownloadJob::AddUrlHandler() {
  48   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
  49   filter->AddUrlHandler(GURL(kUnknownSizeUrl),
  50                         &URLRequestSlowDownloadJob::Factory);
  51   filter->AddUrlHandler(GURL(kKnownSizeUrl),
  52                         &URLRequestSlowDownloadJob::Factory);
  53   filter->AddUrlHandler(GURL(kFinishDownloadUrl),
  54                         &URLRequestSlowDownloadJob::Factory);
  55   filter->AddUrlHandler(GURL(kErrorDownloadUrl),
  56                         &URLRequestSlowDownloadJob::Factory);
  57 }
  58
  59 // static
  60 net::URLRequestJob* URLRequestSlowDownloadJob::Factory(
  61     net::URLRequest* request,
  62     net::NetworkDelegate* network_delegate,
  63     const std::string& scheme) {
  64   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  65   URLRequestSlowDownloadJob* job = new URLRequestSlowDownloadJob(
  66       request, network_delegate);
  67   if (request->url().spec() != kFinishDownloadUrl &&
  68       request->url().spec() != kErrorDownloadUrl)
  69     pending_requests_.Get().insert(job);
  70   return job;
  71 }
  72
  73 // static
  74 size_t URLRequestSlowDownloadJob::NumberOutstandingRequests() {
  75   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  76   return pending_requests_.Get().size();
  77 }
  78
  79 // static
  80 void URLRequestSlowDownloadJob::FinishPendingRequests() {
  81   typedef std::set<URLRequestSlowDownloadJob*> JobList;
  82   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  83   for (JobList::iterator it = pending_requests_.Get().begin(); it !=
  84        pending_requests_.Get().end(); ++it) {
  85     (*it)->set_should_finish_download();
  86   }
  87 }
  88
  89 void URLRequestSlowDownloadJob::ErrorPendingRequests() {
  90   typedef std::set<URLRequestSlowDownloadJob*> JobList;
  91   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  92   for (JobList::iterator it = pending_requests_.Get().begin(); it !=
  93        pending_requests_.Get().end(); ++it) {
  94     (*it)->set_should_error_download();
  95   }
  96 }
  97
  98 URLRequestSlowDownloadJob::URLRequestSlowDownloadJob(
  99     net::URLRequest* request, net::NetworkDelegate* network_delegate)
 100     : net::URLRequestJob(request, network_delegate),
 101       bytes_already_sent_(0),
 102       should_error_download_(false),
 103       should_finish_download_(false),
 104       buffer_size_(0),
 105       weak_factory_(this) {
 106 }
 107
 108 void URLRequestSlowDownloadJob::StartAsync() {
 109   if (LowerCaseEqualsASCII(kFinishDownloadUrl, request_->url().spec().c_str()))
 110     URLRequestSlowDownloadJob::FinishPendingRequests();
 111   if (LowerCaseEqualsASCII(kErrorDownloadUrl, request_->url().spec().c_str()))
 112     URLRequestSlowDownloadJob::ErrorPendingRequests();
 113
 114   NotifyHeadersComplete();
 115 }
 116
 117 // ReadRawData and CheckDoneStatus together implement a state
 118 // machine.  ReadRawData may be called arbitrarily by the network stack.
 119 // It responds by:
 120 //      * If there are bytes remaining in the first chunk, they are
 121 //        returned.
 122 //      [No bytes remaining in first chunk.   ]
 123 //      * If should_finish_download_ is not set, it returns IO_PENDING,
 124 //        and starts calling CheckDoneStatus on a regular timer.
 125 //      [should_finish_download_ set.]
 126 //      * If there are bytes remaining in the second chunk, they are filled.
 127 //      * Otherwise, return *bytes_read = 0 to indicate end of request.
 128 // CheckDoneStatus is called on a regular basis, in the specific
 129 // case where we have transmitted all of the first chunk and none of the
 130 // second.  If should_finish_download_ becomes set, it will "complete"
 131 // the ReadRawData call that spawned off the CheckDoneStatus() repeated call.
 132 //
 133 // FillBufferHelper is a helper function that does the actual work of figuring
 134 // out where in the state machine we are and how we should fill the buffer.
 135 // It returns an enum indicating the state of the read.
 136 URLRequestSlowDownloadJob::ReadStatus
 137 URLRequestSlowDownloadJob::FillBufferHelper(
 138     net::IOBuffer* buf, int buf_size, int* bytes_written) {
 139   if (bytes_already_sent_ < kFirstDownloadSize) {
 140     int bytes_to_write = std::min(kFirstDownloadSize - bytes_already_sent_,
 141                                   buf_size);
 142     for (int i = 0; i < bytes_to_write; ++i) {
 143       buf->data()[i] = '*';
 144     }
 145     *bytes_written = bytes_to_write;
 146     bytes_already_sent_ += bytes_to_write;
 147     return BUFFER_FILLED;
 148   }
 149
 150   if (!should_finish_download_)
 151     return REQUEST_BLOCKED;
 152
 153   if (bytes_already_sent_ < kFirstDownloadSize + kSecondDownloadSize) {
 154     int bytes_to_write =
 155         std::min(kFirstDownloadSize + kSecondDownloadSize - bytes_already_sent_,
 156                  buf_size);
 157     for (int i = 0; i < bytes_to_write; ++i) {
 158       buf->data()[i] = '*';
 159     }
 160     *bytes_written = bytes_to_write;
 161     bytes_already_sent_ += bytes_to_write;
 162     return BUFFER_FILLED;
 163   }
 164
 165   return REQUEST_COMPLETE;
 166 }
 167
 168 bool URLRequestSlowDownloadJob::ReadRawData(net::IOBuffer* buf, int buf_size,
 169                                             int* bytes_read) {
 170   if (LowerCaseEqualsASCII(kFinishDownloadUrl,
 171                            request_->url().spec().c_str()) ||
 172       LowerCaseEqualsASCII(kErrorDownloadUrl,
 173                            request_->url().spec().c_str())) {
 174     VLOG(10) << __FUNCTION__ << " called w/ kFinish/ErrorDownloadUrl.";
 175     *bytes_read = 0;
 176     return true;
 177   }
 178
 179   VLOG(10) << __FUNCTION__ << " called at position "
 180            << bytes_already_sent_ << " in the stream.";
 181   ReadStatus status = FillBufferHelper(buf, buf_size, bytes_read);
 182   switch (status) {
 183     case BUFFER_FILLED:
 184       return true;
 185     case REQUEST_BLOCKED:
 186       buffer_ = buf;
 187       buffer_size_ = buf_size;
 188       SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
 189       base::MessageLoop::current()->PostDelayedTask(
 190           FROM_HERE,
 191           base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
 192                      weak_factory_.GetWeakPtr()),
 193           base::TimeDelta::FromMilliseconds(100));
 194       return false;
 195     case REQUEST_COMPLETE:
 196       *bytes_read = 0;
 197       return true;
 198   }
 199   NOTREACHED();
 200   return true;
 201 }
 202
 203 void URLRequestSlowDownloadJob::CheckDoneStatus() {
 204   if (should_finish_download_) {
 205     VLOG(10) << __FUNCTION__ << " called w/ should_finish_download_ set.";
 206     DCHECK(NULL != buffer_.get());
 207     int bytes_written = 0;
 208     ReadStatus status =
 209         FillBufferHelper(buffer_.get(), buffer_size_, &bytes_written);
 210     DCHECK_EQ(BUFFER_FILLED, status);
 211     buffer_ = NULL;                     // Release the reference.
 212     SetStatus(net::URLRequestStatus());
 213     NotifyReadComplete(bytes_written);
 214   } else if (should_error_download_) {
 215     VLOG(10) << __FUNCTION__ << " called w/ should_finish_ownload_ set.";
 216     NotifyDone(net::URLRequestStatus(
 217         net::URLRequestStatus::FAILED, net::ERR_CONNECTION_RESET));
 218   } else {
 219     base::MessageLoop::current()->PostDelayedTask(
 220         FROM_HERE,
 221         base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
 222                    weak_factory_.GetWeakPtr()),
 223         base::TimeDelta::FromMilliseconds(100));
 224   }
 225 }
 226
 227 // Public virtual version.
 228 void URLRequestSlowDownloadJob::GetResponseInfo(net::HttpResponseInfo* info) {
 229   // Forward to private const version.
 230   GetResponseInfoConst(info);
 231 }
 232
 233 URLRequestSlowDownloadJob::~URLRequestSlowDownloadJob() {
 234   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 235   pending_requests_.Get().erase(this);
 236 }
 237
 238 // Private const version.
 239 void URLRequestSlowDownloadJob::GetResponseInfoConst(
 240     net::HttpResponseInfo* info) const {
 241   // Send back mock headers.
 242   std::string raw_headers;
 243   if (LowerCaseEqualsASCII(kFinishDownloadUrl,
 244                            request_->url().spec().c_str()) ||
 245       LowerCaseEqualsASCII(kErrorDownloadUrl,
 246                            request_->url().spec().c_str())) {
 247     raw_headers.append(
 248       "HTTP/1.1 200 OK\n"
 249       "Content-type: text/plain\n");
 250   } else {
 251     raw_headers.append(
 252       "HTTP/1.1 200 OK\n"
 253       "Content-type: application/octet-stream\n"
 254       "Cache-Control: max-age=0\n");
 255
 256     if (LowerCaseEqualsASCII(kKnownSizeUrl, request_->url().spec().c_str())) {
 257       raw_headers.append(base::StringPrintf(
 258           "Content-Length: %d\n",
 259           kFirstDownloadSize + kSecondDownloadSize));
 260     }
 261   }
 262
 263   // ParseRawHeaders expects \0 to end each header line.
 264   ReplaceSubstringsAfterOffset(&raw_headers, 0, "\n", std::string("\0", 1));
 265   info->headers = new net::HttpResponseHeaders(raw_headers);
 266 }
 267
 268 bool URLRequestSlowDownloadJob::GetMimeType(std::string* mime_type) const {
 269   net::HttpResponseInfo info;
 270   GetResponseInfoConst(&info);
 271   return info.headers.get() && info.headers->GetMimeType(mime_type);
 272 }
 273
 274 }  // namespace content