[Android] Fix handling of asset files loading.

chrome/browser/android/android_protocol_adapter.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.
 
 // URL request job for reading from resources and assets.
 
 #include "chrome/browser/android/android_protocol_adapter.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_helper.h"
 #include "base/android/jni_string.h"
 #include "base/string_util.h"
 #include "chrome/browser/android/android_stream_reader_url_request_job.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "jni/AndroidProtocolAdapter_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/url_request_error_job.h"
-#include "net/url_request/url_request_file_job.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_manager.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ClearException;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
@@ skipping 23 matching lines @@
                            std::string* mime_type) OVERRIDE;
 
   virtual bool GetCharset(JNIEnv* env,
                           net::URLRequest* request,
                           jobject stream,
                           std::string* charset) OVERRIDE;
 
   virtual ~AndroidStreamReaderURLRequestJobDelegateImpl();
 };
 
+class AssetFileProtocolInterceptor :
+      public net::URLRequestJobFactory::Interceptor {
+ public:
+  AssetFileProtocolInterceptor();
+  virtual ~AssetFileProtocolInterceptor() OVERRIDE;
+  virtual net::URLRequestJob* MaybeIntercept(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual net::URLRequestJob* MaybeInterceptRedirect(
+      const GURL& location,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
+
+ private:
+  const std::string kAssetPrefix;
+  const std::string kResourcePrefix;
+};
 
 } // namespace
 
 static bool InitJNIBindings(JNIEnv* env) {
   return RegisterNativesImpl(env) &&
       AndroidStreamReaderURLRequestJob::InitJNIBindings(env);
 }
 
 // static
 net::URLRequestJob* AndroidProtocolAdapter::Factory(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const std::string& scheme) {
-  DCHECK(scheme == chrome::kFileScheme ||
-         scheme == chrome::kContentScheme);
-  JNIEnv* env = AttachCurrentThread();
-  DCHECK(env);
-  // If this is a file:// URL we cannot handle, fall back to the default
-  // handler.
-  const std::string& url = request->url().spec();
-  std::string assetPrefix = std::string(chrome::kFileScheme) + "://" +
-      chrome::kAndroidAssetPath;
-  std::string resourcePrefix = std::string(chrome::kFileScheme) + "://" +
-      chrome::kAndroidResourcePath;
-
-  if (scheme == chrome::kFileScheme &&
-      !StartsWithASCII(url, assetPrefix, /*case_sensitive=*/ true) &&
-      !StartsWithASCII(url, resourcePrefix,  /*case_sensitive=*/ true)) {
-    return net::URLRequestFileJob::Factory(request, network_delegate, scheme);
-  }
-
+  DCHECK(scheme == chrome::kContentScheme);
   return new AndroidStreamReaderURLRequestJob(
       request,
       network_delegate,
       scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>(
           new AndroidStreamReaderURLRequestJobDelegateImpl()));
 }
 
+static void AddFileSchemeInterceptorOnIOThread(
+    net::URLRequestContextGetter* context_getter) {
+  // The job factory takes ownership of the interceptor.
+  const_cast<net::URLRequestJobFactory*>(
+      context_getter->GetURLRequestContext()->job_factory())->AddInterceptor(
+          new AssetFileProtocolInterceptor());
+}
+
 // static
-bool AndroidProtocolAdapter::RegisterProtocols(JNIEnv* env) {
+void AndroidProtocolAdapter::RegisterProtocols(
+    JNIEnv* env, net::URLRequestContextGetter* context_getter) {
   DCHECK(env);
+  if (!InitJNIBindings(env)) {
+    // Must not fail.
+    NOTREACHED();
+  }
 
-  if (!InitJNIBindings(env))
-    return false;
-
-  // Register content:// and file://. Note that even though a scheme is
+  // 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
   // RenderViewHost.
+  //
+  // TODO(mnaganov): Convert into a ProtocolHandler.
   net::URLRequestJobManager* job_manager =
       net::URLRequestJobManager::GetInstance();
   job_manager->RegisterProtocolFactory(chrome::kContentScheme,
       &AndroidProtocolAdapter::Factory);
-  job_manager->RegisterProtocolFactory(
-      chrome::kFileScheme, &AndroidProtocolAdapter::Factory);
 
-  return true;
+  // Register a file: scheme interceptor for application assets.
+  context_getter->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&AddFileSchemeInterceptorOnIOThread,
+                 make_scoped_refptr(context_getter)));
+  // TODO(mnaganov): Add an interceptor for the incognito profile?
 }
 
 // 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 84 matching lines @@
 }
 
 bool AndroidStreamReaderURLRequestJobDelegateImpl::GetCharset(
     JNIEnv* env,
     net::URLRequest* request,
     jobject stream,
     std::string* charset) {
   // TODO: We should probably be getting this from the managed side.
   return false;
 }
+
+AssetFileProtocolInterceptor::AssetFileProtocolInterceptor() :
+    kAssetPrefix(std::string(chrome::kFileScheme) +

[joth, 2012/08/29 19:49:33]

nit: initializer colon should be on this line

[mnaganov (inactive), 2012/08/30 09:24:38]

Done.

+                 std::string(content::kStandardSchemeSeparator) +
+                 chrome::kAndroidAssetPath),
+    kResourcePrefix(std::string(chrome::kFileScheme) +

[joth, 2012/08/29 19:49:33]

nit: I think technically kConst is only for things constants that are statically
defined at compile time.

On balance I think these may as well be done that way too (i.e.: static const
char[] kFoo = "file://android_asset"). while it means we 'duplicate' parts of
the string literals on the flip side it makes it much easier to see (and verify)
exactly what those constants contains, and in reality these aren't going to
change a whole lot as they're in the public API spec.

[mnaganov (inactive), 2012/08/30 09:24:38]

Agree. Changed to asset_prefix_ and resource_prefix_.
 
Well, URI scheme names also doesn't change, but we anyway have constants for
them. One reason for using constants is that if you mistype the name of the
constant, you'll get a compiler error. For clarity, I've added comments for
these constants with their intended values.

[joth, 2012/08/30 18:10:40]

Ah I wasn't meaning to suggest removing constants, just change them to be true
compile-time constants, e.g.:

namespace {
const char[] kAndroidAssetPrefix = "file://android_asset";
...
}

+                    std::string(content::kStandardSchemeSeparator) +
+                    chrome::kAndroidResourcePath) {
+}
+
+AssetFileProtocolInterceptor::~AssetFileProtocolInterceptor() {
+}
+
+net::URLRequestJob* AssetFileProtocolInterceptor::MaybeIntercept(
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+  if (!request->url().SchemeIsFile()) return NULL;
+
+  const std::string& url = request->url().spec();
+  if (!StartsWithASCII(url, kAssetPrefix, /*case_sensitive=*/ true) &&
+      !StartsWithASCII(url, kResourcePrefix,  /*case_sensitive=*/ true)) {
+    return NULL;
+  }
+
+  return new AndroidStreamReaderURLRequestJob(
+      request,
+      network_delegate,
+      scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>(
+          new AndroidStreamReaderURLRequestJobDelegateImpl()));
+}
+
+net::URLRequestJob* AssetFileProtocolInterceptor::MaybeInterceptRedirect(
+    const GURL& location,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return NULL;
+}
+
+net::URLRequestJob* AssetFileProtocolInterceptor::MaybeInterceptResponse(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return NULL;
+}