Add test to ensure that URLs that redirect inside the PDF plugin fail to load

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_util.h"
 #include "pdf/url_loader_wrapper.h"
 #include "ppapi/c/pp_errors.h"
 #include "ui/gfx/range/range.h"
 
 namespace chrome_pdf {
 
 namespace {
 
 // The distance from last received chunk, when we wait requesting data, using
 // current connection (like playing a cassette tape) and do not send new range
 // request (like rewind a cassette tape, and continue playing after).
 // Experimentally chosen value.
 const int kChunkCloseDistance = 10;
 
+// 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 URLLoaderWrapper* loader) {
+  int32_t http_code = loader->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));
@@ skipping 18 matching lines @@
     : client_(client), loader_factory_(this) {}
 
 DocumentLoader::~DocumentLoader() {
 }
 
 bool DocumentLoader::Init(std::unique_ptr<URLLoaderWrapper> loader,
                           const std::string& url) {
   DCHECK(url_.empty());
   DCHECK(!loader_);
 
+  // Check that the initial response status is a valid one.
+  if (!ResponseStatusSuccess(loader.get()))
+    return false;
+
   std::string type = loader->GetContentType();
 
   // This happens for PDFs not loaded from http(s) sources.
   if (type == "text/plain") {
     if (!base::StartsWith(url, "http://",
                           base::CompareCase::INSENSITIVE_ASCII) &&
         !base::StartsWith(url, "https://",
                           base::CompareCase::INSENSITIVE_ASCII)) {
       type = "application/pdf";
     }
@@ skipping 159 matching lines @@
   loader_->OpenRange(
       url_, url_, start, length,
       loader_factory_.NewCallback(&DocumentLoader::DidOpenPartial));
 }
 
 void DocumentLoader::DidOpenPartial(int32_t result) {
   if (result != PP_OK) {
     return ReadComplete();
   }
 
-  int32_t http_code = loader_->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.
+  if (!ResponseStatusSuccess(loader_.get()))
     return ReadComplete();
-  }
 
   // Leave position untouched for multiparted responce for now, when we read the
   // data we'll get it.
   if (!loader_->IsMultipart()) {
     // 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
     int start_pos = 0;
@@ skipping 119 matching lines @@
 float DocumentLoader::GetProgress() const {
   if (!GetDocumentSize())
     return -1;
   if (IsDocumentComplete())
     return 1;
   return static_cast<float>(chunk_stream_.filled_chunks_count()) /
          chunk_stream_.total_chunks_count();
 }
 
 }  // namespace chrome_pdf