PDF: Cleanup more code now that it is completely out of process.

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;
 
+bool IsValidContentType(const std::string& type) {
+  return (EndsWith(type, "/pdf", false) ||
+          EndsWith(type, ".pdf", false) ||
+          EndsWith(type, "/x-pdf", false) ||
+          EndsWith(type, "/*", false) ||
+          EndsWith(type, "/acrobat", false) ||
+          EndsWith(type, "/unknown", false));
+}
+
+}  // namespace
+
 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 14 matching lines @@
     if (headers_var.is_string()) {
       response_headers = headers_var.AsString();
     }
   }
 
   bool accept_ranges_bytes = false;
   bool content_encoded = false;
   uint32 content_length = 0;
   std::string type;
   std::string disposition;
-  if (!response_headers.empty()) {
+
+  // This happens for PDFs not loaded from http(s) sources.
+  if (response_headers == "Content-Type: text/plain") {
+    if (!StartsWithASCII(url, "http://", false) &&
+        !StartsWithASCII(url, "https://", false)) {
+      type = "application/pdf";
+    }
+  }
+  if (type.empty() && !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");
       } else if (LowerCaseEqualsASCII(it.name(), "content-encoding")) {
         content_encoded = true;
       } else if (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 (LowerCaseEqualsASCII(it.name(), "content-disposition")) {
         disposition = it.values();
       }
     }
   }
-  if (!type.empty() &&
-      !EndsWith(type, "/pdf", false) &&
-      !EndsWith(type, ".pdf", false) &&
-      !EndsWith(type, "/x-pdf", false) &&
-      !EndsWith(type, "/*", false) &&
-      !EndsWith(type, "/acrobat", false) &&
-      !EndsWith(type, "/unknown", false)) {
+  if (!type.empty() && !IsValidContentType(type))
     return false;
-  }
-  if (StartsWithASCII(disposition, "attachment", false)) {
+  if (StartsWithASCII(disposition, "attachment", false))
     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 &&
@@ skipping 407 matching lines @@
 uint32 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));
 }
 
 }  // namespace chrome_pdf