PDF: Check the loaded URL in sendScriptingMessage_().

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 317 matching lines @@
   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);

[raymes, 2016/10/11 04:26:22]

thestig: Can we just set this to false? I think this should solve all our
cross-origin problems. The MimeHandler should handle all of the redirection
before the URL gets to the plugin. 

[Lei Zhang, 2016/10/11 04:45:59]

Well, I imagine before we had MimeHandler, we needed this for the PDF Viewer to
follow redirects. Now that there's another layer on top... maybe not? Do there
exist web servers that would behave as Rob's?

[raymes, 2016/10/11 05:24:28]

You mean where the first request doesn't redirect but subsequent range requests
do? I'm not sure but it seems kinda strange. It sort of implies the resource
underneath is changing after the first request.

[Lei Zhang, 2016/10/11 19:07:31]

Yes, I agree it is probably a bit crazy, but I'd like some input from networking
folks regarding this to help reassure me that this is crazy and we should just
flip the bit to false.

BTW, this along with ppapi/tests/test_url_loader.cc are the only callers of
SetFollowRedirects(). Though ppapi::URLRequestInfoData has its follow_redirects
member initiailized to 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();
+  pp::URLResponseInfo response = loader_.GetResponseInfo();
+  int32_t http_code = response.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;
   }
 
+  pp::Var response_url = response.GetURL();
+  std::string response_url_str;
+  if (response_url.is_string())
+    response_url_str = response_url.AsString();
+  if (response_url_str.empty())
+    return;
+
+  if (actual_url_.empty()) {
+    actual_url_ = response_url_str;

[robwu, 2016/10/09 10:49:50]

Testing for URL equality may be too strict. Checking origins ought to be
sufficient, so how about renaming |actual_url_| to |actual_origin_| and using
the following instead:

  actual_origin_ = url::Origin(GURL(response_url_str)).Serialize();

[Lei Zhang, 2016/10/11 00:11:09]

Ack. We can certainly do that if desired.

+    client_->OnGotActualURL(actual_url_);
+  } else {
+    if (actual_url_ != response_url_str)

[Lei Zhang, 2016/10/11 00:09:02]

I was wondering about this as well. Would a web server ever redirect to
different URLs / origins for different chunks of a file? For load balancing
perhaps?

[Tom Sepez, 2016/10/11 16:10:47]

Seems unlikely, but we'll find out.  Want to add a UMA stat?

[nasko, 2016/10/12 00:47:47]

Why not DumpWithoutCrashing? If it is never hit, it has no overhead. But if it
hits, I imagine you would want to know what happened.

+      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);
@@ skipping 157 matching lines @@
 
 void DocumentLoader::UpdateRendering() {
   if (header_request_)
     client_->OnPartialDocumentLoaded();
   else
     client_->OnPendingRequestComplete();
   header_request_ = false;
 }
 
 }  // namespace chrome_pdf