[android_webview] Don't intercept resource and asset URLRequests.

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"
@@ skipping 31 matching lines @@
     delete g_resource_context;
 
   g_resource_context = ref;
 }
 
 class AndroidStreamReaderURLRequestJobDelegateImpl
     : public AndroidStreamReaderURLRequestJob::Delegate {
  public:
   AndroidStreamReaderURLRequestJobDelegateImpl();
 
+  bool CanOpenInputStream(JNIEnv* env, net::URLRequest* request);
+
   virtual scoped_ptr<InputStream> OpenInputStream(
       JNIEnv* env,
       net::URLRequest* request) OVERRIDE;
 
   virtual bool GetMimeType(JNIEnv* env,
                            net::URLRequest* request,
                            InputStream* stream,
                            std::string* mime_type) OVERRIDE;
 
   virtual bool GetCharset(JNIEnv* env,
                           net::URLRequest* request,
                           InputStream* stream,
                           std::string* charset) OVERRIDE;
 
   virtual ~AndroidStreamReaderURLRequestJobDelegateImpl();
+
+ private:
+  scoped_ptr<InputStream> DoOpenInputStream(JNIEnv* env,
+                                            net::URLRequest* request);
+
+  net::URLRequest* cached_input_stream_request_;
+  scoped_ptr<InputStream> cached_input_stream_;
 };
 
-class AssetFileProtocolInterceptor :
+class AssetFileProtocolHandler :
       public net::URLRequestJobFactory::ProtocolHandler {
  public:
-  virtual ~AssetFileProtocolInterceptor() OVERRIDE;
-  static scoped_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
-      scoped_ptr<net::URLRequestJobFactory> base_job_factory);
+  AssetFileProtocolHandler();
+
+  virtual ~AssetFileProtocolHandler() OVERRIDE;
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE;
 
  private:
-  AssetFileProtocolInterceptor();
-
   // 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 net::URLRequestJobFactory::ProtocolHandler {
  public:
-  ContentSchemeProtocolHandler() {}
-
+  ContentSchemeProtocolHandler();
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
-  DCHECK(request->url().SchemeIs(android_webview::kContentScheme));
-  return new AndroidStreamReaderURLRequestJob(
-      request,
-      network_delegate,
-      scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>(
-          new AndroidStreamReaderURLRequestJobDelegateImpl()));
-  }
+      net::NetworkDelegate* network_delegate) 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());
   return context;
 }
 
+// AndroidStreamReaderURLRequestJobDelegateImpl -------------------------------
+
 AndroidStreamReaderURLRequestJobDelegateImpl::
-AndroidStreamReaderURLRequestJobDelegateImpl() {
-}
+    AndroidStreamReaderURLRequestJobDelegateImpl()
+    : cached_input_stream_request_(NULL) {}
 
 AndroidStreamReaderURLRequestJobDelegateImpl::
 ~AndroidStreamReaderURLRequestJobDelegateImpl() {
 }
 
+bool AndroidStreamReaderURLRequestJobDelegateImpl::CanOpenInputStream(
+    JNIEnv* env,
+    net::URLRequest* request) {
+  cached_input_stream_request_ = request;
+  cached_input_stream_ = DoOpenInputStream(env, request);
+  return cached_input_stream_.get() != NULL;
+}
+
 scoped_ptr<InputStream>
