Rename ProtocolInterceptJobFactory and make it not use ProtocolHandlers.

android_webview/native/android_protocol_handler.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 "android_webview/native/android_protocol_handler.h"
 
 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/common/url_constants.h"
 #include "android_webview/native/input_stream_impl.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/url_constants.h"
 #include "jni/AndroidProtocolHandler_jni.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_util.h"
-#include "net/url_request/protocol_intercept_job_factory.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_interceptor.h"
 #include "url/gurl.h"
 
 using android_webview::InputStream;
 using android_webview::InputStreamImpl;
 using base::android::AttachCurrentThread;
 using base::android::ClearException;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
@@ skipping 39 matching lines @@
                            std::string* mime_type) OVERRIDE;
 
   virtual bool GetCharset(JNIEnv* env,
                           net::URLRequest* request,
                           InputStream* stream,
                           std::string* charset) OVERRIDE;
 
   virtual ~AndroidStreamReaderURLRequestJobDelegateImpl();
 };
 
-class AndroidProtocolHandlerBase :
-    public net::URLRequestJobFactory::ProtocolHandler {
+class AndroidRequestInterceptorBase : public net::URLRequestInterceptor {
  public:
-  virtual net::URLRequestJob* MaybeCreateJob(
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE;
 
-  virtual bool CanHandleRequest(const net::URLRequest* request) const = 0;
+  virtual bool ShouldHandleRequest(const net::URLRequest* request) const = 0;
 };
 
-class AssetFileProtocolHandler : public AndroidProtocolHandlerBase {
+class AssetFileRequestInterceptor : public AndroidRequestInterceptorBase {
  public:
-  AssetFileProtocolHandler();
+  AssetFileRequestInterceptor();
 
-  virtual ~AssetFileProtocolHandler() OVERRIDE;
-  virtual bool CanHandleRequest(const net::URLRequest* request) const OVERRIDE;
+  virtual ~AssetFileRequestInterceptor() OVERRIDE;
+  virtual bool ShouldHandleRequest(
+      const net::URLRequest* request) const OVERRIDE;
 
  private:
   // file:///android_asset/
   const std::string asset_prefix_;
   // file:///android_res/
   const std::string resource_prefix_;
 };
 
 // Protocol handler for content:// scheme requests.
-class ContentSchemeProtocolHandler : public AndroidProtocolHandlerBase {
+class ContentSchemeRequestInterceptor : public AndroidRequestInterceptorBase {
  public:
-  ContentSchemeProtocolHandler();
-  virtual bool CanHandleRequest(const net::URLRequest* request) const OVERRIDE;
+  ContentSchemeRequestInterceptor();
+  virtual bool ShouldHandleRequest(
+      const net::URLRequest* request) const OVERRIDE;
 };
 
 static ScopedJavaLocalRef<jobject> GetResourceContext(JNIEnv* env) {
   if (g_resource_context)
     return g_resource_context->get(env);
   ScopedJavaLocalRef<jobject> context;
   // We have to reset as GetApplicationContext() returns a jobject with a
   // global ref. The constructor that takes a jobject would expect a local ref
   // and would assert.
   context.Reset(env, base::android::GetApplicationContext());
@@ skipping 68 matching lines @@
 
 bool AndroidStreamReaderURLRequestJobDelegateImpl::GetCharset(
     JNIEnv* env,
     net::URLRequest* request,
     android_webview::InputStream* stream,
     std::string* charset) {
   // TODO: We should probably be getting this from the managed side.
   return false;
 }
 
-// AndroidProtocolHandlerBase -------------------------------------------------
+// AndroidRequestInterceptorBase ----------------------------------------------
 
-net::URLRequestJob* AndroidProtocolHandlerBase::MaybeCreateJob(
+net::URLRequestJob* AndroidRequestInterceptorBase::MaybeInterceptRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
-  if (!CanHandleRequest(request)) return NULL;
+  if (!ShouldHandleRequest(request))
+    return NULL;
 
   // For WebViewClassic compatibility this job can only accept URLs that can be
   // opened. URLs that cannot be opened should be resolved by the next handler.
   //
   // If a request is initially handled here but the job fails due to it being
   // unable to open the InputStream for that request the request is marked as
   // previously failed and restarted.
   // Restarting a request involves creating a new job for that request. This
   // handler will ignore requests know to have previously failed to 1) prevent
   // an infinite loop, 2) ensure that the next handler in line gets the
   // opportunity to create a job for the request.
-  if (HasRequestPreviouslyFailed(request)) return NULL;
+  if (HasRequestPreviouslyFailed(request))
+    return NULL;
 
   scoped_ptr<AndroidStreamReaderURLRequestJobDelegateImpl> reader_delegate(
       new AndroidStreamReaderURLRequestJobDelegateImpl());
 
   return new AndroidStreamReaderURLRequestJob(
       request,
       network_delegate,
       reader_delegate.PassAs<AndroidStreamReaderURLRequestJob::Delegate>());
 }
 
-// AssetFileProtocolHandler ---------------------------------------------------
+// AssetFileRequestInterceptor ------------------------------------------------
 
-AssetFileProtocolHandler::AssetFileProtocolHandler()
+AssetFileRequestInterceptor::AssetFileRequestInterceptor()
     : asset_prefix_(std::string(content::kFileScheme) +
                     std::string(content::kStandardSchemeSeparator) +
                     android_webview::kAndroidAssetPath),
       resource_prefix_(std::string(content::kFileScheme) +
                        std::string(content::kStandardSchemeSeparator) +
                        android_webview::kAndroidResourcePath) {
 }
 
-AssetFileProtocolHandler::~AssetFileProtocolHandler() {
+AssetFileRequestInterceptor::~AssetFileRequestInterceptor() {
 }
 
-bool AssetFileProtocolHandler::CanHandleRequest(
+bool AssetFileRequestInterceptor::ShouldHandleRequest(
     const net::URLRequest* request) const {
   if (!request->url().SchemeIsFile())
     return false;
 
   const std::string& url = request->url().spec();
   if (!StartsWithASCII(url, asset_prefix_, /*case_sensitive=*/ true) &&
       !StartsWithASCII(url, resource_prefix_, /*case_sensitive=*/ true)) {
     return false;
   }
 
   return true;
 }
 
-// ContentSchemeProtocolHandler -----------------------------------------------
+// ContentSchemeRequestInterceptor --------------------------------------------
 
-ContentSchemeProtocolHandler::ContentSchemeProtocolHandler() {
+ContentSchemeRequestInterceptor::ContentSchemeRequestInterceptor() {
 }
 
-bool ContentSchemeProtocolHandler::CanHandleRequest(
+bool ContentSchemeRequestInterceptor::ShouldHandleRequest(
     const net::URLRequest* request) const {
   return request->url().SchemeIs(android_webview::kContentScheme);
 }
 
 }  // namespace
 
 namespace android_webview {
 
 bool RegisterAndroidProtocolHandler(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
-scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
-CreateContentSchemeProtocolHandler() {
-  return make_scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
-      new ContentSchemeProtocolHandler());
+scoped_ptr<net::URLRequestInterceptor>
+CreateContentSchemeRequestInterceptor() {
+  return make_scoped_ptr<net::URLRequestInterceptor>(
+      new ContentSchemeRequestInterceptor());
 }
 
 // static
-scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
-CreateAssetFileProtocolHandler() {
-  return make_scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
-      new AssetFileProtocolHandler());
+scoped_ptr<net::URLRequestInterceptor> CreateAssetFileRequestInterceptor() {
+  return scoped_ptr<net::URLRequestInterceptor>(
+      new AssetFileRequestInterceptor());
 }
 
 // Set a context object to be used for resolving resource queries. This can
 // be used to override the default application context and redirect all
 // resource queries to a specific context object, e.g., for the purposes of
 // testing.
 //
 // |context| should be a android.content.Context instance or NULL to enable
 // the use of the standard application context.
 static void SetResourceContextForTesting(JNIEnv* env, jclass /*clazz*/,
@@ skipping 11 matching lines @@
       env, android_webview::kAndroidAssetPath).Release();
 }
 
 static jstring GetAndroidResourcePath(JNIEnv* env, jclass /*clazz*/) {
   // OK to release, JNI binding.
   return ConvertUTF8ToJavaString(
       env, android_webview::kAndroidResourcePath).Release();
 }
 
 }  // namespace android_webview