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/aw_contents_io_thread_client_impl.h" 6 7 #include <map> 8 #include <utility> 9 10 #include "android_webview/common/devtools_instrumentation.h" 11 #include "android_webview/native/aw_web_resource_response_impl.h" 12 #include "base/android/jni_array.h" 13 #include "base/android/jni_string.h" 14 #include "base/android/jni_weak_ref.h" 15 #include "base/lazy_instance.h" 16 #include "base/memory/linked_ptr.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "base/synchronization/lock.h" 19 #include "content/public/browser/browser_thread.h" 20 #include "content/public/browser/render_frame_host.h" 21 #include "content/public/browser/render_process_host.h" 22 #include "content/public/browser/render_view_host.h" 23 #include "content/public/browser/resource_request_info.h" 24 #include "content/public/browser/web_contents.h" 25 #include "content/public/browser/web_contents_observer.h" 26 #include "jni/AwContentsIoThreadClient_jni.h" 27 #include "net/http/http_request_headers.h" 28 #include "net/url_request/url_request.h" 29 #include "url/gurl.h" 30 31 using base::android::AttachCurrentThread; 32 using base::android::ConvertUTF8ToJavaString; 33 using base::android::JavaRef; 34 using base::android::ScopedJavaLocalRef; 35 using base::android::ToJavaArrayOfStrings; 36 using base::LazyInstance; 37 using content::BrowserThread; 38 using content::RenderFrameHost; 39 using content::ResourceType; 40 using content::WebContents; 41 using std::map; 42 using std::pair; 43 using std::string; 44 using std::vector; 45 46 namespace android_webview { 47 48 namespace { 49 50 struct IoThreadClientData { 51 bool pending_association; 52 JavaObjectWeakGlobalRef io_thread_client; 53 54 IoThreadClientData(); 55 }; 56 57 IoThreadClientData::IoThreadClientData() : pending_association(false) {} 58 59 typedef map<pair<int, int>, IoThreadClientData> 60 RenderFrameHostToIoThreadClientType; 61 62 static pair<int, int> GetRenderFrameHostIdPair(RenderFrameHost* rfh) { 63 return pair<int, int>(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); 64 } 65 66 // RfhToIoThreadClientMap ----------------------------------------------------- 67 class RfhToIoThreadClientMap { 68 public: 69 static RfhToIoThreadClientMap* GetInstance(); 70 void Set(pair<int, int> rfh_id, const IoThreadClientData& client); 71 bool Get(pair<int, int> rfh_id, IoThreadClientData* client); 72 void Erase(pair<int, int> rfh_id); 73 74 private: 75 static LazyInstance<RfhToIoThreadClientMap> g_instance_; 76 base::Lock map_lock_; 77 RenderFrameHostToIoThreadClientType rfh_to_io_thread_client_; 78 }; 79 80 // static 81 LazyInstance<RfhToIoThreadClientMap> RfhToIoThreadClientMap::g_instance_ = 82 LAZY_INSTANCE_INITIALIZER; 83 84 // static 85 RfhToIoThreadClientMap* RfhToIoThreadClientMap::GetInstance() { 86 return g_instance_.Pointer(); 87 } 88 89 void RfhToIoThreadClientMap::Set(pair<int, int> rfh_id, 90 const IoThreadClientData& client) { 91 base::AutoLock lock(map_lock_); 92 rfh_to_io_thread_client_[rfh_id] = client; 93 } 94 95 bool RfhToIoThreadClientMap::Get( 96 pair<int, int> rfh_id, IoThreadClientData* client) { 97 base::AutoLock lock(map_lock_); 98 RenderFrameHostToIoThreadClientType::iterator iterator = 99 rfh_to_io_thread_client_.find(rfh_id); 100 if (iterator == rfh_to_io_thread_client_.end()) 101 return false; 102 103 *client = iterator->second; 104 return true; 105 } 106 107 void RfhToIoThreadClientMap::Erase(pair<int, int> rfh_id) { 108 base::AutoLock lock(map_lock_); 109 rfh_to_io_thread_client_.erase(rfh_id); 110 } 111 112 // ClientMapEntryUpdater ------------------------------------------------------ 113 114 class ClientMapEntryUpdater : public content::WebContentsObserver { 115 public: 116 ClientMapEntryUpdater(JNIEnv* env, WebContents* web_contents, 117 jobject jdelegate); 118 119 virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) OVERRIDE; 120 virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) OVERRIDE; 121 virtual void WebContentsDestroyed() OVERRIDE; 122 123 private: 124 JavaObjectWeakGlobalRef jdelegate_; 125 }; 126 127 ClientMapEntryUpdater::ClientMapEntryUpdater(JNIEnv* env, 128 WebContents* web_contents, 129 jobject jdelegate) 130 : content::WebContentsObserver(web_contents), 131 jdelegate_(env, jdelegate) { 132 DCHECK(web_contents); 133 DCHECK(jdelegate); 134 135 if (web_contents->GetMainFrame()) 136 RenderFrameCreated(web_contents->GetMainFrame()); 137 } 138 139 void ClientMapEntryUpdater::RenderFrameCreated(RenderFrameHost* rfh) { 140 IoThreadClientData client_data; 141 client_data.io_thread_client = jdelegate_; 142 client_data.pending_association = false; 143 RfhToIoThreadClientMap::GetInstance()->Set( 144 GetRenderFrameHostIdPair(rfh), client_data); 145 } 146 147 void ClientMapEntryUpdater::RenderFrameDeleted(RenderFrameHost* rfh) { 148 RfhToIoThreadClientMap::GetInstance()->Erase(GetRenderFrameHostIdPair(rfh)); 149 } 150 151 void ClientMapEntryUpdater::WebContentsDestroyed() { 152 delete this; 153 } 154 155 } // namespace 156 157 // AwContentsIoThreadClientImpl ----------------------------------------------- 158 159 // static 160 scoped_ptr<AwContentsIoThreadClient> 161 AwContentsIoThreadClient::FromID(int render_process_id, int render_frame_id) { 162 pair<int, int> rfh_id(render_process_id, render_frame_id); 163 IoThreadClientData client_data; 164 if (!RfhToIoThreadClientMap::GetInstance()->Get(rfh_id, &client_data)) 165 return scoped_ptr<AwContentsIoThreadClient>(); 166 167 JNIEnv* env = AttachCurrentThread(); 168 ScopedJavaLocalRef<jobject> java_delegate = 169 client_data.io_thread_client.get(env); 170 DCHECK(!client_data.pending_association || java_delegate.is_null()); 171 return scoped_ptr<AwContentsIoThreadClient>(new AwContentsIoThreadClientImpl( 172 client_data.pending_association, java_delegate)); 173 } 174 175 // static 176 void AwContentsIoThreadClient::SubFrameCreated(int render_process_id, 177 int parent_render_frame_id, 178 int child_render_frame_id) { 179 pair<int, int> parent_rfh_id(render_process_id, parent_render_frame_id); 180 pair<int, int> child_rfh_id(render_process_id, child_render_frame_id); 181 IoThreadClientData client_data; 182 if (!RfhToIoThreadClientMap::GetInstance()->Get(parent_rfh_id, 183 &client_data)) { 184 NOTREACHED(); 185 return; 186 } 187 188 RfhToIoThreadClientMap::GetInstance()->Set(child_rfh_id, client_data); 189 } 190 191 // static 192 void AwContentsIoThreadClientImpl::RegisterPendingContents( 193 WebContents* web_contents) { 194 IoThreadClientData client_data; 195 client_data.pending_association = true; 196 RfhToIoThreadClientMap::GetInstance()->Set( 197 GetRenderFrameHostIdPair(web_contents->GetMainFrame()), client_data); 198 } 199 200 // static 201 void AwContentsIoThreadClientImpl::Associate( 202 WebContents* web_contents, 203 const JavaRef<jobject>& jclient) { 204 JNIEnv* env = AttachCurrentThread(); 205 // The ClientMapEntryUpdater lifespan is tied to the WebContents. 206 new ClientMapEntryUpdater(env, web_contents, jclient.obj()); 207 } 208 209 AwContentsIoThreadClientImpl::AwContentsIoThreadClientImpl( 210 bool pending_association, 211 const JavaRef<jobject>& obj) 212 : pending_association_(pending_association), 213 java_object_(obj) { 214 } 215 216 AwContentsIoThreadClientImpl::~AwContentsIoThreadClientImpl() { 217 // explict, out-of-line destructor. 218 } 219 220 bool AwContentsIoThreadClientImpl::PendingAssociation() const { 221 return pending_association_; 222 } 223 224 AwContentsIoThreadClient::CacheMode 225 AwContentsIoThreadClientImpl::GetCacheMode() const { 226 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 227 if (java_object_.is_null()) 228 return AwContentsIoThreadClient::LOAD_DEFAULT; 229 230 JNIEnv* env = AttachCurrentThread(); 231 return static_cast<AwContentsIoThreadClient::CacheMode>( 232 Java_AwContentsIoThreadClient_getCacheMode( 233 env, java_object_.obj())); 234 } 235 236 scoped_ptr<AwWebResourceResponse> 237 AwContentsIoThreadClientImpl::ShouldInterceptRequest( 238 const GURL& location, 239 const net::URLRequest* request) { 240 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 241 if (java_object_.is_null()) 242 return scoped_ptr<AwWebResourceResponse>(); 243 const content::ResourceRequestInfo* info = 244 content::ResourceRequestInfo::ForRequest(request); 245 bool is_main_frame = info && 246 info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME; 247 bool has_user_gesture = info && info->HasUserGesture(); 248 249 vector<string> headers_names; 250 vector<string> headers_values; 251 { 252 net::HttpRequestHeaders headers; 253 if (!request->GetFullRequestHeaders(&headers)) 254 headers = request->extra_request_headers(); 255 net::HttpRequestHeaders::Iterator headers_iterator(headers); 256 while (headers_iterator.GetNext()) { 257 headers_names.push_back(headers_iterator.name()); 258 headers_values.push_back(headers_iterator.value()); 259 } 260 } 261 262 JNIEnv* env = AttachCurrentThread(); 263 ScopedJavaLocalRef<jstring> jstring_url = 264 ConvertUTF8ToJavaString(env, location.spec()); 265 ScopedJavaLocalRef<jstring> jstring_method = 266 ConvertUTF8ToJavaString(env, request->method()); 267 ScopedJavaLocalRef<jobjectArray> jstringArray_headers_names = 268 ToJavaArrayOfStrings(env, headers_names); 269 ScopedJavaLocalRef<jobjectArray> jstringArray_headers_values = 270 ToJavaArrayOfStrings(env, headers_values); 271 devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback( 272 "shouldInterceptRequest"); 273 ScopedJavaLocalRef<jobject> ret = 274 Java_AwContentsIoThreadClient_shouldInterceptRequest( 275 env, 276 java_object_.obj(), 277 jstring_url.obj(), 278 is_main_frame, 279 has_user_gesture, 280 jstring_method.obj(), 281 jstringArray_headers_names.obj(), 282 jstringArray_headers_values.obj()); 283 if (ret.is_null()) 284 return scoped_ptr<AwWebResourceResponse>(); 285 return scoped_ptr<AwWebResourceResponse>( 286 new AwWebResourceResponseImpl(ret)); 287 } 288 289 bool AwContentsIoThreadClientImpl::ShouldBlockContentUrls() const { 290 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 291 if (java_object_.is_null()) 292 return false; 293 294 JNIEnv* env = AttachCurrentThread(); 295 return Java_AwContentsIoThreadClient_shouldBlockContentUrls( 296 env, java_object_.obj()); 297 } 298 299 bool AwContentsIoThreadClientImpl::ShouldBlockFileUrls() const { 300 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 301 if (java_object_.is_null()) 302 return false; 303 304 JNIEnv* env = AttachCurrentThread(); 305 return Java_AwContentsIoThreadClient_shouldBlockFileUrls( 306 env, java_object_.obj()); 307 } 308 309 bool AwContentsIoThreadClientImpl::ShouldAcceptThirdPartyCookies() const { 310 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 311 if (java_object_.is_null()) 312 return false; 313 314 JNIEnv* env = AttachCurrentThread(); 315 return Java_AwContentsIoThreadClient_shouldAcceptThirdPartyCookies( 316 env, java_object_.obj()); 317 } 318 319 bool AwContentsIoThreadClientImpl::ShouldBlockNetworkLoads() const { 320 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 321 if (java_object_.is_null()) 322 return false; 323 324 JNIEnv* env = AttachCurrentThread(); 325 return Java_AwContentsIoThreadClient_shouldBlockNetworkLoads( 326 env, java_object_.obj()); 327 } 328 329 void AwContentsIoThreadClientImpl::NewDownload( 330 const GURL& url, 331 const string& user_agent, 332 const string& content_disposition, 333 const string& mime_type, 334 int64 content_length) { 335 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 336 if (java_object_.is_null()) 337 return; 338 339 JNIEnv* env = AttachCurrentThread(); 340 ScopedJavaLocalRef<jstring> jstring_url = 341 ConvertUTF8ToJavaString(env, url.spec()); 342 ScopedJavaLocalRef<jstring> jstring_user_agent = 343 ConvertUTF8ToJavaString(env, user_agent); 344 ScopedJavaLocalRef<jstring> jstring_content_disposition = 345 ConvertUTF8ToJavaString(env, content_disposition); 346 ScopedJavaLocalRef<jstring> jstring_mime_type = 347 ConvertUTF8ToJavaString(env, mime_type); 348 349 Java_AwContentsIoThreadClient_onDownloadStart( 350 env, 351 java_object_.obj(), 352 jstring_url.obj(), 353 jstring_user_agent.obj(), 354 jstring_content_disposition.obj(), 355 jstring_mime_type.obj(), 356 content_length); 357 } 358 359 void AwContentsIoThreadClientImpl::NewLoginRequest(const string& realm, 360 const string& account, 361 const string& args) { 362 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 363 if (java_object_.is_null()) 364 return; 365 366 JNIEnv* env = AttachCurrentThread(); 367 ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm); 368 ScopedJavaLocalRef<jstring> jargs = ConvertUTF8ToJavaString(env, args); 369 370 ScopedJavaLocalRef<jstring> jaccount; 371 if (!account.empty()) 372 jaccount = ConvertUTF8ToJavaString(env, account); 373 374 Java_AwContentsIoThreadClient_newLoginRequest( 375 env, java_object_.obj(), jrealm.obj(), jaccount.obj(), jargs.obj()); 376 } 377 378 bool RegisterAwContentsIoThreadClientImpl(JNIEnv* env) { 379 return RegisterNativesImpl(env); 380 } 381 382 } // namespace android_webview 383
