blob: 4a0ba6e21291ca62a345ff57ca84526eefd59129 [file] [log] [blame]
// 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 "net/url_request/url_request_test_job.h"
#include <algorithm>
#include <list>
#include "base/bind.h"
#include "base/compiler_specific.h"
#include "base/lazy_instance.h"
#include "base/message_loop.h"
#include "base/string_util.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/http/http_response_headers.h"
#include "net/url_request/url_request.h"
namespace net {
namespace {
typedef std::list<URLRequestTestJob*> URLRequestJobList;
base::LazyInstance<URLRequestJobList>::Leaky
g_pending_jobs = LAZY_INSTANCE_INITIALIZER;
} // namespace
// static getters for known URLs
GURL URLRequestTestJob::test_url_1() {
return GURL("test:url1");
}
GURL URLRequestTestJob::test_url_2() {
return GURL("test:url2");
}
GURL URLRequestTestJob::test_url_3() {
return GURL("test:url3");
}
GURL URLRequestTestJob::test_url_error() {
return GURL("test:error");
}
// static getters for known URL responses
std::string URLRequestTestJob::test_data_1() {
return std::string("<html><title>Test One</title></html>");
}
std::string URLRequestTestJob::test_data_2() {
return std::string("<html><title>Test Two Two</title></html>");
}
std::string URLRequestTestJob::test_data_3() {
return std::string("<html><title>Test Three Three Three</title></html>");
}
// static getter for simple response headers
std::string URLRequestTestJob::test_headers() {
static const char kHeaders[] =
"HTTP/1.1 200 OK\0"
"Content-type: text/html\0"
"\0";
return std::string(kHeaders, arraysize(kHeaders));
}
// static getter for redirect response headers
std::string URLRequestTestJob::test_redirect_headers() {
static const char kHeaders[] =
"HTTP/1.1 302 MOVED\0"
"Location: somewhere\0"
"\0";
return std::string(kHeaders, arraysize(kHeaders));
}
// static getter for error response headers
std::string URLRequestTestJob::test_error_headers() {
static const char kHeaders[] =
"HTTP/1.1 500 BOO HOO\0"
"\0";
return std::string(kHeaders, arraysize(kHeaders));
}
// static
URLRequestJob* URLRequestTestJob::Factory(URLRequest* request,
const std::string& scheme) {
return new URLRequestTestJob(request);
}
URLRequestTestJob::URLRequestTestJob(URLRequest* request)
: URLRequestJob(request),
auto_advance_(false),
stage_(WAITING),
offset_(0),
async_buf_(NULL),
async_buf_size_(0),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
}
URLRequestTestJob::URLRequestTestJob(URLRequest* request,
bool auto_advance)
: URLRequestJob(request),
auto_advance_(auto_advance),
stage_(WAITING),
offset_(0),
async_buf_(NULL),
async_buf_size_(0),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
}
URLRequestTestJob::URLRequestTestJob(URLRequest* request,
const std::string& response_headers,
const std::string& response_data,
bool auto_advance)
: URLRequestJob(request),
auto_advance_(auto_advance),
stage_(WAITING),
response_headers_(new HttpResponseHeaders(response_headers)),
response_data_(response_data),
offset_(0),
async_buf_(NULL),
async_buf_size_(0),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
}
URLRequestTestJob::~URLRequestTestJob() {
g_pending_jobs.Get().erase(
std::remove(
g_pending_jobs.Get().begin(), g_pending_jobs.Get().end(), this),
g_pending_jobs.Get().end());
}
bool URLRequestTestJob::GetMimeType(std::string* mime_type) const {
DCHECK(mime_type);
if (!response_headers_)
return false;
return response_headers_->GetMimeType(mime_type);
}
void URLRequestTestJob::Start() {
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
MessageLoop::current()->PostTask(
FROM_HERE, base::Bind(&URLRequestTestJob::StartAsync,
weak_factory_.GetWeakPtr()));
}
void URLRequestTestJob::StartAsync() {
if (!response_headers_) {
response_headers_ = new HttpResponseHeaders(test_headers());
if (request_->url().spec() == test_url_1().spec()) {
response_data_ = test_data_1();
stage_ = DATA_AVAILABLE; // Simulate a synchronous response for this one.
} else if (request_->url().spec() == test_url_2().spec()) {
response_data_ = test_data_2();
} else if (request_->url().spec() == test_url_3().spec()) {
response_data_ = test_data_3();
} else {
AdvanceJob();
// unexpected url, return error
// FIXME(brettw) we may want to use WININET errors or have some more types
// of errors
NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
ERR_INVALID_URL));
// FIXME(brettw): this should emulate a network error, and not just fail
// initiating a connection
return;
}
}
AdvanceJob();
this->NotifyHeadersComplete();
}
bool URLRequestTestJob::ReadRawData(IOBuffer* buf, int buf_size,
int *bytes_read) {
if (stage_ == WAITING) {
async_buf_ = buf;
async_buf_size_ = buf_size;
SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
return false;
}
DCHECK(bytes_read);
*bytes_read = 0;
if (offset_ >= static_cast<int>(response_data_.length())) {
return true; // done reading
}
int to_read = buf_size;
if (to_read + offset_ > static_cast<int>(response_data_.length()))
to_read = static_cast<int>(response_data_.length()) - offset_;
memcpy(buf->data(), &response_data_.c_str()[offset_], to_read);
offset_ += to_read;
*bytes_read = to_read;
return true;
}
void URLRequestTestJob::GetResponseInfo(HttpResponseInfo* info) {
if (response_headers_)
info->headers = response_headers_;
}
int URLRequestTestJob::GetResponseCode() const {
if (response_headers_)
return response_headers_->response_code();
return -1;
}
bool URLRequestTestJob::IsRedirectResponse(GURL* location,
int* http_status_code) {
if (!response_headers_)
return false;
std::string value;
if (!response_headers_->IsRedirect(&value))
return false;
*location = request_->url().Resolve(value);
*http_status_code = response_headers_->response_code();
return true;
}
void URLRequestTestJob::Kill() {
stage_ = DONE;
URLRequestJob::Kill();
weak_factory_.InvalidateWeakPtrs();
g_pending_jobs.Get().erase(
std::remove(
g_pending_jobs.Get().begin(), g_pending_jobs.Get().end(), this),
g_pending_jobs.Get().end());
}
void URLRequestTestJob::ProcessNextOperation() {
switch (stage_) {
case WAITING:
// Must call AdvanceJob() prior to NotifyReadComplete() since that may
// delete |this|.
AdvanceJob();
stage_ = DATA_AVAILABLE;
// OK if ReadRawData wasn't called yet.
if (async_buf_) {
int bytes_read;
if (!ReadRawData(async_buf_, async_buf_size_, &bytes_read))
NOTREACHED() << "This should not return false in DATA_AVAILABLE.";
SetStatus(URLRequestStatus()); // clear the io pending flag
NotifyReadComplete(bytes_read);
}
break;
case DATA_AVAILABLE:
AdvanceJob();
stage_ = ALL_DATA; // done sending data
break;
case ALL_DATA:
stage_ = DONE;
return;
case DONE:
return;
default:
NOTREACHED() << "Invalid stage";
return;
}
}
void URLRequestTestJob::AdvanceJob() {
if (auto_advance_) {
MessageLoop::current()->PostTask(
FROM_HERE, base::Bind(&URLRequestTestJob::ProcessNextOperation,
weak_factory_.GetWeakPtr()));
return;
}
g_pending_jobs.Get().push_back(this);
}
// static
bool URLRequestTestJob::ProcessOnePendingMessage() {
if (g_pending_jobs.Get().empty())
return false;
URLRequestTestJob* next_job(g_pending_jobs.Get().front());
g_pending_jobs.Get().pop_front();
DCHECK(!next_job->auto_advance()); // auto_advance jobs should be in this q
next_job->ProcessNextOperation();
return true;
}
} // namespace net