-AndroidStreamReaderURLRequestJobDelegateImpl::OpenInputStream(
-    JNIEnv* env, net::URLRequest* request) {
+AndroidStreamReaderURLRequestJobDelegateImpl::DoOpenInputStream(
+    JNIEnv* env,
+    net::URLRequest* request) {
   DCHECK(request);
   DCHECK(env);
 
   // Open the input stream.
   ScopedJavaLocalRef<jstring> url =
       ConvertUTF8ToJavaString(env, request->url().spec());
   ScopedJavaLocalRef<jobject> stream =
       android_webview::Java_AndroidProtocolHandler_open(
           env,
           GetResourceContext(env).obj(),
           url.obj());
 
   // Check and clear pending exceptions.
   if (ClearException(env) || stream.is_null()) {
     DLOG(ERROR) << "Unable to open input stream for Android URL";
     return scoped_ptr<InputStream>();
   }
   return make_scoped_ptr<InputStream>(new InputStreamImpl(stream));
 }
 
+scoped_ptr<InputStream>
+AndroidStreamReaderURLRequestJobDelegateImpl::OpenInputStream(
+    JNIEnv* env, net::URLRequest* request) {
+  if (cached_input_stream_request_ == request) {
+    cached_input_stream_request_ = NULL;
+    return cached_input_stream_.Pass();
+  }
+  return DoOpenInputStream(env, request);
+}
+
 bool AndroidStreamReaderURLRequestJobDelegateImpl::GetMimeType(
     JNIEnv* env,
     net::URLRequest* request,
     android_webview::InputStream* stream,
     std::string* mime_type) {
   DCHECK(env);
   DCHECK(request);
   DCHECK(mime_type);
 
   // Query the mime type from the Java side. It is possible for the query to
@@ skipping 16 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;
 }
 
-AssetFileProtocolInterceptor::AssetFileProtocolInterceptor()
+// AssetFileProtocolHandler -----------------------------------------------
+
+AssetFileProtocolHandler::AssetFileProtocolHandler()
     : asset_prefix_(std::string(chrome::kFileScheme) +
                     std::string(content::kStandardSchemeSeparator) +
                     android_webview::kAndroidAssetPath),
       resource_prefix_(std::string(chrome::kFileScheme) +
                        std::string(content::kStandardSchemeSeparator) +
                        android_webview::kAndroidResourcePath) {
 }
 
-AssetFileProtocolInterceptor::~AssetFileProtocolInterceptor() {
+AssetFileProtocolHandler::~AssetFileProtocolHandler() {
 }
 
-// static
-scoped_ptr<net::URLRequestJobFactory>
-AssetFileProtocolInterceptor::CreateURLRequestJobFactory(
-    scoped_ptr<net::URLRequestJobFactory> base_job_factory) {
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory(
-      new net::ProtocolInterceptJobFactory(
-          base_job_factory.Pass(),
-          scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
-              new AssetFileProtocolInterceptor())));
-  return top_job_factory.Pass();
-}
-
-net::URLRequestJob* AssetFileProtocolInterceptor::MaybeCreateJob(
+net::URLRequestJob* AssetFileProtocolHandler::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   if (!request->url().SchemeIsFile()) return NULL;
 
   const std::string& url = request->url().spec();
   if (!StartsWithASCII(url, asset_prefix_, /*case_sensitive=*/ true) &&
       !StartsWithASCII(url, resource_prefix_,  /*case_sensitive=*/ true)) {
     return NULL;
   }
 
+  scoped_ptr<AndroidStreamReaderURLRequestJobDelegateImpl> reader_delegate(
+      new AndroidStreamReaderURLRequestJobDelegateImpl());
+
+  // For WebViewClassic compatibility this job can only accept URLs that can be
+  // opened.
+  if (!reader_delegate->CanOpenInputStream(AttachCurrentThread(), request)) {

[mkosiba (inactive), 2013/03/01 18:21:00]

Just thought of the right way to solve this - use a ResourceThrottle to delay
the URLRequest while we perform this check on the file thread and resume the
request when we get the result. I'd probably make it so the throttle creates the
AndroidStreamReaderURLRequestJobDelegateImpl so we won't have to open the
inputstream twice.

[mkosiba (inactive), 2013/03/05 16:34:43]

and turns out doing this is a major pain. opted to simply restart the request on
failure.

+    return NULL;
+  }
+
   return new AndroidStreamReaderURLRequestJob(
       request,
       network_delegate,
-      scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>(
-          new AndroidStreamReaderURLRequestJobDelegateImpl()));
+      reader_delegate.PassAs<AndroidStreamReaderURLRequestJob::Delegate>());
+}
+
+// ContentSchemeProtocolHandler -----------------------------------------------
+
+ContentSchemeProtocolHandler::ContentSchemeProtocolHandler() {
+}
+
+net::URLRequestJob* ContentSchemeProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  if (!request->url().SchemeIs(android_webview::kContentScheme)) {
+    return NULL;
+  }
+
+  scoped_ptr<AndroidStreamReaderURLRequestJobDelegateImpl> reader_delegate(
+      new AndroidStreamReaderURLRequestJobDelegateImpl());
+
+  // For WebViewClassic compatibility this job can only accept URLs that can be
+  // opened.
+  if (!reader_delegate->CanOpenInputStream(AttachCurrentThread(), request)) {
+    return NULL;
+  }
+
+  return new AndroidStreamReaderURLRequestJob(
+      request,
+      network_delegate,
+      reader_delegate.PassAs<AndroidStreamReaderURLRequestJob::Delegate>());
 }
 
 }  // namespace
 
 namespace android_webview {
 
 bool RegisterAndroidProtocolHandler(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
-scoped_ptr<net::URLRequestJobFactory> CreateAndroidRequestJobFactory(
-    scoped_ptr<AwURLRequestJobFactory> job_factory) {
-  // Register content://. Note that even though a scheme is
-  // registered here, it cannot be used by child processes until access to it is
-  // granted via ChildProcessSecurityPolicy::GrantScheme(). This is done in
-  // AwContentBrowserClient.
-  // The job factory takes ownership of the handler.
-  bool set_protocol = job_factory->SetProtocolHandler(
-      android_webview::kContentScheme, new ContentSchemeProtocolHandler());
-  DCHECK(set_protocol);
-  return AssetFileProtocolInterceptor::CreateURLRequestJobFactory(
-      job_factory.PassAs<net::URLRequestJobFactory>());
+scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+CreateContentSchemeProtocolHandler() {
+  return make_scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
+      new ContentSchemeProtocolHandler());
+}
+
+// static
+scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
+CreateAssetFileProtocolHandler() {
+  return make_scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
+      new AssetFileProtocolHandler());
 }
 
 // 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