Remove ProtocolFactory/Interceptor uses in GViewRequestInterceptor

net/url_request/url_request_job_manager.cc

 // Copyright (c) 2011 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 31 matching lines @@
   { "data", URLRequestDataJob::Factory },
 };
 
 // static
 URLRequestJobManager* URLRequestJobManager::GetInstance() {
   return Singleton<URLRequestJobManager>::get();
 }
 
 URLRequestJob* URLRequestJobManager::CreateJob(
     URLRequest* request) const {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
 
   // If we are given an invalid URL, then don't even try to inspect the scheme.
   if (!request->url().is_valid())
     return new URLRequestErrorJob(request, ERR_INVALID_URL);
 
   // We do this here to avoid asking interceptors about unsupported schemes.
   const URLRequestJobFactory* job_factory = NULL;
   if (request->context())
     job_factory = request->context()->job_factory();
 
@@ skipping 60 matching lines @@
   // If we reached here, then it means that a registered protocol factory
   // wasn't interested in handling the URL.  That is fairly unexpected, and we
   // don't know have a specific error to report here :-(
   LOG(WARNING) << "Failed to map: " << request->url().spec();
   return new URLRequestErrorJob(request, ERR_FAILED);
 }
 
 URLRequestJob* URLRequestJobManager::MaybeInterceptRedirect(
     URLRequest* request,
     const GURL& location) const {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
-  if ((request->load_flags() & LOAD_DISABLE_INTERCEPT) ||
-      (request->status().status() == URLRequestStatus::CANCELED) ||
-      !request->url().is_valid() ||
-      !SupportsScheme(request->url().scheme()))
+  if (!request->url().is_valid() ||
+      request->load_flags() & LOAD_DISABLE_INTERCEPT ||
+      request->status().status() == URLRequestStatus::CANCELED) {
     return NULL;
+  }
+
+  const URLRequestJobFactory* job_factory = NULL;
+  if (request->context())
+    job_factory = request->context()->job_factory();
+
+  const std::string& scheme = request->url().scheme();  // already lowercase
+  if (job_factory) {
+    if (!job_factory->IsHandledProtocol(scheme)) {
+      return NULL;
+    }
+  } else if (!SupportsScheme(scheme)) {
+    return NULL;
+  }
+
+  URLRequestJob* job = NULL;
+  if (job_factory)
+    job = job_factory->MaybeInterceptRedirect(location, request);
+  if (job)
+    return job;
 
   InterceptorList::const_iterator i;
   for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
-    URLRequestJob* job = (*i)->MaybeInterceptRedirect(request, location);
+    job = (*i)->MaybeInterceptRedirect(request, location);
     if (job)
       return job;
   }
   return NULL;
 }
 
 URLRequestJob* URLRequestJobManager::MaybeInterceptResponse(
     URLRequest* request) const {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
-  if ((request->load_flags() & LOAD_DISABLE_INTERCEPT) ||
-      (request->status().status() == URLRequestStatus::CANCELED) ||
-      !request->url().is_valid() ||
-      !SupportsScheme(request->url().scheme()))
+  if (!request->url().is_valid() ||
+      request->load_flags() & LOAD_DISABLE_INTERCEPT ||
+      request->status().status() == URLRequestStatus::CANCELED) {
     return NULL;
+  }
+
+  const URLRequestJobFactory* job_factory = NULL;
+  if (request->context())
+    job_factory = request->context()->job_factory();
+
+  const std::string& scheme = request->url().scheme();  // already lowercase
+  if (job_factory) {
+    if (!job_factory->IsHandledProtocol(scheme)) {
+      return NULL;
+    }
+  } else if (!SupportsScheme(scheme)) {
+    return NULL;
+  }
+
+  URLRequestJob* job = NULL;
+  if (job_factory)
+    job = job_factory->MaybeInterceptResponse(request);
+  if (job)
+    return job;
 
   InterceptorList::const_iterator i;
   for (i = interceptors_.begin(); i != interceptors_.end(); ++i) {
-    URLRequestJob* job = (*i)->MaybeInterceptResponse(request);
+    job = (*i)->MaybeInterceptResponse(request);
     if (job)
       return job;
   }
   return NULL;
 }
 
 bool URLRequestJobManager::SupportsScheme(const std::string& scheme) const {
   // The set of registered factories may change on another thread.
   {
     base::AutoLock locked(lock_);
     if (factories_.find(scheme) != factories_.end())
       return true;
   }
 
   for (size_t i = 0; i < arraysize(kBuiltinFactories); ++i)
     if (LowerCaseEqualsASCII(scheme, kBuiltinFactories[i].scheme))
       return true;
 
   return false;
 }
 
 URLRequest::ProtocolFactory* URLRequestJobManager::RegisterProtocolFactory(
     const std::string& scheme,
     URLRequest::ProtocolFactory* factory) {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
 
   base::AutoLock locked(lock_);
 
   URLRequest::ProtocolFactory* old_factory;
   FactoryMap::iterator i = factories_.find(scheme);
   if (i != factories_.end()) {
     old_factory = i->second;
   } else {
     old_factory = NULL;
   }
   if (factory) {
     factories_[scheme] = factory;
   } else if (i != factories_.end()) {  // uninstall any old one
     factories_.erase(i);
   }
   return old_factory;
 }
 
 void URLRequestJobManager::RegisterRequestInterceptor(
     URLRequest::Interceptor* interceptor) {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
 
   base::AutoLock locked(lock_);
 
   DCHECK(std::find(interceptors_.begin(), interceptors_.end(), interceptor) ==
          interceptors_.end());
   interceptors_.push_back(interceptor);
 }
 
 void URLRequestJobManager::UnregisterRequestInterceptor(
     URLRequest::Interceptor* interceptor) {
-#ifndef NDEBUG
   DCHECK(IsAllowedThread());
-#endif
 
   base::AutoLock locked(lock_);
 
   InterceptorList::iterator i =
       std::find(interceptors_.begin(), interceptors_.end(), interceptor);
   DCHECK(i != interceptors_.end());
   interceptors_.erase(i);
 }
 
 URLRequestJobManager::URLRequestJobManager() : enable_file_access_(false) {
 #ifndef NDEBUG
   allowed_thread_ = 0;
   allowed_thread_initialized_ = false;
 #endif
 }
 
 URLRequestJobManager::~URLRequestJobManager() {}
 
 }  // namespace net