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
ResetResourceContext(JavaObjectWeakGlobalRef * ref)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
MarkRequestAsFailed(net::URLRequest * request)49 void MarkRequestAsFailed(net::URLRequest* request) {
50 request->SetUserData(kPreviouslyFailedKey,
51 new base::SupportsUserData::Data());
52 }
53
HasRequestPreviouslyFailed(net::URLRequest * request)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
GetResourceContext(JNIEnv * env)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::
AndroidStreamReaderURLRequestJobDelegateImpl()133 AndroidStreamReaderURLRequestJobDelegateImpl() {}
134
135 AndroidStreamReaderURLRequestJobDelegateImpl::
~AndroidStreamReaderURLRequestJobDelegateImpl()136 ~AndroidStreamReaderURLRequestJobDelegateImpl() {
137 }
138
139 scoped_ptr<InputStream>
OpenInputStream(JNIEnv * env,const GURL & url)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
OnInputStreamOpenFailed(net::URLRequest * request,bool * restart)161 void AndroidStreamReaderURLRequestJobDelegateImpl::OnInputStreamOpenFailed(
162 net::URLRequest* request,
163 bool* restart) {
164 DCHECK(!HasRequestPreviouslyFailed(request));
165 MarkRequestAsFailed(request);
166 *restart = true;
167 }
168
GetMimeType(JNIEnv * env,net::URLRequest * request,android_webview::InputStream * stream,std::string * mime_type)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
GetCharset(JNIEnv * env,net::URLRequest * request,android_webview::InputStream * stream,std::string * charset)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
AppendResponseHeaders(JNIEnv * env,net::HttpResponseHeaders * headers)205 void AndroidStreamReaderURLRequestJobDelegateImpl::AppendResponseHeaders(
206 JNIEnv* env,
207 net::HttpResponseHeaders* headers) {
208 // no-op
209 }
210
211 // AndroidRequestInterceptorBase ----------------------------------------------
212
MaybeInterceptRequest(net::URLRequest * request,net::NetworkDelegate * network_delegate) const213 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
AssetFileRequestInterceptor()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
~AssetFileRequestInterceptor()252 AssetFileRequestInterceptor::~AssetFileRequestInterceptor() {
253 }
254
ShouldHandleRequest(const net::URLRequest * request) const255 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
ContentSchemeRequestInterceptor()271 ContentSchemeRequestInterceptor::ContentSchemeRequestInterceptor() {
272 }
273
ShouldHandleRequest(const net::URLRequest * request) const274 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
RegisterAndroidProtocolHandler(JNIEnv * env)283 bool RegisterAndroidProtocolHandler(JNIEnv* env) {
284 return RegisterNativesImpl(env);
285 }
286
287 // static
288 scoped_ptr<net::URLRequestInterceptor>
CreateContentSchemeRequestInterceptor()289 CreateContentSchemeRequestInterceptor() {
290 return make_scoped_ptr<net::URLRequestInterceptor>(
291 new ContentSchemeRequestInterceptor());
292 }
293
294 // static
CreateAssetFileRequestInterceptor()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.
SetResourceContextForTesting(JNIEnv * env,jclass,jobject 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
GetAndroidAssetPath(JNIEnv * env,jclass)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
GetAndroidResourcePath(JNIEnv * env,jclass)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
329