Cleanup the PDF DocumentLoader code.

pdf/document_loader.cc

 // 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 kMinFileSize = 64*1024;
+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 (LowerCaseEqualsASCII(it.name(), "content-range")) {
+      std::string range = it.values().c_str();
+      if (StartsWithASCII(range, "bytes", false)) {
+        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 (LowerCaseEqualsASCII(it.name(), "content-type")) {
+      std::string type = base::StringToLowerASCII(it.values());
+      if (StartsWithASCII(type, "multipart/", true)) {
+        const char* boundary = strstr(type.c_str(), "boundary=");
+        if (!boundary) {
+          NOTREACHED();
+          break;
+        }
+
+        return std::string(boundary + 9);
+      }
+    }
+  }
+  return std::string();
+}
+
+}  // 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() {
 }
@@ skipping 12 matching lines @@
     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 content_length = 0;
+  uint32_t content_length = 0;
   std::string type;
   std::string disposition;
   if (!response_headers.empty()) {
     net::HttpUtil::HeadersIterator it(response_headers.begin(),
                                       response_headers.end(), "\n");
     while (it.GetNext()) {
       if (LowerCaseEqualsASCII(it.name(), "content-length")) {
         content_length = atoi(it.values().c_str());
       } else if (LowerCaseEqualsASCII(it.name(), "accept-ranges")) {
         accept_ranges_bytes = LowerCaseEqualsASCII(it.values(), "bytes");
@@ skipping 58 matching lines @@
   chunk_buffer_.clear();
   ReadMore();
 }
 
 bool DocumentLoader::IsDocumentComplete() const {
   if (document_size_ == 0)  // Document size unknown.
     return false;
   return IsDataAvailable(0, document_size_);
 }
 
-uint32 DocumentLoader::GetAvailableData() const {
+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 available = document_size_;
-  std::vector<std::pair<size_t, size_t> >::iterator it;
-  for (it = ranges.begin(); it != ranges.end(); ++it) {
-    available -= it->second;
-  }
+  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 position, uint32 size, void* buf) const {
+bool DocumentLoader::GetBlock(uint32_t position,
+                              uint32_t size,
+                              void* buf) const {
   return chunk_stream_.ReadData(position, size, buf);
 }
 
-bool DocumentLoader::IsDataAvailable(uint32 position, uint32 size) const {
+bool DocumentLoader::IsDataAvailable(uint32_t position, uint32_t size) const {
   return chunk_stream_.IsRangeAvailable(position, size);
 }
 
-void DocumentLoader::RequestData(uint32 position, uint32 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())
@@ skipping 12 matching lines @@
   // 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 pos = pending_requests_.front().first;
-  uint32 size = pending_requests_.front().second;
+  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.size() > 0) {
+  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 cur_request_size = GetRequestSize();
+  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 new_pos = pos;
-    uint32 new_size = cur_request_size;
+    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 block_end = new_pos + new_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;
@@ skipping 21 matching lines @@
   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 position,
-                                              uint32 size) const {
+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
@@ skipping 25 matching lines @@
   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.size()) {
+  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 start_pos, end_pos;
+    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();
 }
 
-bool DocumentLoader::GetByteRange(const std::string& headers, uint32* start,
-                                  uint32* end) {
-  net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
-  while (it.GetNext()) {
-    if (LowerCaseEqualsASCII(it.name(), "content-range")) {
-      std::string range = it.values().c_str();
-      if (StartsWithASCII(range, "bytes", false)) {
-        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;
-}
-
-std::string DocumentLoader::GetMultiPartBoundary(const std::string& headers) {
-  net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
-  while (it.GetNext()) {
-    if (LowerCaseEqualsASCII(it.name(), "content-type")) {
-      std::string type = base::StringToLowerASCII(it.values());
-      if (StartsWithASCII(type, "multipart/", true)) {
-        const char* boundary = strstr(type.c_str(), "boundary=");
-        if (!boundary) {
-          NOTREACHED();
-          break;
-        }
-
-        return std::string(boundary + 9);
-      }
-    }
-  }
-  return std::string();
-}
-
 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 start_pos, end_pos;
+          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;
         }
       }
@@ skipping 34 matching lines @@
   }
 }
 
 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 pos = 0;
-      std::list<std::vector<unsigned char> >::iterator it;
-      for (it = chunk_buffer_.begin(); it != chunk_buffer_.end(); ++it) {
-        chunk_stream_.WriteData(pos, &((*it)[0]), it->size());
-        pos += it->size();
+      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();
@@ skipping 14 matching lines @@
   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 pos = chunk_stream_.GetFirstMissingByte();
+    uint32_t pos = chunk_stream_.GetFirstMissingByte();
     std::vector<std::pair<size_t, size_t> > ranges;
     chunk_stream_.GetMissedRanges(pos, GetRequestSize(), &ranges);
-    DCHECK(ranges.size() > 0);
+    DCHECK(!ranges.empty());
     RequestData(ranges[0].first, ranges[0].second);
   }
 }
 
-uint32 DocumentLoader::GetRequestSize() const {
+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 limited_count = std::min(std::max(requests_count_, 10u), 70u);
-  return 32*1024 * (1 << ((limited_count - 1) / 10u));
+  uint32_t limited_count = std::min(std::max(requests_count_, 10u), 70u);
+  return 32 * 1024 * (1 << ((limited_count - 1) / 10u));
 }
 
 }  // namespace chrome_pdf