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