[2/3 chromium] Support redirect option of Request and "opaqueredirect" response type.

content/browser/loader/resource_loader.cc

 // Copyright (c) 2012 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 "content/browser/loader/resource_loader.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 262 matching lines @@
       !ChildProcessSecurityPolicyImpl::GetInstance()->
           CanRequestURL(info->GetChildID(), redirect_info.new_url)) {
     DVLOG(1) << "Denied unauthorized request for "
              << redirect_info.new_url.possibly_invalid_spec();
 
     // Tell the renderer that this request was disallowed.
     Cancel();
     return;
   }
 
+  if (info->fetch_redirect_mode() == FETCH_REDIRECT_MODE_ERROR) {
+    Cancel();
+    return;
+  } else if (info->fetch_redirect_mode() == FETCH_REDIRECT_MODE_MANUAL) {
+    // TODO(horo): If we support upload progress events for Fetch API, we will
+    // have to call ReportUploadProgress().
+    DCHECK(!GetRequestInfo()->is_upload_progress_enabled());
+
+    CompleteResponseStarted(true);
+    if (is_deferred())
+      return;
+
+    // There is no need to read the response body here because there is no way
+    // to read the body of opaque-redirect filtered response's internal
+    // response.
+    // TODO(horo): If we support any API which expose the internal body, we will
+    // have to read the body before calling ResponseCompleted(). And also Cache
+    // changes will be needed because it doesn't store the body of redirect
+    // responses.
+    ResponseCompleted();
+    return;
+  }
+
   delegate_->DidReceiveRedirect(this, redirect_info.new_url);
 
   if (delegate_->HandleExternalProtocol(this, redirect_info.new_url)) {
     // The request is complete so we can remove it.
     CancelAndIgnore();
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
   PopulateResourceResponse(info, request_.get(), response.get());
@@ skipping 89 matching lines @@
 
   // We want to send a final upload progress message prior to sending the
   // response complete message even if we're waiting for an ack to to a
   // previous upload progress message.
   ResourceRequestInfoImpl* info = GetRequestInfo();
   if (info->is_upload_progress_enabled()) {
     waiting_for_upload_progress_ack_ = false;
     ReportUploadProgress();
   }
 
-  CompleteResponseStarted();
+  CompleteResponseStarted(false);
 
   if (is_deferred())
     return;
 
   if (request_->status().is_success())
     StartReading(false);  // Read the first chunk.
   else
     ResponseCompleted();
 }
 
@@ skipping 172 matching lines @@
   if (!was_pending) {
     // If the request isn't in flight, then we won't get an asynchronous
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted,
                               weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
-void ResourceLoader::CompleteResponseStarted() {
+void ResourceLoader::CompleteResponseStarted(bool is_redirect_response) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
   PopulateResourceResponse(info, request_.get(), response.get());
 
   if (request_->ssl_info().cert.get()) {
     SSLStatus ssl_status;
     GetSSLStatusForRequest(request_->url(), request_->ssl_info(),
                            info->GetChildID(), &ssl_status);
 
     response->head.security_info = SerializeSecurityInfo(ssl_status);
   } else {
     // We should not have any SSL state.
     DCHECK(!request_->ssl_info().cert_status &&
            request_->ssl_info().security_bits == -1 &&
            !request_->ssl_info().connection_status);
   }
 
   delegate_->DidReceiveResponse(this);
 
   // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnResponseStarted()"));
 
   bool defer = false;
   if (!handler_->OnResponseStarted(response.get(), &defer)) {
     Cancel();
   } else if (defer) {
     read_deferral_start_time_ = base::TimeTicks::Now();
-    deferred_stage_ = DEFERRED_READ;  // Read first chunk when resumed.
+    // Complete when resumed for redirect responses, otherwise read first chunk.
+    deferred_stage_ =
+        is_redirect_response ? DEFERRED_RESPONSE_COMPLETE : DEFERRED_READ;

[mmenke, 2015/08/11 18:48:56]

In this new path, we skip both OnWillRead and OnReadComplete(0), which
ResourceHandlers normally see for all successes.  I'm very concerned that this
new path will subtly break some ResourceHandler in a hard to debug manner.  And
I'm even more concerned that I'll end up being the one stuck with investigating
it, 2 months down the line when it suddenly turns up on stable as a mysterious
network crash.  Or 2 years down the line, when someone starts using
redirect_mode for something else entirely, using a different ResourceHandler
stack.

I think we could safely remove the 0-byte OnReadComplete(0) after the final read
everywhere, but then there's still the OnWillRead call we're skipping.

   }
 }
 
 void ResourceLoader::StartReading(bool is_continuation) {
   int bytes_read = 0;
   ReadMore(&bytes_read);
 
   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
   if (request_->status().is_io_pending())
     return;
@@ skipping 139 matching lines @@
       case net::URLRequestStatus::FAILED:
         status = STATUS_UNDEFINED;
         break;
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.Prefetch.Pattern", status, STATUS_MAX);
   }
 }
 
 }  // namespace content