Refactor PDF ChunkStream and 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 34 matching lines @@
     }
   }
   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::ToLowerASCII(it.values());
-      if (base::StartsWith(type, "multipart/", base::CompareCase::SENSITIVE)) {
-        const char* boundary = strstr(type.c_str(), "boundary=");
-        if (!boundary) {
-          NOTREACHED();
-          break;
-        }
+    if (!base::LowerCaseEqualsASCII(it.name(), "content-type"))
+      continue;
 
-        return std::string(boundary + 9);
-      }
+    std::string type = base::ToLowerASCII(it.values());
+    if (!base::StartsWith(type, "multipart/", base::CompareCase::SENSITIVE))
+      continue;
+
+    static constexpr char kBoundary[] = "boundary=";
+    const char* boundary = strstr(type.c_str(), kBoundary);
+    if (!boundary) {
+      NOTREACHED();
+      return std::string();
     }
+
+    return std::string(boundary + strlen(kBoundary));
   }
   return std::string();
 }
 
 // Return true if the HTTP response of |loader| is a successful one and loading
 // should continue. 4xx error indicate subsequent requests will fail too.
 // e.g. resource has been removed from the server while loading it. 301
 // indicates a redirect was returned which won't be successful because we
 // disable following redirects for PDF loading (we assume they are already
 // resolved by the browser.
 bool ResponseStatusSuccess(const pp::URLLoader& loader) {
   int32_t http_code = loader.GetResponseInfo().GetStatusCode();
   return (http_code < 400 && http_code != 301) || http_code >= 500;
 }
 
 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);
 }
 
+bool IsDoubleNewlines(const char* buffer, int index) {
+  DCHECK_GE(index, 2);
+  static constexpr char kLF2[] = "\n\n";
+  static constexpr char kCRLF2[] = "\r\n\r\n";
+  if (strncmp(&buffer[index - 2], kLF2, strlen(kLF2)) == 0)
+    return true;
+  return index >= 4 && strncmp(&buffer[index - 4], kCRLF2, strlen(kCRLF2)) == 0;
+}
+
 }  // namespace
 
 DocumentLoader::Client::~Client() {}
 
 DocumentLoader::DocumentLoader(Client* client)
     : client_(client),
       partial_document_(false),
       request_pending_(false),
       current_pos_(0),
       current_chunk_size_(0),
@@ skipping 111 matching lines @@
   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.
+  if (document_size_ == 0)  // Document size 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() {
-  pending_requests_.erase(pending_requests_.begin(), pending_requests_.end());
+  pending_requests_.clear();
 }
 
 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);
@@ skipping 147 matching lines @@
     // 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 byte-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;
+    uint32_t start_pos;
+    uint32_t 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;
     } else {
       partial_document_ = false;
     }
   }
 
   ReadMore();
@@ skipping 14 matching lines @@
     // case where an error occurred, the renderer will detect that we're missing
     // data and will display a message.
     ReadComplete();
     return;
   }
 
   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 (IsDoubleNewlines(buffer_, i)) {
+        uint32_t start_pos;
+        uint32_t 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 97 matching lines @@
 
 void DocumentLoader::UpdateRendering() {
   if (header_request_)
     client_->OnPartialDocumentLoaded();
   else
     client_->OnPendingRequestComplete();
   header_request_ = false;
 }
 
 }  // namespace chrome_pdf