blob: a156cbeec369fd2de22860ab65be4feb0f00a41b [file] [log] [blame]
// Copyright (c) 2010 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 "pdf/document_loader.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "net/http/http_util.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/cpp/url_loader.h"
#include "ppapi/cpp/url_request_info.h"
#include "ppapi/cpp/url_response_info.h"
namespace chrome_pdf {
namespace {
// Document below size will be downloaded in one chunk.
const uint32_t kMinFileSize = 64 * 1024;
// If the headers have a byte-range response, writes the start and end
// positions and returns true if at least the start position was parsed.
// The end position will be set to 0 if it was not found or parsed from the
// response.
// Returns false if not even a start position could be parsed.
bool GetByteRange(const std::string& headers, uint32_t* start, uint32_t* end) {
net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
while (it.GetNext()) {
if (base::LowerCaseEqualsASCII(it.name(), "content-range")) {
std::string range = it.values().c_str();
if (base::StartsWith(range, "bytes",
base::CompareCase::INSENSITIVE_ASCII)) {
range = range.substr(strlen("bytes"));
std::string::size_type pos = range.find('-');
std::string range_end;
if (pos != std::string::npos)
range_end = range.substr(pos + 1);
TrimWhitespaceASCII(range, base::TRIM_LEADING, &range);
TrimWhitespaceASCII(range_end, base::TRIM_LEADING, &range_end);
*start = atoi(range.c_str());
*end = atoi(range_end.c_str());
return true;
}
}
}
return false;
}
// If the headers have a multi-part response, returns the boundary name.
// Otherwise returns an empty string.
std::string GetMultiPartBoundary(const std::string& headers) {
net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
while (it.GetNext()) {
if (base::LowerCaseEqualsASCII(it.name(), "content-type")) {
std::string type = base::StringToLowerASCII(it.values());
if (base::StartsWith(type, "multipart/", base::CompareCase::SENSITIVE)) {
const char* boundary = strstr(type.c_str(), "boundary=");
if (!boundary) {
NOTREACHED();
break;
}
return std::string(boundary + 9);
}
}
}
return std::string();
}
bool IsValidContentType(const std::string& type) {
return (base::EndsWith(type, "/pdf", base::CompareCase::INSENSITIVE_ASCII) ||
base::EndsWith(type, ".pdf", base::CompareCase::INSENSITIVE_ASCII) ||
base::EndsWith(type, "/x-pdf",
base::CompareCase::INSENSITIVE_ASCII) ||
base::EndsWith(type, "/*", base::CompareCase::INSENSITIVE_ASCII) ||
base::EndsWith(type, "/acrobat",
base::CompareCase::INSENSITIVE_ASCII) ||
base::EndsWith(type, "/unknown",
base::CompareCase::INSENSITIVE_ASCII));
}
} // namespace
DocumentLoader::Client::~Client() {
}
DocumentLoader::DocumentLoader(Client* client)
: client_(client), partial_document_(false), request_pending_(false),
current_pos_(0), current_chunk_size_(0), current_chunk_read_(0),
document_size_(0), header_request_(true), is_multipart_(false) {
loader_factory_.Initialize(this);
}
DocumentLoader::~DocumentLoader() {
}
bool DocumentLoader::Init(const pp::URLLoader& loader,
const std::string& url,
const std::string& headers) {
DCHECK(url_.empty());
url_ = url;
loader_ = loader;
std::string response_headers;
if (!headers.empty()) {
response_headers = headers;
} else {
pp::URLResponseInfo response = loader_.GetResponseInfo();
pp::Var headers_var = response.GetHeaders();
if (headers_var.is_string()) {
response_headers = headers_var.AsString();
}
}
bool accept_ranges_bytes = false;
bool content_encoded = false;
uint32_t content_length = 0;
std::string type;
std::string disposition;
// This happens for PDFs not loaded from http(s) sources.
if (response_headers == "Content-Type: text/plain") {
if (!base::StartsWith(url, "http://",
base::CompareCase::INSENSITIVE_ASCII) &&
!base::StartsWith(url, "https://",
base::CompareCase::INSENSITIVE_ASCII)) {
type = "application/pdf";
}
}
if (type.empty() && !response_headers.empty()) {
net::HttpUtil::HeadersIterator it(response_headers.begin(),
response_headers.end(), "\n");
while (it.GetNext()) {
if (base::LowerCaseEqualsASCII(it.name(), "content-length")) {
content_length = atoi(it.values().c_str());
} else if (base::LowerCaseEqualsASCII(it.name(), "accept-ranges")) {
accept_ranges_bytes = base::LowerCaseEqualsASCII(it.values(), "bytes");
} else if (base::LowerCaseEqualsASCII(it.name(), "content-encoding")) {
content_encoded = true;
} else if (base::LowerCaseEqualsASCII(it.name(), "content-type")) {
type = it.values();
size_t semi_colon_pos = type.find(';');
if (semi_colon_pos != std::string::npos) {
type = type.substr(0, semi_colon_pos);
}
TrimWhitespace(type, base::TRIM_ALL, &type);
} else if (base::LowerCaseEqualsASCII(it.name(), "content-disposition")) {
disposition = it.values();
}
}
}
if (!type.empty() && !IsValidContentType(type))
return false;
if (base::StartsWith(disposition, "attachment",
base::CompareCase::INSENSITIVE_ASCII))
return false;
if (content_length > 0)
chunk_stream_.Preallocate(content_length);
document_size_ = content_length;
requests_count_ = 0;
// Enable partial loading only if file size is above the threshold.
// It will allow avoiding latency for multiple requests.
if (content_length > kMinFileSize &&
accept_ranges_bytes &&
!content_encoded) {
LoadPartialDocument();
} else {
LoadFullDocument();
}
return true;
}
void DocumentLoader::LoadPartialDocument() {
partial_document_ = true;
// Force the main request to be cancelled, since if we're a full-frame plugin
// there could be other references to the loader.
loader_.Close();
loader_ = pp::URLLoader();
// Download file header.
header_request_ = true;
RequestData(0, std::min(GetRequestSize(), document_size_));
}
void DocumentLoader::LoadFullDocument() {
partial_document_ = false;
chunk_buffer_.clear();
ReadMore();
}
bool DocumentLoader::IsDocumentComplete() const {
if (document_size_ == 0) // Document size unknown.
return false;
return IsDataAvailable(0, document_size_);
}
uint32_t DocumentLoader::GetAvailableData() const {
if (document_size_ == 0) { // If document size is unknown.
return current_pos_;
}
std::vector<std::pair<size_t, size_t> > ranges;
chunk_stream_.GetMissedRanges(0, document_size_, &ranges);
uint32_t available = document_size_;
for (const auto& range : ranges)
available -= range.second;
return available;
}
void DocumentLoader::ClearPendingRequests() {
// The first item in the queue is pending (need to keep it in the queue).
if (pending_requests_.size() > 1) {
// Remove all elements except the first one.
pending_requests_.erase(++pending_requests_.begin(),
pending_requests_.end());
}
}
bool DocumentLoader::GetBlock(uint32_t position,
uint32_t size,
void* buf) const {
return chunk_stream_.ReadData(position, size, buf);
}
bool DocumentLoader::IsDataAvailable(uint32_t position, uint32_t size) const {
return chunk_stream_.IsRangeAvailable(position, size);
}
void DocumentLoader::RequestData(uint32_t position, uint32_t size) {
DCHECK(partial_document_);
// We have some artefact request from
// PDFiumEngine::OnDocumentComplete() -> FPDFAvail_IsPageAvail after
// document is complete.
// We need this fix in PDFIum. Adding this as a work around.
// Bug: http://code.google.com/p/chromium/issues/detail?id=79996
// Test url:
// http://www.icann.org/en/correspondence/holtzman-to-jeffrey-02mar11-en.pdf
if (IsDocumentComplete())
return;
pending_requests_.push_back(std::pair<size_t, size_t>(position, size));
DownloadPendingRequests();
}
void DocumentLoader::DownloadPendingRequests() {
if (request_pending_ || pending_requests_.empty())
return;
// Remove already completed requests.
// By design DownloadPendingRequests() should have at least 1 request in the
// queue. ReadComplete() will remove the last pending comment from the queue.
while (pending_requests_.size() > 1) {
if (IsDataAvailable(pending_requests_.front().first,
pending_requests_.front().second)) {
pending_requests_.pop_front();
} else {
break;
}
}
uint32_t pos = pending_requests_.front().first;
uint32_t size = pending_requests_.front().second;
if (IsDataAvailable(pos, size)) {
ReadComplete();
return;
}
// If current request has been partially downloaded already, split it into
// a few smaller requests.
std::vector<std::pair<size_t, size_t> > ranges;
chunk_stream_.GetMissedRanges(pos, size, &ranges);
if (!ranges.empty()) {
pending_requests_.pop_front();
pending_requests_.insert(pending_requests_.begin(),
ranges.begin(), ranges.end());
pos = pending_requests_.front().first;
size = pending_requests_.front().second;
}
uint32_t cur_request_size = GetRequestSize();
// If size is less than default request, try to expand download range for
// more optimal download.
if (size < cur_request_size && partial_document_) {
// First, try to expand block towards the end of the file.
uint32_t new_pos = pos;
uint32_t new_size = cur_request_size;
if (pos + new_size > document_size_)
new_size = document_size_ - pos;
std::vector<std::pair<size_t, size_t> > ranges;
if (chunk_stream_.GetMissedRanges(new_pos, new_size, &ranges)) {
new_pos = ranges[0].first;
new_size = ranges[0].second;
}
// Second, try to expand block towards the beginning of the file.
if (new_size < cur_request_size) {
uint32_t block_end = new_pos + new_size;
if (block_end > cur_request_size) {
new_pos = block_end - cur_request_size;
} else {
new_pos = 0;
}
new_size = block_end - new_pos;
if (chunk_stream_.GetMissedRanges(new_pos, new_size, &ranges)) {
new_pos = ranges.back().first;
new_size = ranges.back().second;
}
}
pos = new_pos;
size = new_size;
}
size_t last_byte_before = chunk_stream_.GetLastByteBefore(pos);
size_t first_byte_after = chunk_stream_.GetFirstByteAfter(pos + size - 1);
if (pos - last_byte_before < cur_request_size) {
size = pos + size - last_byte_before;
pos = last_byte_before;
}
if ((pos + size < first_byte_after) &&
(pos + size + cur_request_size >= first_byte_after))
size = first_byte_after - pos;
request_pending_ = true;
// Start downloading first pending request.
loader_.Close();
loader_ = client_->CreateURLLoader();
pp::CompletionCallback callback =
loader_factory_.NewCallback(&DocumentLoader::DidOpen);
pp::URLRequestInfo request = GetRequest(pos, size);
requests_count_++;
int rv = loader_.Open(request, callback);
if (rv != PP_OK_COMPLETIONPENDING)
callback.Run(rv);
}
pp::URLRequestInfo DocumentLoader::GetRequest(uint32_t position,
uint32_t size) const {
pp::URLRequestInfo request(client_->GetPluginInstance());
request.SetURL(url_);
request.SetMethod("GET");
request.SetFollowRedirects(true);
request.SetCustomReferrerURL(url_);
const size_t kBufSize = 100;
char buf[kBufSize];
// According to rfc2616, byte range specifies position of the first and last
// bytes in the requested range inclusively. Therefore we should subtract 1
// from the position + size, to get index of the last byte that needs to be
// downloaded.
base::snprintf(buf, kBufSize, "Range: bytes=%d-%d", position,
position + size - 1);
pp::Var header(buf);
request.SetHeaders(header);
return request;
}
void DocumentLoader::DidOpen(int32_t result) {
if (result != PP_OK) {
NOTREACHED();
return;
}
int32_t http_code = loader_.GetResponseInfo().GetStatusCode();
if (http_code >= 400 && http_code < 500) {
// Error accessing resource. 4xx error indicate subsequent requests
// will fail too.
// E.g. resource has been removed from the server while loading it.
// https://code.google.com/p/chromium/issues/detail?id=414827
return;
}
is_multipart_ = false;
current_chunk_size_ = 0;
current_chunk_read_ = 0;
pp::Var headers_var = loader_.GetResponseInfo().GetHeaders();
std::string headers;
if (headers_var.is_string())
headers = headers_var.AsString();
std::string boundary = GetMultiPartBoundary(headers);
if (!boundary.empty()) {
// Leave position untouched for now, when we read the data we'll get it.
is_multipart_ = true;
multipart_boundary_ = boundary;
} else {
// Need to make sure that the server returned a byte-range, since it's
// possible for a server to just ignore our bye-range request and just
// return the entire document even if it supports byte-range requests.
// i.e. sniff response to
// http://www.act.org/compass/sample/pdf/geometry.pdf
current_pos_ = 0;
uint32_t start_pos, end_pos;
if (GetByteRange(headers, &start_pos, &end_pos)) {
current_pos_ = start_pos;
if (end_pos && end_pos > start_pos)
current_chunk_size_ = end_pos - start_pos + 1;
}
}
ReadMore();
}
void DocumentLoader::ReadMore() {
pp::CompletionCallback callback =
loader_factory_.NewCallback(&DocumentLoader::DidRead);
int rv = loader_.ReadResponseBody(buffer_, sizeof(buffer_), callback);
if (rv != PP_OK_COMPLETIONPENDING)
callback.Run(rv);
}
void DocumentLoader::DidRead(int32_t result) {
if (result > 0) {
char* start = buffer_;
size_t length = result;
if (is_multipart_ && result > 2) {
for (int i = 2; i < result; ++i) {
if ((buffer_[i - 1] == '\n' && buffer_[i - 2] == '\n') ||
(i >= 4 &&
buffer_[i - 1] == '\n' && buffer_[i - 2] == '\r' &&
buffer_[i - 3] == '\n' && buffer_[i - 4] == '\r')) {
uint32_t start_pos, end_pos;
if (GetByteRange(std::string(buffer_, i), &start_pos, &end_pos)) {
current_pos_ = start_pos;
start += i;
length -= i;
if (end_pos && end_pos > start_pos)
current_chunk_size_ = end_pos - start_pos + 1;
}
break;
}
}
// Reset this flag so we don't look inside the buffer in future calls of
// DidRead for this response. Note that this code DOES NOT handle multi-
// part responses with more than one part (we don't issue them at the
// moment, so they shouldn't arrive).
is_multipart_ = false;
}
if (current_chunk_size_ &&
current_chunk_read_ + length > current_chunk_size_)
length = current_chunk_size_ - current_chunk_read_;
if (length) {
if (document_size_ > 0) {
chunk_stream_.WriteData(current_pos_, start, length);
} else {
// If we did not get content-length in the response, we can't
// preallocate buffer for the entire document. Resizing array causing
// memory fragmentation issues on the large files and OOM exceptions.
// To fix this, we collect all chunks of the file to the list and
// concatenate them together after request is complete.
chunk_buffer_.push_back(std::vector<unsigned char>());
chunk_buffer_.back().resize(length);
memcpy(&(chunk_buffer_.back()[0]), start, length);
}
current_pos_ += length;
current_chunk_read_ += length;
client_->OnNewDataAvailable();
}
ReadMore();
} else if (result == PP_OK) {
ReadComplete();
} else {
NOTREACHED();
}
}
void DocumentLoader::ReadComplete() {
if (!partial_document_) {
if (document_size_ == 0) {
// For the document with no 'content-length" specified we've collected all
// the chunks already. Let's allocate final document buffer and copy them
// over.
chunk_stream_.Preallocate(current_pos_);
uint32_t pos = 0;
for (auto& chunk : chunk_buffer_) {
chunk_stream_.WriteData(pos, &(chunk[0]), chunk.size());
pos += chunk.size();
}
chunk_buffer_.clear();
}
document_size_ = current_pos_;
client_->OnDocumentComplete();
return;
}
request_pending_ = false;
pending_requests_.pop_front();
// If there are more pending request - continue downloading.
if (!pending_requests_.empty()) {
DownloadPendingRequests();
return;
}
if (IsDocumentComplete()) {
client_->OnDocumentComplete();
return;
}
if (header_request_)
client_->OnPartialDocumentLoaded();
else
client_->OnPendingRequestComplete();
header_request_ = false;
// The OnPendingRequestComplete could have added more requests.
if (!pending_requests_.empty()) {
DownloadPendingRequests();
} else {
// Document is not complete and we have no outstanding requests.
// Let's keep downloading PDF file in small chunks.
uint32_t pos = chunk_stream_.GetFirstMissingByte();
std::vector<std::pair<size_t, size_t> > ranges;
chunk_stream_.GetMissedRanges(pos, GetRequestSize(), &ranges);
DCHECK(!ranges.empty());
RequestData(ranges[0].first, ranges[0].second);
}
}
uint32_t DocumentLoader::GetRequestSize() const {
// Document loading strategy:
// For first 10 requests, we use 32k chunk sizes, for the next 10 requests we
// double the size (64k), and so on, until we cap max request size at 2M for
// 71 or more requests.
uint32_t limited_count = std::min(std::max(requests_count_, 10u), 70u);
return 32 * 1024 * (1 << ((limited_count - 1) / 10u));
}
} // namespace chrome_pdf