1 // Copyright (c) 2011 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/cookie_manager.h" 6 7 #include "android_webview/browser/aw_browser_context.h" 8 #include "android_webview/browser/aw_cookie_access_policy.h" 9 #include "android_webview/browser/net/init_native_callback.h" 10 #include "android_webview/browser/scoped_allow_wait_for_legacy_web_view_api.h" 11 #include "android_webview/native/aw_browser_dependency_factory.h" 12 #include "base/android/jni_string.h" 13 #include "base/android/path_utils.h" 14 #include "base/bind.h" 15 #include "base/bind_helpers.h" 16 #include "base/files/file_path.h" 17 #include "base/files/file_util.h" 18 #include "base/lazy_instance.h" 19 #include "base/message_loop/message_loop.h" 20 #include "base/message_loop/message_loop_proxy.h" 21 #include "base/path_service.h" 22 #include "base/synchronization/lock.h" 23 #include "base/synchronization/waitable_event.h" 24 #include "base/threading/sequenced_worker_pool.h" 25 #include "base/threading/thread.h" 26 #include "base/threading/thread_restrictions.h" 27 #include "content/public/browser/browser_context.h" 28 #include "content/public/browser/browser_thread.h" 29 #include "content/public/browser/cookie_crypto_delegate.h" 30 #include "content/public/browser/cookie_store_factory.h" 31 #include "jni/AwCookieManager_jni.h" 32 #include "net/cookies/cookie_monster.h" 33 #include "net/cookies/cookie_options.h" 34 #include "net/url_request/url_request_context.h" 35 #include "url/url_constants.h" 36 37 using base::FilePath; 38 using base::WaitableEvent; 39 using base::android::ConvertJavaStringToUTF8; 40 using base::android::ConvertJavaStringToUTF16; 41 using base::android::ScopedJavaGlobalRef; 42 using content::BrowserThread; 43 using net::CookieList; 44 using net::CookieMonster; 45 46 // In the future, we may instead want to inject an explicit CookieStore 47 // dependency into this object during process initialization to avoid 48 // depending on the URLRequestContext. 49 // See issue http://crbug.com/157683 50 51 // On the CookieManager methods without a callback and methods with a callback 52 // when that callback is null can be called from any thread, including threads 53 // without a message loop. Methods with a non-null callback must be called on 54 // a thread with a running message loop. 55 56 namespace android_webview { 57 58 namespace { 59 60 typedef base::Callback<void(bool)> BoolCallback; 61 typedef base::Callback<void(int)> IntCallback; 62 63 // Holds a Java BooleanCookieCallback, knows how to invoke it and turn it 64 // into a base callback. 65 class BoolCookieCallbackHolder { 66 public: 67 BoolCookieCallbackHolder(JNIEnv* env, jobject callback) { 68 callback_.Reset(env, callback); 69 } 70 71 void Invoke(bool result) { 72 if (!callback_.is_null()) { 73 JNIEnv* env = base::android::AttachCurrentThread(); 74 Java_AwCookieManager_invokeBooleanCookieCallback( 75 env, callback_.obj(), result); 76 } 77 } 78 79 static BoolCallback ConvertToCallback( 80 scoped_ptr<BoolCookieCallbackHolder> me) { 81 return base::Bind(&BoolCookieCallbackHolder::Invoke, 82 base::Owned(me.release())); 83 } 84 85 private: 86 ScopedJavaGlobalRef<jobject> callback_; 87 DISALLOW_COPY_AND_ASSIGN(BoolCookieCallbackHolder); 88 }; 89 90 // Construct a closure which signals a waitable event if and when the closure 91 // is called the waitable event must still exist. 92 static base::Closure SignalEventClosure(WaitableEvent* completion) { 93 return base::Bind(&WaitableEvent::Signal, base::Unretained(completion)); 94 } 95 96 static void DiscardBool(const base::Closure& f, bool b) { 97 f.Run(); 98 } 99 100 static BoolCallback BoolCallbackAdapter(const base::Closure& f) { 101 return base::Bind(&DiscardBool, f); 102 } 103 104 static void DiscardInt(const base::Closure& f, int i) { 105 f.Run(); 106 } 107 108 static IntCallback IntCallbackAdapter(const base::Closure& f) { 109 return base::Bind(&DiscardInt, f); 110 } 111 112 // Are cookies allowed for file:// URLs by default? 113 const bool kDefaultFileSchemeAllowed = false; 114 115 void ImportLegacyCookieStore(const FilePath& cookie_store_path) { 116 // We use the old cookie store to create the new cookie store only if the 117 // new cookie store does not exist. 118 if (base::PathExists(cookie_store_path)) 119 return; 120 121 // WebViewClassic gets the database path from Context and appends a 122 // hardcoded name. See: 123 // https://android.googlesource.com/platform/frameworks/base/+/bf6f6f9d/core/java/android/webkit/JniUtil.java 124 // https://android.googlesource.com/platform/external/webkit/+/7151e/ 125 // Source/WebKit/android/WebCoreSupport/WebCookieJar.cpp 126 FilePath old_cookie_store_path; 127 base::android::GetDatabaseDirectory(&old_cookie_store_path); 128 old_cookie_store_path = old_cookie_store_path.Append( 129 FILE_PATH_LITERAL("webviewCookiesChromium.db")); 130 if (base::PathExists(old_cookie_store_path) && 131 !base::Move(old_cookie_store_path, cookie_store_path)) { 132 LOG(WARNING) << "Failed to move old cookie store path from " 133 << old_cookie_store_path.AsUTF8Unsafe() << " to " 134 << cookie_store_path.AsUTF8Unsafe(); 135 } 136 } 137 138 void GetUserDataDir(FilePath* user_data_dir) { 139 if (!PathService::Get(base::DIR_ANDROID_APP_DATA, user_data_dir)) { 140 NOTREACHED() << "Failed to get app data directory for Android WebView"; 141 } 142 } 143 144 class CookieManager { 145 public: 146 static CookieManager* GetInstance(); 147 148 scoped_refptr<net::CookieStore> GetCookieStore(); 149 150 void SetShouldAcceptCookies(bool accept); 151 bool GetShouldAcceptCookies(); 152 void SetCookie(const GURL& host, 153 const std::string& cookie_value, 154 scoped_ptr<BoolCookieCallbackHolder> callback); 155 void SetCookieSync(const GURL& host, 156 const std::string& cookie_value); 157 std::string GetCookie(const GURL& host); 158 void RemoveSessionCookies(scoped_ptr<BoolCookieCallbackHolder> callback); 159 void RemoveAllCookies(scoped_ptr<BoolCookieCallbackHolder> callback); 160 void RemoveAllCookiesSync(); 161 void RemoveSessionCookiesSync(); 162 void RemoveExpiredCookies(); 163 void FlushCookieStore(); 164 bool HasCookies(); 165 bool AllowFileSchemeCookies(); 166 void SetAcceptFileSchemeCookies(bool accept); 167 168 private: 169 friend struct base::DefaultLazyInstanceTraits<CookieManager>; 170 171 CookieManager(); 172 ~CookieManager(); 173 174 void ExecCookieTaskSync(const base::Callback<void(BoolCallback)>& task); 175 void ExecCookieTaskSync(const base::Callback<void(IntCallback)>& task); 176 void ExecCookieTaskSync(const base::Callback<void(base::Closure)>& task); 177 void ExecCookieTask(const base::Closure& task); 178 179 void SetCookieHelper( 180 const GURL& host, 181 const std::string& value, 182 BoolCallback callback); 183 184 void GetCookieValueAsyncHelper(const GURL& host, 185 std::string* result, 186 base::Closure complete); 187 void GetCookieValueCompleted(base::Closure complete, 188 std::string* result, 189 const std::string& value); 190 191 void RemoveSessionCookiesHelper(BoolCallback callback); 192 void RemoveAllCookiesHelper(BoolCallback callback); 193 void RemoveCookiesCompleted(BoolCallback callback, int num_deleted); 194 195 void FlushCookieStoreAsyncHelper(base::Closure complete); 196 197 void HasCookiesAsyncHelper(bool* result, base::Closure complete); 198 void HasCookiesCompleted(base::Closure complete, 199 bool* result, 200 const CookieList& cookies); 201 202 void CreateCookieMonster( 203 const FilePath& user_data_dir, 204 const scoped_refptr<base::SequencedTaskRunner>& client_task_runner, 205 const scoped_refptr<base::SequencedTaskRunner>& background_task_runner); 206 void EnsureCookieMonsterExistsLocked(); 207 bool AllowFileSchemeCookiesLocked(); 208 void SetAcceptFileSchemeCookiesLocked(bool accept); 209 210 scoped_refptr<net::CookieMonster> cookie_monster_; 211 scoped_refptr<base::MessageLoopProxy> cookie_monster_proxy_; 212 base::Lock cookie_monster_lock_; 213 214 scoped_ptr<base::Thread> cookie_monster_client_thread_; 215 scoped_ptr<base::Thread> cookie_monster_backend_thread_; 216 217 DISALLOW_COPY_AND_ASSIGN(CookieManager); 218 }; 219 220 base::LazyInstance<CookieManager>::Leaky g_lazy_instance; 221 222 // static 223 CookieManager* CookieManager::GetInstance() { 224 return g_lazy_instance.Pointer(); 225 } 226 227 CookieManager::CookieManager() { 228 } 229 230 CookieManager::~CookieManager() { 231 } 232 233 void CookieManager::CreateCookieMonster( 234 const FilePath& user_data_dir, 235 const scoped_refptr<base::SequencedTaskRunner>& client_task_runner, 236 const scoped_refptr<base::SequencedTaskRunner>& background_task_runner) { 237 FilePath cookie_store_path = 238 user_data_dir.Append(FILE_PATH_LITERAL("Cookies")); 239 240 background_task_runner->PostTask( 241 FROM_HERE, 242 base::Bind(ImportLegacyCookieStore, cookie_store_path)); 243 244 content::CookieStoreConfig cookie_config( 245 cookie_store_path, 246 content::CookieStoreConfig::RESTORED_SESSION_COOKIES, 247 NULL, NULL); 248 cookie_config.client_task_runner = client_task_runner; 249 cookie_config.background_task_runner = background_task_runner; 250 net::CookieStore* cookie_store = content::CreateCookieStore(cookie_config); 251 cookie_monster_ = cookie_store->GetCookieMonster(); 252 SetAcceptFileSchemeCookiesLocked(kDefaultFileSchemeAllowed); 253 } 254 255 void CookieManager::EnsureCookieMonsterExistsLocked() { 256 cookie_monster_lock_.AssertAcquired(); 257 if (cookie_monster_.get()) { 258 return; 259 } 260 261 // Create cookie monster using WebView-specific threads, as the rest of the 262 // browser has not been started yet. 263 FilePath user_data_dir; 264 GetUserDataDir(&user_data_dir); 265 cookie_monster_client_thread_.reset( 266 new base::Thread("CookieMonsterClient")); 267 cookie_monster_client_thread_->Start(); 268 cookie_monster_proxy_ = cookie_monster_client_thread_->message_loop_proxy(); 269 cookie_monster_backend_thread_.reset( 270 new base::Thread("CookieMonsterBackend")); 271 cookie_monster_backend_thread_->Start(); 272 273 CreateCookieMonster(user_data_dir, 274 cookie_monster_proxy_, 275 cookie_monster_backend_thread_->message_loop_proxy()); 276 } 277 278 // Executes the |task| on the |cookie_monster_proxy_| message loop and 279 // waits for it to complete before returning. 280 281 // To execute a CookieTask synchronously you must arrange for Signal to be 282 // called on the waitable event at some point. You can call the bool or int 283 // versions of ExecCookieTaskSync, these will supply the caller with a dummy 284 // callback which takes an int/bool, throws it away and calls Signal. 285 // Alternatively you can call the version which supplies a Closure in which 286 // case you must call Run on it when you want the unblock the calling code. 287 288 // Ignore a bool callback. 289 void CookieManager::ExecCookieTaskSync( 290 const base::Callback<void(BoolCallback)>& task) { 291 WaitableEvent completion(false, false); 292 ExecCookieTask( 293 base::Bind(task, BoolCallbackAdapter(SignalEventClosure(&completion)))); 294 ScopedAllowWaitForLegacyWebViewApi wait; 295 completion.Wait(); 296 } 297 298 // Ignore an int callback. 299 void CookieManager::ExecCookieTaskSync( 300 const base::Callback<void(IntCallback)>& task) { 301 WaitableEvent completion(false, false); 302 ExecCookieTask( 303 base::Bind(task, IntCallbackAdapter(SignalEventClosure(&completion)))); 304 ScopedAllowWaitForLegacyWebViewApi wait; 305 completion.Wait(); 306 } 307 308 // Call the supplied closure when you want to signal that the blocked code can 309 // continue. 310 void CookieManager::ExecCookieTaskSync( 311 const base::Callback<void(base::Closure)>& task) { 312 WaitableEvent completion(false, false); 313 ExecCookieTask(base::Bind(task, SignalEventClosure(&completion))); 314 ScopedAllowWaitForLegacyWebViewApi wait; 315 completion.Wait(); 316 } 317 318 // Executes the |task| on the |cookie_monster_proxy_| message loop. 319 void CookieManager::ExecCookieTask(const base::Closure& task) { 320 base::AutoLock lock(cookie_monster_lock_); 321 EnsureCookieMonsterExistsLocked(); 322 cookie_monster_proxy_->PostTask(FROM_HERE, task); 323 } 324 325 scoped_refptr<net::CookieStore> CookieManager::GetCookieStore() { 326 base::AutoLock lock(cookie_monster_lock_); 327 EnsureCookieMonsterExistsLocked(); 328 return cookie_monster_; 329 } 330 331 void CookieManager::SetShouldAcceptCookies(bool accept) { 332 AwCookieAccessPolicy::GetInstance()->SetShouldAcceptCookies(accept); 333 } 334 335 bool CookieManager::GetShouldAcceptCookies() { 336 return AwCookieAccessPolicy::GetInstance()->GetShouldAcceptCookies(); 337 } 338 339 void CookieManager::SetCookie( 340 const GURL& host, 341 const std::string& cookie_value, 342 scoped_ptr<BoolCookieCallbackHolder> callback_holder) { 343 BoolCallback callback = 344 BoolCookieCallbackHolder::ConvertToCallback(callback_holder.Pass()); 345 ExecCookieTask(base::Bind(&CookieManager::SetCookieHelper, 346 base::Unretained(this), 347 host, 348 cookie_value, 349 callback)); 350 } 351 352 void CookieManager::SetCookieSync(const GURL& host, 353 const std::string& cookie_value) { 354 ExecCookieTaskSync(base::Bind(&CookieManager::SetCookieHelper, 355 base::Unretained(this), 356 host, 357 cookie_value)); 358 } 359 360 void CookieManager::SetCookieHelper( 361 const GURL& host, 362 const std::string& value, 363 const BoolCallback callback) { 364 net::CookieOptions options; 365 options.set_include_httponly(); 366 367 cookie_monster_->SetCookieWithOptionsAsync( 368 host, value, options, callback); 369 } 370 371 std::string CookieManager::GetCookie(const GURL& host) { 372 std::string cookie_value; 373 ExecCookieTaskSync(base::Bind(&CookieManager::GetCookieValueAsyncHelper, 374 base::Unretained(this), 375 host, 376 &cookie_value)); 377 return cookie_value; 378 } 379 380 void CookieManager::GetCookieValueAsyncHelper( 381 const GURL& host, 382 std::string* result, 383 base::Closure complete) { 384 net::CookieOptions options; 385 options.set_include_httponly(); 386 387 cookie_monster_->GetCookiesWithOptionsAsync( 388 host, 389 options, 390 base::Bind(&CookieManager::GetCookieValueCompleted, 391 base::Unretained(this), 392 complete, 393 result)); 394 } 395 396 void CookieManager::GetCookieValueCompleted(base::Closure complete, 397 std::string* result, 398 const std::string& value) { 399 *result = value; 400 complete.Run(); 401 } 402 403 void CookieManager::RemoveSessionCookies( 404 scoped_ptr<BoolCookieCallbackHolder> callback_holder) { 405 BoolCallback callback = 406 BoolCookieCallbackHolder::ConvertToCallback(callback_holder.Pass()); 407 ExecCookieTask(base::Bind(&CookieManager::RemoveSessionCookiesHelper, 408 base::Unretained(this), 409 callback)); 410 } 411 412 void CookieManager::RemoveSessionCookiesSync() { 413 ExecCookieTaskSync(base::Bind(&CookieManager::RemoveSessionCookiesHelper, 414 base::Unretained(this))); 415 } 416 417 void CookieManager::RemoveSessionCookiesHelper( 418 BoolCallback callback) { 419 cookie_monster_->DeleteSessionCookiesAsync( 420 base::Bind(&CookieManager::RemoveCookiesCompleted, 421 base::Unretained(this), 422 callback)); 423 } 424 425 void CookieManager::RemoveCookiesCompleted( 426 BoolCallback callback, 427 int num_deleted) { 428 callback.Run(num_deleted > 0); 429 } 430 431 void CookieManager::RemoveAllCookies( 432 scoped_ptr<BoolCookieCallbackHolder> callback_holder) { 433 BoolCallback callback = 434 BoolCookieCallbackHolder::ConvertToCallback(callback_holder.Pass()); 435 ExecCookieTask(base::Bind(&CookieManager::RemoveAllCookiesHelper, 436 base::Unretained(this), 437 callback)); 438 } 439 440 void CookieManager::RemoveAllCookiesSync() { 441 ExecCookieTaskSync(base::Bind(&CookieManager::RemoveAllCookiesHelper, 442 base::Unretained(this))); 443 } 444 445 void CookieManager::RemoveAllCookiesHelper( 446 const BoolCallback callback) { 447 cookie_monster_->DeleteAllAsync( 448 base::Bind(&CookieManager::RemoveCookiesCompleted, 449 base::Unretained(this), 450 callback)); 451 } 452 453 void CookieManager::RemoveExpiredCookies() { 454 // HasCookies will call GetAllCookiesAsync, which in turn will force a GC. 455 HasCookies(); 456 } 457 458 void CookieManager::FlushCookieStore() { 459 ExecCookieTaskSync(base::Bind(&CookieManager::FlushCookieStoreAsyncHelper, 460 base::Unretained(this))); 461 } 462 463 void CookieManager::FlushCookieStoreAsyncHelper( 464 base::Closure complete) { 465 cookie_monster_->FlushStore(complete); 466 } 467 468 bool CookieManager::HasCookies() { 469 bool has_cookies; 470 ExecCookieTaskSync(base::Bind(&CookieManager::HasCookiesAsyncHelper, 471 base::Unretained(this), 472 &has_cookies)); 473 return has_cookies; 474 } 475 476 // TODO(kristianm): Simplify this, copying the entire list around 477 // should not be needed. 478 void CookieManager::HasCookiesAsyncHelper(bool* result, 479 base::Closure complete) { 480 cookie_monster_->GetAllCookiesAsync( 481 base::Bind(&CookieManager::HasCookiesCompleted, 482 base::Unretained(this), 483 complete, 484 result)); 485 } 486 487 void CookieManager::HasCookiesCompleted(base::Closure complete, 488 bool* result, 489 const CookieList& cookies) { 490 *result = cookies.size() != 0; 491 complete.Run(); 492 } 493 494 bool CookieManager::AllowFileSchemeCookies() { 495 base::AutoLock lock(cookie_monster_lock_); 496 EnsureCookieMonsterExistsLocked(); 497 return AllowFileSchemeCookiesLocked(); 498 } 499 500 bool CookieManager::AllowFileSchemeCookiesLocked() { 501 return cookie_monster_->IsCookieableScheme(url::kFileScheme); 502 } 503 504 void CookieManager::SetAcceptFileSchemeCookies(bool accept) { 505 base::AutoLock lock(cookie_monster_lock_); 506 EnsureCookieMonsterExistsLocked(); 507 SetAcceptFileSchemeCookiesLocked(accept); 508 } 509 510 void CookieManager::SetAcceptFileSchemeCookiesLocked(bool accept) { 511 // The docs on CookieManager base class state the API must not be called after 512 // creating a CookieManager instance (which contradicts its own internal 513 // implementation) but this code does rely on the essence of that comment, as 514 // the monster will DCHECK here if it has already been lazy initialized (i.e. 515 // if cookies have been read or written from the store). If that turns out to 516 // be a problemin future, it looks like it maybe possible to relax the DCHECK. 517 cookie_monster_->SetEnableFileScheme(accept); 518 } 519 520 } // namespace 521 522 static void SetShouldAcceptCookies(JNIEnv* env, jobject obj, jboolean accept) { 523 CookieManager::GetInstance()->SetShouldAcceptCookies(accept); 524 } 525 526 static jboolean GetShouldAcceptCookies(JNIEnv* env, jobject obj) { 527 return CookieManager::GetInstance()->GetShouldAcceptCookies(); 528 } 529 530 static void SetCookie(JNIEnv* env, 531 jobject obj, 532 jstring url, 533 jstring value, 534 jobject java_callback) { 535 GURL host(ConvertJavaStringToUTF16(env, url)); 536 std::string cookie_value(ConvertJavaStringToUTF8(env, value)); 537 scoped_ptr<BoolCookieCallbackHolder> callback( 538 new BoolCookieCallbackHolder(env, java_callback)); 539 CookieManager::GetInstance()->SetCookie(host, cookie_value, callback.Pass()); 540 } 541 542 static void SetCookieSync(JNIEnv* env, 543 jobject obj, 544 jstring url, 545 jstring value) { 546 GURL host(ConvertJavaStringToUTF16(env, url)); 547 std::string cookie_value(ConvertJavaStringToUTF8(env, value)); 548 549 CookieManager::GetInstance()->SetCookieSync(host, cookie_value); 550 } 551 552 static jstring GetCookie(JNIEnv* env, jobject obj, jstring url) { 553 GURL host(ConvertJavaStringToUTF16(env, url)); 554 555 return base::android::ConvertUTF8ToJavaString( 556 env, 557 CookieManager::GetInstance()->GetCookie(host)).Release(); 558 } 559 560 static void RemoveSessionCookies(JNIEnv* env, 561 jobject obj, 562 jobject java_callback) { 563 scoped_ptr<BoolCookieCallbackHolder> callback( 564 new BoolCookieCallbackHolder(env, java_callback)); 565 CookieManager::GetInstance()->RemoveSessionCookies(callback.Pass()); 566 } 567 568 static void RemoveSessionCookiesSync(JNIEnv* env, jobject obj) { 569 CookieManager::GetInstance()->RemoveSessionCookiesSync(); 570 } 571 572 static void RemoveAllCookies(JNIEnv* env, jobject obj, jobject java_callback) { 573 scoped_ptr<BoolCookieCallbackHolder> callback( 574 new BoolCookieCallbackHolder(env, java_callback)); 575 CookieManager::GetInstance()->RemoveAllCookies(callback.Pass()); 576 } 577 578 static void RemoveAllCookiesSync(JNIEnv* env, jobject obj) { 579 CookieManager::GetInstance()->RemoveAllCookiesSync(); 580 } 581 582 static void RemoveExpiredCookies(JNIEnv* env, jobject obj) { 583 CookieManager::GetInstance()->RemoveExpiredCookies(); 584 } 585 586 static void FlushCookieStore(JNIEnv* env, jobject obj) { 587 CookieManager::GetInstance()->FlushCookieStore(); 588 } 589 590 static jboolean HasCookies(JNIEnv* env, jobject obj) { 591 return CookieManager::GetInstance()->HasCookies(); 592 } 593 594 static jboolean AllowFileSchemeCookies(JNIEnv* env, jobject obj) { 595 return CookieManager::GetInstance()->AllowFileSchemeCookies(); 596 } 597 598 static void SetAcceptFileSchemeCookies(JNIEnv* env, jobject obj, 599 jboolean accept) { 600 return CookieManager::GetInstance()->SetAcceptFileSchemeCookies(accept); 601 } 602 603 scoped_refptr<net::CookieStore> CreateCookieStore( 604 AwBrowserContext* browser_context) { 605 return CookieManager::GetInstance()->GetCookieStore(); 606 } 607 608 bool RegisterCookieManager(JNIEnv* env) { 609 return RegisterNativesImpl(env); 610 } 611 612 } // android_webview namespace 613