aw: Remove global AllowWait on UI thread

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 <memory>
 #include <utility>
 #include <vector>
 
 #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"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 116 matching lines @@
                  << cookie_store_path.AsUTF8Unsafe();
   }
 }
 
 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";
   }
 }
 
+}  // namespace
+
 // CookieManager creates and owns Webview's CookieStore, in addition to handling
 // calls into the CookieStore from Java.
 //
 // Since Java calls can be made on the IO Thread, and must synchronously return
 // a result, and the CookieStore API allows it to asynchronously return results,
 // the CookieStore must be run on its own thread, to prevent deadlock.
 class CookieManager {
  public:
   static CookieManager* GetInstance();
 
@@ skipping 64 matching lines @@
 
   base::Thread cookie_store_client_thread_;
   base::Thread cookie_store_backend_thread_;
 
   scoped_refptr<base::SingleThreadTaskRunner> cookie_store_task_runner_;
   std::unique_ptr<net::CookieStore> cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieManager);
 };
 
+namespace {
 base::LazyInstance<CookieManager>::Leaky g_lazy_instance;
-
-}  // namespace
+}
 
 // static
 CookieManager* CookieManager::GetInstance() {
   return g_lazy_instance.Pointer();
 }
 
 CookieManager::CookieManager()
     : accept_file_scheme_cookies_(kDefaultFileSchemeAllowed),
       cookie_store_created_(false),
       cookie_store_client_thread_("CookieMonsterClient"),
@@ skipping 16 matching lines @@
 // Alternatively you can call the version which supplies a Closure in which
 // case you must call Run on it when you want the unblock the calling code.
 //
 // Ignore a bool callback.
 void CookieManager::ExecCookieTaskSync(
     const base::Callback<void(BoolCallback)>& task) {
   WaitableEvent completion(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   ExecCookieTask(
       base::Bind(task, BoolCallbackAdapter(SignalEventClosure(&completion))));
-  ScopedAllowWaitForLegacyWebViewApi wait;
+  base::ThreadRestrictions::ScopedAllowWait wait;
   completion.Wait();
 }
 
 // Ignore an int callback.
 void CookieManager::ExecCookieTaskSync(
     const base::Callback<void(IntCallback)>& task) {
   WaitableEvent completion(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   ExecCookieTask(
       base::Bind(task, IntCallbackAdapter(SignalEventClosure(&completion))));
-  ScopedAllowWaitForLegacyWebViewApi wait;
+  base::ThreadRestrictions::ScopedAllowWait wait;
   completion.Wait();
 }
 
 // Call the supplied closure when you want to signal that the blocked code can
 // continue.
 void CookieManager::ExecCookieTaskSync(
     const base::Callback<void(base::Closure)>& task) {
   WaitableEvent completion(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   ExecCookieTask(base::Bind(task, SignalEventClosure(&completion)));
-  ScopedAllowWaitForLegacyWebViewApi wait;
+  base::ThreadRestrictions::ScopedAllowWait wait;
   completion.Wait();
 }
 
 // Executes the |task| using |cookie_store_task_runner_|.
 void CookieManager::ExecCookieTask(const base::Closure& task) {
   cookie_store_task_runner_->PostTask(FROM_HERE, task);
 }
 
 base::SingleThreadTaskRunner* CookieManager::GetCookieStoreTaskRunner() {
   return cookie_store_task_runner_.get();
@@ skipping 322 matching lines @@
 
 net::CookieStore* GetCookieStore() {
   return CookieManager::GetInstance()->GetCookieStore();
 }
 
 bool RegisterCookieManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // android_webview namespace