Fixes a deadlock between shouldInterceptRequest() and getCookie()

android_webview/native/cookie_manager.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "android_webview/native/cookie_manager.h"
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_cookie_access_policy.h"
 #include "android_webview/browser/net/init_native_callback.h"
 #include "android_webview/browser/scoped_allow_wait_for_legacy_web_view_api.h"
@@ skipping 127 matching lines @@
 void GetUserDataDir(FilePath* user_data_dir) {
   if (!PathService::Get(base::DIR_ANDROID_APP_DATA, user_data_dir)) {
     NOTREACHED() << "Failed to get app data directory for Android WebView";
   }
 }
 
 class CookieManager {
  public:
   static CookieManager* GetInstance();
 
-  scoped_refptr<net::CookieStore> CreateBrowserThreadCookieStore(
-      AwBrowserContext* browser_context);
+  scoped_refptr<net::CookieStore> GetCookieStore();
 
   void SetAcceptCookie(bool accept);
   bool AcceptCookie();
   void SetAcceptThirdPartyCookie(bool accept);
   bool AcceptThirdPartyCookie();
   void SetCookie(const GURL& host,
                  const std::string& cookie_value,
                  scoped_ptr<BoolCookieCallbackHolder> callback);
   void SetCookieSync(const GURL& host,
                  const std::string& cookie_value);
@@ skipping 47 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& client_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner);
   void EnsureCookieMonsterExistsLocked();
   bool AllowFileSchemeCookiesLocked();
   void SetAcceptFileSchemeCookiesLocked(bool accept);
 
   scoped_refptr<net::CookieMonster> cookie_monster_;
   scoped_refptr<base::MessageLoopProxy> cookie_monster_proxy_;
   base::Lock cookie_monster_lock_;
 
-  // Both these threads are normally NULL. They only exist if CookieManager was
-  // accessed before Chromium was started.
   scoped_ptr<base::Thread> cookie_monster_client_thread_;
   scoped_ptr<base::Thread> cookie_monster_backend_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieManager);
 };
 
 base::LazyInstance<CookieManager>::Leaky g_lazy_instance;
 
 // static
 CookieManager* CookieManager::GetInstance() {
@@ skipping 91 matching lines @@
   completion.Wait();
 }
 
 // Executes the |task| on the |cookie_monster_proxy_| message loop.
 void CookieManager::ExecCookieTask(const base::Closure& task) {
   base::AutoLock lock(cookie_monster_lock_);
   EnsureCookieMonsterExistsLocked();
   cookie_monster_proxy_->PostTask(FROM_HERE, task);
 }
 
-scoped_refptr<net::CookieStore> CookieManager::CreateBrowserThreadCookieStore(
-    AwBrowserContext* browser_context) {
+scoped_refptr<net::CookieStore> CookieManager::GetCookieStore() {
   base::AutoLock lock(cookie_monster_lock_);
-
-  if (cookie_monster_client_thread_) {
-    // We created a cookie monster already on its own threads; we'll just keep
-    // using it rather than creating one on the normal Chromium threads.
-    // CookieMonster is threadsafe, so this is fine.
-    return cookie_monster_;
-  }
-
-  // Go ahead and create the cookie monster using the normal Chromium threads.
-  DCHECK(!cookie_monster_.get());
-  DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
-
-  FilePath user_data_dir;
-  GetUserDataDir(&user_data_dir);
-  DCHECK(browser_context->GetPath() == user_data_dir);
-
-  cookie_monster_proxy_ =
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
-  scoped_refptr<base::SequencedTaskRunner> background_task_runner =
-      BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
-          BrowserThread::GetBlockingPool()->GetSequenceToken());
-  CreateCookieMonster(user_data_dir,
-                      cookie_monster_proxy_,
-                      background_task_runner);
+  EnsureCookieMonsterExistsLocked();
   return cookie_monster_;
 }
 
 void CookieManager::SetAcceptCookie(bool accept) {
   AwCookieAccessPolicy::GetInstance()->SetGlobalAllowAccess(accept);
 }
 
 bool CookieManager::AcceptCookie() {
   return AwCookieAccessPolicy::GetInstance()->GetGlobalAllowAccess();
 }
@@ skipping 275 matching lines @@
   return CookieManager::GetInstance()->AllowFileSchemeCookies();
 }
 
 static void SetAcceptFileSchemeCookies(JNIEnv* env, jobject obj,
                                        jboolean accept) {
   return CookieManager::GetInstance()->SetAcceptFileSchemeCookies(accept);
 }
 
 scoped_refptr<net::CookieStore> CreateCookieStore(
     AwBrowserContext* browser_context) {
-  return CookieManager::GetInstance()->CreateBrowserThreadCookieStore(
-      browser_context);
+  return CookieManager::GetInstance()->GetCookieStore();
 }
 
 bool RegisterCookieManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // android_webview namespace