Add MaybeInterceptRedirect/Response to URLRequestInterceptor

net/url_request/url_request_job_manager.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 "net/url_request/url_request_job_manager.h"
 
 #include <algorithm>
 
 #include "base/memory/singleton.h"
 #include "build/build_config.h"
@@ skipping 110 matching lines @@
     return NULL;
 
   InterceptorList::const_iterator i;
   for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
     URLRequestJob* job = (*i)->MaybeInterceptRedirect(request,
                                                       network_delegate,
                                                       location);
     if (job)
       return job;
   }
-  return NULL;
+  return request->context()->job_factory()->MaybeInterceptRedirect(
+      request, network_delegate, location);

[mmenke, 2014/10/30 19:59:24]

Ideally, these should ignore the LOAD_DISABLE_INTERCEPT flag.  AppCache should
just track the URLRequests itself, probably by attaching UserData to them (And
it actually already does this, I believe).

Suppose that should probably be in its own CL, though, after AppCache has been
moved to the new API, so not really something you should worry about (Just don't
use the load flag in your new code).

[mmenke, 2014/10/30 19:59:24]

These should go before the old interceptors, for consistency.

[bengr, 2014/10/31 00:45:31]

Acknowledged.

[bengr, 2014/10/31 00:45:31]

Done.

[michaeln1, 2014/10/31 00:47:10]

Consistency with what?

The old URLRequest::Interceptor's MaybeIntercept method gets called prior to the
corresponding method of the new URLReqeustInterceptor.

 }
 
 URLRequestJob* URLRequestJobManager::MaybeInterceptResponse(
     URLRequest* request, NetworkDelegate* network_delegate) const {
   DCHECK(IsAllowedThread());
   if (!request->url().is_valid() ||
       request->load_flags() & LOAD_DISABLE_INTERCEPT ||
       request->status().status() == URLRequestStatus::CANCELED) {
     return NULL;
   }
 
   const URLRequestJobFactory* job_factory = NULL;
   job_factory = request->context()->job_factory();
 
   const std::string& scheme = request->url().scheme();  // already lowercase
   if (!job_factory->IsHandledProtocol(scheme))
     return NULL;
 
   InterceptorList::const_iterator i;
   for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
     URLRequestJob* job = (*i)->MaybeInterceptResponse(request,
                                                       network_delegate);
     if (job)
       return job;
   }
-  return NULL;
+  return request->context()->job_factory()->MaybeInterceptResponse(
+      request, network_delegate);
 }
 
 // static
 bool URLRequestJobManager::SupportsScheme(const std::string& scheme) {
   for (size_t i = 0; i < arraysize(kBuiltinFactories); ++i) {
     if (LowerCaseEqualsASCII(scheme, kBuiltinFactories[i].scheme))
       return true;
   }
 
   return false;
@@ skipping 23 matching lines @@
 }
 
 URLRequestJobManager::URLRequestJobManager()
     : allowed_thread_(0),
       allowed_thread_initialized_(false) {
 }
 
 URLRequestJobManager::~URLRequestJobManager() {}
 
 }  // namespace net