Media: fail properly on 404 after redirect

media/blink/resource_multibuffer_data_provider.cc

 // Copyright 2015 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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 154 matching lines @@
     return;
   active_loader_->SetDeferred(deferred);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // WebAssociatedURLLoaderClient implementation.
 
 bool ResourceMultiBufferDataProvider::willFollowRedirect(
     const WebURLRequest& newRequest,
     const WebURLResponse& redirectResponse) {
+  DVLOG(1) << "willFollowRedirect";
   redirects_to_ = newRequest.url();
   url_data_->set_valid_until(base::Time::Now() +
                              GetCacheValidUntil(redirectResponse));
 
   // This test is vital for security!
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED) {
     // We allow the redirect if the origin is the same.
     if (origin_ != redirects_to_.GetOrigin()) {
       // We also allow the redirect if we don't have any data in the
       // cache, as that means that no dangerous data mixing can occur.
       if (url_data_->multibuffer()->map().empty() && fifo_.empty())
         return true;
 
       active_loader_ = nullptr;
       url_data_->Fail();
       return false;  // "this" may be deleted now.
     }
   }
   return true;
 }
 
 void ResourceMultiBufferDataProvider::didSendData(
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   NOTIMPLEMENTED();
 }
 
 void ResourceMultiBufferDataProvider::didReceiveResponse(
     const WebURLResponse& response) {
-#if ENABLE_DLOG
-  string version;
+#if DCHECK_IS_ON()
+  std::string version;
   switch (response.httpVersion()) {
     case WebURLResponse::HTTPVersion_0_9:
       version = "0.9";
       break;
     case WebURLResponse::HTTPVersion_1_0:
       version = "1.0";
       break;
     case WebURLResponse::HTTPVersion_1_1:
       version = "1.1";
       break;
     case WebURLResponse::HTTPVersion_2_0:
       version = "2.1";
       break;
+    case WebURLResponse::HTTPVersionUnknown:
+      version = "unknown";
+      break;
   }
   DVLOG(1) << "didReceiveResponse: HTTP/" << version << " "
            << response.httpStatusCode();
 #endif
   DCHECK(active_loader_);
 
   scoped_refptr<UrlData> destination_url_data(url_data_);
 
   UrlIndex* url_index = url_data_->url_index();
 
@@ skipping 34 matching lines @@
     }
 
     reasons >>= 1;
     ++shift;
   }
 
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
   int64_t content_length = response.expectedContentLength();
   bool end_of_file = false;
+  bool do_fail = false;
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
   if (destination_url_data->url().SchemeIsHTTPOrHTTPS()) {
     bool partial_response = (response.httpStatusCode() == kHttpPartialContent);
     bool ok_response = (response.httpStatusCode() == kHttpOK);
 
     // Check to see whether the server supports byte ranges.
@@ skipping 15 matching lines @@
       destination_url_data->set_length(content_length);
     } else if (response.httpStatusCode() == kHttpRangeNotSatisfiable) {
       // Unsatisfiable range
       // Really, we should never request a range that doesn't exist, but
       // if we do, let's handle it in a sane way.
       // Note, we can't just call OnDataProviderEvent() here, because
       // url_data_ hasn't been updated to the final destination yet.
       end_of_file = true;
     } else {
       active_loader_ = nullptr;
-      destination_url_data->Fail();
-      return;  // "this" may be deleted now.
+      // Can't call fail until readers have been migrated to the new
+      // url data below.
+      do_fail = true;
     }
   } else {
     destination_url_data->set_range_supported();
     if (content_length != kPositionNotSpecified) {
       destination_url_data->set_length(content_length + byte_pos());
     }
   }
 
-  if (url_index) {
+  if (url_index && !do_fail) {
     destination_url_data = url_index->TryInsert(destination_url_data);
   }
 
   if (destination_url_data != url_data_) {
     // At this point, we've encountered a redirect, or found a better url data
     // instance for the data that we're about to download.
 
     // First, let's take a ref on the current url data.
     scoped_refptr<UrlData> old_url_data(url_data_);
     destination_url_data->Use();
 
     // Take ownership of ourselves. (From the multibuffer)
     std::unique_ptr<DataProvider> self(
         url_data_->multibuffer()->RemoveProvider(this));
     url_data_ = destination_url_data.get();
     // Give the ownership to our new owner.
     url_data_->multibuffer()->AddProvider(std::move(self));
 
     // Call callback to let upstream users know about the transfer.
     // This will merge the data from the two multibuffers and
     // cause clients to start using the new UrlData.
     old_url_data->RedirectTo(destination_url_data);
   }
 
+  if (do_fail) {
+    destination_url_data->Fail();
+    return;  // "this" may be deleted now.
+  }
+
   // This test is vital for security!
   const GURL& original_url = response.wasFetchedViaServiceWorker()
                                  ? response.originalURLViaServiceWorker()
                                  : response.url();
   if (!url_data_->ValidateDataOrigin(original_url.GetOrigin())) {
     active_loader_ = nullptr;
     url_data_->Fail();
     return;  // "this" may be deleted now.
   }
 
@@ skipping 182 matching lines @@
   }
 
   if (byte_pos() != first_byte_position) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace media