Stop ShouldServiceRequest from running callback

content/browser/loader/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 1300 matching lines @@
   ResourceContext* resource_context = NULL;
   net::URLRequestContext* request_context = NULL;
   filter_->GetContexts(request_data.resource_type, &resource_context,
                        &request_context);
 
   // Parse the headers before calling ShouldServiceRequest, so that they are
   // available to be validated.
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(request_data.headers);
 
-  BeginRequestStatus begin_request_status = CONTINUE;
-  OnHeaderProcessedCallback callback;
-  if (!is_shutdown_) {
-    callback =
-        base::Bind(&ResourceDispatcherHostImpl::ContinuePendingBeginRequest,
-                   base::Unretained(this), request_id, request_data,
-                   sync_result, route_id, headers);
-    begin_request_status =
-        ShouldServiceRequest(process_type, child_id, request_data, headers,
-                             filter_, resource_context, callback);
-  } else {
-    begin_request_status = ABORT;
-  }
-  if (begin_request_status == ABORT) {
+  if (is_shutdown_ ||
+      !ShouldServiceRequest(process_type, child_id, request_data, headers,
+                            filter_, resource_context)) {
     AbortRequestBeforeItStarts(filter_, sync_result, request_id);
     return;
-  } else if (begin_request_status == CONTINUE) {
-    callback.Run(true, 0);
   }
+  // Check if we have a registered interceptor for the headers passed in. If
+  // yes then we need to mark the current request as pending and wait for the
+  // interceptor to invoke the callback with a status code indicating whether
+  // the request needs to be aborted or continued.
+  for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
+    HeaderInterceptorMap::iterator index =
+        http_header_interceptor_map_.find(it.name());
+    if (index != http_header_interceptor_map_.end()) {
+      HeaderInterceptorInfo& interceptor_info = index->second;
+
+      bool call_interceptor = true;
+      if (!interceptor_info.starts_with.empty()) {
+        call_interceptor =
+            base::StartsWith(it.value(), interceptor_info.starts_with,
+                             base::CompareCase::INSENSITIVE_ASCII);
+      }
+      if (call_interceptor) {
+        interceptor_info.interceptor.Run(
+            it.name(), it.value(), child_id, resource_context,
+            base::Bind(&ResourceDispatcherHostImpl::ContinuePendingBeginRequest,
+                       base::Unretained(this), request_id, request_data,
+                       sync_result, route_id, headers));
+        return;
+      }
+    }
+  }
+  ContinuePendingBeginRequest(request_id, request_data, sync_result, route_id,
+                              headers, true, 0);
 }
 
 void ResourceDispatcherHostImpl::ContinuePendingBeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     IPC::Message* sync_result,  // only valid for sync
     int route_id,
     const net::HttpRequestHeaders& headers,
     bool continue_request,
     int error_code) {
@@ skipping 1251 matching lines @@
   DCHECK(deserialized);
   ssl.cert_id = GetCertStore()->StoreCert(ssl_info.cert.get(), child_id);
   response->head.security_info = SerializeSecurityInfo(ssl);
 }
 
 CertStore* ResourceDispatcherHostImpl::GetCertStore() {
   return cert_store_for_testing_ ? cert_store_for_testing_
                                  : CertStore::GetInstance();
 }
 
-ResourceDispatcherHostImpl::BeginRequestStatus
-ResourceDispatcherHostImpl::ShouldServiceRequest(
+bool ResourceDispatcherHostImpl::ShouldServiceRequest(
     int process_type,
     int child_id,
     const ResourceRequest& request_data,
     const net::HttpRequestHeaders& headers,
     ResourceMessageFilter* filter,
-    ResourceContext* resource_context,
-    OnHeaderProcessedCallback callback) {
+    ResourceContext* resource_context) {
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   // Check if the renderer is permitted to request the requested URL.
   if (!policy->CanRequestURL(child_id, request_data.url)) {
     VLOG(1) << "Denied unauthorized request for "
             << request_data.url.possibly_invalid_spec();
-    return ABORT;
+    return false;
   }
 
   // Check if the renderer is using an illegal Origin header.  If so, kill it.
   std::string origin_string;
   bool has_origin =
       headers.GetHeader("Origin", &origin_string) && origin_string != "null";
   if (has_origin) {
     GURL origin(origin_string);
     if (!policy->CanCommitURL(child_id, origin)) {
       VLOG(1) << "Killed renderer for illegal origin: " << origin_string;
       bad_message::ReceivedBadMessage(filter, bad_message::RDH_ILLEGAL_ORIGIN);
-      return ABORT;
+      return false;
     }
   }
 
   // Check if the renderer is permitted to upload the requested files.
   if (request_data.request_body.get()) {
     const std::vector<ResourceRequestBodyImpl::Element>* uploads =
         request_data.request_body->elements();
     std::vector<ResourceRequestBodyImpl::Element>::const_iterator iter;
     for (iter = uploads->begin(); iter != uploads->end(); ++iter) {
       if (iter->type() == ResourceRequestBodyImpl::Element::TYPE_FILE &&
           !policy->CanReadFile(child_id, iter->path())) {
         NOTREACHED() << "Denied unauthorized upload of "
                      << iter->path().value();
-        return ABORT;
+        return false;
       }
       if (iter->type() ==
           ResourceRequestBodyImpl::Element::TYPE_FILE_FILESYSTEM) {
         storage::FileSystemURL url =
             filter->file_system_context()->CrackURL(iter->filesystem_url());
         if (!policy->CanReadFileSystemFile(child_id, url)) {
           NOTREACHED() << "Denied unauthorized upload of "
                        << iter->filesystem_url().spec();
-          return ABORT;
+          return false;
         }
       }
     }
   }
-
-  // Check if we have a registered interceptor for the headers passed in. If
-  // yes then we need to mark the current request as pending and wait for the
-  // interceptor to invoke the |callback| with a status code indicating whether
-  // the request needs to be aborted or continued.
-  for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
-    HeaderInterceptorMap::iterator index =
-        http_header_interceptor_map_.find(it.name());
-    if (index != http_header_interceptor_map_.end()) {
-      HeaderInterceptorInfo& interceptor_info = index->second;
-
-      bool call_interceptor = true;
-      if (!interceptor_info.starts_with.empty()) {
-        call_interceptor =
-            base::StartsWith(it.value(), interceptor_info.starts_with,
-                             base::CompareCase::INSENSITIVE_ASCII);
-      }
-      if (call_interceptor) {
-        interceptor_info.interceptor.Run(it.name(), it.value(), child_id,
-                                         resource_context, callback);
-        return PENDING;
-      }
-    }
-  }
-  return CONTINUE;
+  return true;
 }
 
 }  // namespace content