android_webview/native/android_protocol_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/native/android_protocol_handler.h"
   6
   7 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
   8 #include "android_webview/browser/net/aw_url_request_job_factory.h"
   9 #include "android_webview/common/url_constants.h"
  10 #include "android_webview/native/input_stream_impl.h"
  11 #include "base/android/jni_android.h"
  12 #include "base/android/jni_string.h"
  13 #include "base/android/jni_weak_ref.h"
  14 #include "base/strings/string_util.h"
  15 #include "content/public/common/url_constants.h"
  16 #include "jni/AndroidProtocolHandler_jni.h"
  17 #include "net/base/io_buffer.h"
  18 #include "net/base/mime_util.h"
  19 #include "net/base/net_errors.h"
  20 #include "net/base/net_util.h"
  21 #include "net/http/http_util.h"
  22 #include "net/url_request/url_request.h"
  23 #include "net/url_request/url_request_interceptor.h"
  24 #include "url/gurl.h"
  25
  26 using android_webview::InputStream;
  27 using android_webview::InputStreamImpl;
  28 using base::android::AttachCurrentThread;
  29 using base::android::ClearException;
  30 using base::android::ConvertUTF8ToJavaString;
  31 using base::android::ScopedJavaGlobalRef;
  32 using base::android::ScopedJavaLocalRef;
  33
  34 namespace {
  35
  36 // Override resource context for reading resource and asset files. Used for
  37 // testing.
  38 JavaObjectWeakGlobalRef* g_resource_context = NULL;
  39
  40 void ResetResourceContext(JavaObjectWeakGlobalRef* ref) {
  41   if (g_resource_context)
  42     delete g_resource_context;
  43
  44   g_resource_context = ref;
  45 }
  46
  47 void* kPreviouslyFailedKey = &kPreviouslyFailedKey;
  48
  49 void MarkRequestAsFailed(net::URLRequest* request) {
  50   request->SetUserData(kPreviouslyFailedKey,
  51                        new base::SupportsUserData::Data());
  52 }
  53
  54 bool HasRequestPreviouslyFailed(net::URLRequest* request) {
  55   return request->GetUserData(kPreviouslyFailedKey) != NULL;
  56 }
  57
  58 class AndroidStreamReaderURLRequestJobDelegateImpl
  59     : public AndroidStreamReaderURLRequestJob::Delegate {
  60  public:
  61   AndroidStreamReaderURLRequestJobDelegateImpl();
  62
  63   virtual scoped_ptr<InputStream> OpenInputStream(
  64       JNIEnv* env,
  65       const GURL& url) OVERRIDE;
  66
  67   virtual void OnInputStreamOpenFailed(net::URLRequest* request,
  68                                        bool* restart) OVERRIDE;
  69
  70   virtual bool GetMimeType(JNIEnv* env,
  71                            net::URLRequest* request,
  72                            InputStream* stream,
  73                            std::string* mime_type) OVERRIDE;
  74
  75   virtual bool GetCharset(JNIEnv* env,
  76                           net::URLRequest* request,
  77                           InputStream* stream,
  78                           std::string* charset) OVERRIDE;
  79
  80   virtual void AppendResponseHeaders(
  81       JNIEnv* env,
  82       net::HttpResponseHeaders* headers) OVERRIDE;
  83
  84   virtual ~AndroidStreamReaderURLRequestJobDelegateImpl();
  85 };
  86
  87 class AndroidRequestInterceptorBase : public net::URLRequestInterceptor {
  88  public:
  89   virtual net::URLRequestJob* MaybeInterceptRequest(
  90       net::URLRequest* request,
  91       net::NetworkDelegate* network_delegate) const OVERRIDE;
  92
  93   virtual bool ShouldHandleRequest(const net::URLRequest* request) const = 0;
  94 };
  95
  96 class AssetFileRequestInterceptor : public AndroidRequestInterceptorBase {
  97  public:
  98   AssetFileRequestInterceptor();
  99
 100   virtual ~AssetFileRequestInterceptor() OVERRIDE;
 101   virtual bool ShouldHandleRequest(
 102       const net::URLRequest* request) const OVERRIDE;
 103
 104  private:
 105   // file:///android_asset/
 106   const std::string asset_prefix_;
 107   // file:///android_res/
 108   const std::string resource_prefix_;
 109 };
 110
 111 // Protocol handler for content:// scheme requests.
 112 class ContentSchemeRequestInterceptor : public AndroidRequestInterceptorBase {
 113  public:
 114   ContentSchemeRequestInterceptor();
 115   virtual bool ShouldHandleRequest(
 116       const net::URLRequest* request) const OVERRIDE;
 117 };
 118
 119 static ScopedJavaLocalRef<jobject> GetResourceContext(JNIEnv* env) {
 120   if (g_resource_context)
 121     return g_resource_context->get(env);
 122   ScopedJavaLocalRef<jobject> context;
 123   // We have to reset as GetApplicationContext() returns a jobject with a
 124   // global ref. The constructor that takes a jobject would expect a local ref
 125   // and would assert.
 126   context.Reset(env, base::android::GetApplicationContext());
 127   return context;
 128 }
 129
 130 // AndroidStreamReaderURLRequestJobDelegateImpl -------------------------------
 131
 132 AndroidStreamReaderURLRequestJobDelegateImpl::
 133     AndroidStreamReaderURLRequestJobDelegateImpl() {}
 134
 135 AndroidStreamReaderURLRequestJobDelegateImpl::
 136 ~AndroidStreamReaderURLRequestJobDelegateImpl() {
 137 }
 138
 139 scoped_ptr<InputStream>
 140 AndroidStreamReaderURLRequestJobDelegateImpl::OpenInputStream(
 141     JNIEnv* env, const GURL& url) {
 142   DCHECK(url.is_valid());
 143   DCHECK(env);
 144
 145   // Open the input stream.
 146   ScopedJavaLocalRef<jstring> jurl =
 147       ConvertUTF8ToJavaString(env, url.spec());
 148   ScopedJavaLocalRef<jobject> stream =
 149       android_webview::Java_AndroidProtocolHandler_open(
 150           env,
 151           GetResourceContext(env).obj(),
 152           jurl.obj());
 153
 154   if (stream.is_null()) {
 155     DLOG(ERROR) << "Unable to open input stream for Android URL";
 156     return scoped_ptr<InputStream>();
 157   }
 158   return make_scoped_ptr<InputStream>(new InputStreamImpl(stream));
 159 }
 160
 161 void AndroidStreamReaderURLRequestJobDelegateImpl::OnInputStreamOpenFailed(
 162     net::URLRequest* request,
 163     bool* restart) {
 164   DCHECK(!HasRequestPreviouslyFailed(request));
 165   MarkRequestAsFailed(request);
 166   *restart = true;
 167 }
 168
 169 bool AndroidStreamReaderURLRequestJobDelegateImpl::GetMimeType(
 170     JNIEnv* env,
 171     net::URLRequest* request,
 172     android_webview::InputStream* stream,
 173     std::string* mime_type) {
 174   DCHECK(env);
 175   DCHECK(request);
 176   DCHECK(mime_type);
 177
 178   // Query the mime type from the Java side. It is possible for the query to
 179   // fail, as the mime type cannot be determined for all supported schemes.
 180   ScopedJavaLocalRef<jstring> url =
 181       ConvertUTF8ToJavaString(env, request->url().spec());
 182   const InputStreamImpl* stream_impl =
 183       InputStreamImpl::FromInputStream(stream);
 184   ScopedJavaLocalRef<jstring> returned_type =
 185       android_webview::Java_AndroidProtocolHandler_getMimeType(
 186           env,
 187           GetResourceContext(env).obj(),
 188           stream_impl->jobj(), url.obj());
 189   if (returned_type.is_null())
 190     return false;
 191
 192   *mime_type = base::android::ConvertJavaStringToUTF8(returned_type);
 193   return true;
 194 }
 195
 196 bool AndroidStreamReaderURLRequestJobDelegateImpl::GetCharset(
 197     JNIEnv* env,
 198     net::URLRequest* request,
 199     android_webview::InputStream* stream,
 200     std::string* charset) {
 201   // TODO: We should probably be getting this from the managed side.
 202   return false;
 203 }
 204
 205 void AndroidStreamReaderURLRequestJobDelegateImpl::AppendResponseHeaders(
 206     JNIEnv* env,
 207     net::HttpResponseHeaders* headers) {
 208   // no-op
 209 }
 210
 211 // AndroidRequestInterceptorBase ----------------------------------------------
 212
 213 net::URLRequestJob* AndroidRequestInterceptorBase::MaybeInterceptRequest(
 214     net::URLRequest* request,
 215     net::NetworkDelegate* network_delegate) const {
 216   if (!ShouldHandleRequest(request))
 217     return NULL;
 218
 219   // For WebViewClassic compatibility this job can only accept URLs that can be
 220   // opened. URLs that cannot be opened should be resolved by the next handler.
 221   //
 222   // If a request is initially handled here but the job fails due to it being
 223   // unable to open the InputStream for that request the request is marked as
 224   // previously failed and restarted.
 225   // Restarting a request involves creating a new job for that request. This
 226   // handler will ignore requests know to have previously failed to 1) prevent
 227   // an infinite loop, 2) ensure that the next handler in line gets the
 228   // opportunity to create a job for the request.
 229   if (HasRequestPreviouslyFailed(request))
 230     return NULL;
 231
 232   scoped_ptr<AndroidStreamReaderURLRequestJobDelegateImpl> reader_delegate(
 233       new AndroidStreamReaderURLRequestJobDelegateImpl());
 234
 235   return new AndroidStreamReaderURLRequestJob(
 236       request,
 237       network_delegate,
 238       reader_delegate.PassAs<AndroidStreamReaderURLRequestJob::Delegate>());
 239 }
 240
 241 // AssetFileRequestInterceptor ------------------------------------------------
 242
 243 AssetFileRequestInterceptor::AssetFileRequestInterceptor()
 244     : asset_prefix_(std::string(url::kFileScheme) +
 245                     std::string(url::kStandardSchemeSeparator) +
 246                     android_webview::kAndroidAssetPath),
 247       resource_prefix_(std::string(url::kFileScheme) +
 248                        std::string(url::kStandardSchemeSeparator) +
 249                        android_webview::kAndroidResourcePath) {
 250 }
 251
 252 AssetFileRequestInterceptor::~AssetFileRequestInterceptor() {
 253 }
 254
 255 bool AssetFileRequestInterceptor::ShouldHandleRequest(
 256     const net::URLRequest* request) const {
 257   if (!request->url().SchemeIsFile())
 258     return false;
 259
 260   const std::string& url = request->url().spec();
 261   if (!StartsWithASCII(url, asset_prefix_, /*case_sensitive=*/ true) &&
 262       !StartsWithASCII(url, resource_prefix_, /*case_sensitive=*/ true)) {
 263     return false;
 264   }
 265
 266   return true;
 267 }
 268
 269 // ContentSchemeRequestInterceptor --------------------------------------------
 270
 271 ContentSchemeRequestInterceptor::ContentSchemeRequestInterceptor() {
 272 }
 273
 274 bool ContentSchemeRequestInterceptor::ShouldHandleRequest(
 275     const net::URLRequest* request) const {
 276   return request->url().SchemeIs(android_webview::kContentScheme);
 277 }
 278
 279 }  // namespace
 280
 281 namespace android_webview {
 282
 283 bool RegisterAndroidProtocolHandler(JNIEnv* env) {
 284   return RegisterNativesImpl(env);
 285 }
 286
 287 // static
 288 scoped_ptr<net::URLRequestInterceptor>
 289 CreateContentSchemeRequestInterceptor() {
 290   return make_scoped_ptr<net::URLRequestInterceptor>(
 291       new ContentSchemeRequestInterceptor());
 292 }
 293
 294 // static
 295 scoped_ptr<net::URLRequestInterceptor> CreateAssetFileRequestInterceptor() {
 296   return scoped_ptr<net::URLRequestInterceptor>(
 297       new AssetFileRequestInterceptor());
 298 }
 299
 300 // Set a context object to be used for resolving resource queries. This can
 301 // be used to override the default application context and redirect all
 302 // resource queries to a specific context object, e.g., for the purposes of
 303 // testing.
 304 //
 305 // |context| should be a android.content.Context instance or NULL to enable
 306 // the use of the standard application context.
 307 static void SetResourceContextForTesting(JNIEnv* env, jclass /*clazz*/,
 308                                          jobject context) {
 309   if (context) {
 310     ResetResourceContext(new JavaObjectWeakGlobalRef(env, context));
 311   } else {
 312     ResetResourceContext(NULL);
 313   }
 314 }
 315
 316 static jstring GetAndroidAssetPath(JNIEnv* env, jclass /*clazz*/) {
 317   // OK to release, JNI binding.
 318   return ConvertUTF8ToJavaString(
 319       env, android_webview::kAndroidAssetPath).Release();
 320 }
 321
 322 static jstring GetAndroidResourcePath(JNIEnv* env, jclass /*clazz*/) {
 323   // OK to release, JNI binding.
 324   return ConvertUTF8ToJavaString(
 325       env, android_webview::kAndroidResourcePath).Release();
 326 }
 327
 328 }  // namespace android_webview