Revert of Move ResourceHandler deferred actions ahead of external protocol handling.

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 <utility>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 139 matching lines @@
   if (login_delegate_.get())
     login_delegate_->OnRequestCancelled();
   ssl_client_auth_handler_.reset();
 
   // Run ResourceHandler destructor before we tear-down the rest of our state
   // as the ResourceHandler may want to inspect the URLRequest and other state.
   handler_.reset();
 }
 
 void ResourceLoader::StartRequest() {
+  if (delegate_->HandleExternalProtocol(this, request_->url())) {
+    CancelAndIgnore();
+    return;
+  }
+
   // Give the handler a chance to delay the URLRequest from being started.
   bool defer_start = false;
   if (!handler_->OnWillStart(request_->url(), &defer_start)) {
     Cancel();
     return;
   }
 
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::StartRequest", this,
                          TRACE_EVENT_FLAG_FLOW_OUT);
   if (defer_start) {
@@ skipping 91 matching lines @@
             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 (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());
   delegate_->DidReceiveRedirect(this, redirect_info.new_url, response.get());
   if (!handler_->OnRequestRedirected(redirect_info, response.get(), defer)) {
     Cancel();
   } else if (*defer) {
     deferred_stage_ = DEFERRED_REDIRECT;  // Follow redirect when resumed.
-    DCHECK(deferred_redirect_url_.is_empty());
-    deferred_redirect_url_ = redirect_info.new_url;
-  } else if (delegate_->HandleExternalProtocol(this, redirect_info.new_url)) {
-    // The request is complete so we can remove it.
-    CancelAndIgnore();
-    return;
   }
 }
 
 void ResourceLoader::OnAuthRequired(net::URLRequest* unused,
                                     net::AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request_.get(), unused);
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
   if (info->do_not_prompt_for_login()) {
     request_->CancelAuth();
@@ skipping 144 matching lines @@
   DeferredStage stage = deferred_stage_;
   deferred_stage_ = DEFERRED_NONE;
   switch (stage) {
     case DEFERRED_NONE:
       NOTREACHED();
       break;
     case DEFERRED_START:
       StartRequestInternal();
       break;
     case DEFERRED_REDIRECT:
-      FollowDeferredRedirectInternal();
+      request_->FollowDeferredRedirect();
       break;
     case DEFERRED_READ:
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ResourceLoader::ResumeReading,
                                 weak_ptr_factory_.GetWeakPtr()));
       break;
     case DEFERRED_RESPONSE_COMPLETE:
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted,
                                 weak_ptr_factory_.GetWeakPtr()));
       break;
     case DEFERRED_FINISH:
       // Delay self-destruction since we don't know how we were reached.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ResourceLoader::CallDidFinishLoading,
                                 weak_ptr_factory_.GetWeakPtr()));
       break;
   }
 }
 
 void ResourceLoader::Cancel() {
   CancelRequest(false);
 }
 
 void ResourceLoader::StartRequestInternal() {
   DCHECK(!request_->is_pending());
 
-  // Note: at this point any possible deferred start actions are already over.
-
   if (!request_->status().is_success()) {
     return;
   }
 
-  if (delegate_->HandleExternalProtocol(this, request_->url())) {
-    CancelAndIgnore();
-    return;
-  }
-
   started_request_ = true;
   request_->Start();
 
   delegate_->DidStartRequest(this);
 }
 
 void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
   DVLOG(1) << "CancelRequestInternal: " << request_->url().spec();
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
@@ skipping 32 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::FollowDeferredRedirectInternal() {
-  DCHECK(!deferred_redirect_url_.is_empty());
-  GURL redirect_url = deferred_redirect_url_;
-  deferred_redirect_url_ = GURL();
-  if (delegate_->HandleExternalProtocol(this, deferred_redirect_url_)) {
-    CancelAndIgnore();
-  } else {
-    request_->FollowDeferredRedirect();
-  }
-}
-
 void ResourceLoader::CompleteResponseStarted() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   PopulateResourceResponse(info, request_.get(), response.get());
 
   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()"));
@@ skipping 180 matching lines @@
       UMA_HISTOGRAM_ENUMERATION("Net.Prefetch.Pattern", prefetch_status,
                                 STATUS_MAX);
     }
   } else if (request_->response_info().unused_since_prefetch) {
     TimeDelta total_time = base::TimeTicks::Now() - request_->creation_time();
     UMA_HISTOGRAM_TIMES("Net.Prefetch.TimeSpentOnPrefetchHit", total_time);
   }
 }
 
 }  // namespace content