[WebView] Move files from native to browser

android_webview/browser/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/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 "base/android/jni_string.h"
 #include "base/android/path_utils.h"
@@ skipping 229 matching lines @@
 CookieManager::CookieManager()
     : accept_file_scheme_cookies_(kDefaultFileSchemeAllowed),
       cookie_store_created_(false),
       cookie_store_client_thread_("CookieMonsterClient"),
       cookie_store_backend_thread_("CookieMonsterBackend") {
   cookie_store_client_thread_.Start();
   cookie_store_backend_thread_.Start();
   cookie_store_task_runner_ = cookie_store_client_thread_.task_runner();
 }
 
-CookieManager::~CookieManager() {
-}
+CookieManager::~CookieManager() {}
 
 // Executes the |task| on |cookie_store_task_runner_| and waits for it to
 // complete before returning.
 //
 // To execute a CookieTask synchronously you must arrange for Signal to be
 // called on the waitable event at some point. You can call the bool or int
 // versions of ExecCookieTaskSync, these will supply the caller with a dummy
 // callback which takes an int/bool, throws it away and calls Signal.
 // 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.
@@ skipping 92 matching lines @@
   return AwCookieAccessPolicy::GetInstance()->GetShouldAcceptCookies();
 }
 
 void CookieManager::SetCookie(
     const GURL& host,
     const std::string& cookie_value,
     std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::SetCookieHelper,
-                            base::Unretained(this),
-                            host,
-                            cookie_value,
+                            base::Unretained(this), host, cookie_value,
                             callback));
 }
 
 void CookieManager::SetCookieSync(const GURL& host,
-                              const std::string& cookie_value) {
+                                  const std::string& cookie_value) {
   ExecCookieTaskSync(base::Bind(&CookieManager::SetCookieHelper,
-                            base::Unretained(this),
-                            host,
-                            cookie_value));
+                                base::Unretained(this), host, cookie_value));
 }
 
-void CookieManager::SetCookieHelper(
-    const GURL& host,
-    const std::string& value,
-    const BoolCallback callback) {
+void CookieManager::SetCookieHelper(const GURL& host,
+                                    const std::string& value,
+                                    const BoolCallback callback) {
   net::CookieOptions options;
   options.set_include_httponly();
 
   // Log message for catching strict secure cookies related bugs.
   // TODO(sgurun) temporary. Add UMA stats to monitor, and remove afterwards.
   if (host.is_valid() &&
       (!host.has_scheme() || host.SchemeIs(url::kHttpScheme))) {
     net::ParsedCookie parsed_cookie(value);
     if (parsed_cookie.IsValid() && parsed_cookie.IsSecure()) {
       LOG(WARNING) << "Strict Secure Cookie policy does not allow setting a "
                       "secure cookie for "
                    << host.spec();
       GURL::Replacements replace_host;
       replace_host.SetSchemeStr("https");
       GURL new_host = host.ReplaceComponents(replace_host);
       GetCookieStore()->SetCookieWithOptionsAsync(new_host, value, options,
                                                   callback);
       return;
     }
   }
 
   GetCookieStore()->SetCookieWithOptionsAsync(host, value, options, callback);
 }
 
 std::string CookieManager::GetCookie(const GURL& host) {
   std::string cookie_value;
   ExecCookieTaskSync(base::Bind(&CookieManager::GetCookieValueAsyncHelper,
-                            base::Unretained(this),
-                            host,
-                            &cookie_value));
+                                base::Unretained(this), host, &cookie_value));
   return cookie_value;
 }
 
-void CookieManager::GetCookieValueAsyncHelper(
-    const GURL& host,
-    std::string* result,
-    base::Closure complete) {
+void CookieManager::GetCookieValueAsyncHelper(const GURL& host,
+                                              std::string* result,
+                                              base::Closure complete) {
   net::CookieOptions options;
   options.set_include_httponly();
 
   GetCookieStore()->GetCookiesWithOptionsAsync(
-      host, options, base::Bind(&CookieManager::GetCookieValueCompleted,
-                                base::Unretained(this), complete, result));
+      host, options,
+      base::Bind(&CookieManager::GetCookieValueCompleted,
+                 base::Unretained(this), complete, result));
 }
 
 void CookieManager::GetCookieValueCompleted(base::Closure complete,
                                             std::string* result,
                                             const std::string& value) {
   *result = value;
   complete.Run();
 }
 
 void CookieManager::RemoveSessionCookies(
     std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::RemoveSessionCookiesHelper,
-                            base::Unretained(this),
-                            callback));
+                            base::Unretained(this), callback));
 }
 
 void CookieManager::RemoveSessionCookiesSync() {
   ExecCookieTaskSync(base::Bind(&CookieManager::RemoveSessionCookiesHelper,
-                            base::Unretained(this)));
+                                base::Unretained(this)));
 }
 
-void CookieManager::RemoveSessionCookiesHelper(
-    BoolCallback callback) {
+void CookieManager::RemoveSessionCookiesHelper(BoolCallback callback) {
   GetCookieStore()->DeleteSessionCookiesAsync(
       base::Bind(&CookieManager::RemoveCookiesCompleted, base::Unretained(this),
                  callback));
 }
 
-void CookieManager::RemoveCookiesCompleted(
-    BoolCallback callback,
-    int num_deleted) {
+void CookieManager::RemoveCookiesCompleted(BoolCallback callback,
+                                           int num_deleted) {
   callback.Run(num_deleted > 0);
 }
 
 void CookieManager::RemoveAllCookies(
     std::unique_ptr<BoolCookieCallbackHolder> callback_holder) {
   BoolCallback callback =
       BoolCookieCallbackHolder::ConvertToCallback(std::move(callback_holder));
   ExecCookieTask(base::Bind(&CookieManager::RemoveAllCookiesHelper,
-                            base::Unretained(this),
-                            callback));
+                            base::Unretained(this), callback));
 }
 
 void CookieManager::RemoveAllCookiesSync() {
   ExecCookieTaskSync(base::Bind(&CookieManager::RemoveAllCookiesHelper,
-                            base::Unretained(this)));
+                                base::Unretained(this)));
 }
 
-void CookieManager::RemoveAllCookiesHelper(
-    const BoolCallback callback) {
+void CookieManager::RemoveAllCookiesHelper(const BoolCallback callback) {
   GetCookieStore()->DeleteAllAsync(
       base::Bind(&CookieManager::RemoveCookiesCompleted, base::Unretained(this),
                  callback));
 }
 
 void CookieManager::RemoveExpiredCookies() {
   // HasCookies will call GetAllCookiesAsync, which in turn will force a GC.
   HasCookies();
 }
 
 void CookieManager::FlushCookieStore() {
   ExecCookieTaskSync(base::Bind(&CookieManager::FlushCookieStoreAsyncHelper,
-                            base::Unretained(this)));
+                                base::Unretained(this)));
 }
 
-void CookieManager::FlushCookieStoreAsyncHelper(
-    base::Closure complete) {
+void CookieManager::FlushCookieStoreAsyncHelper(base::Closure complete) {
   GetCookieStore()->FlushStore(complete);
 }
 
 bool CookieManager::HasCookies() {
   bool has_cookies;
   ExecCookieTaskSync(base::Bind(&CookieManager::HasCookiesAsyncHelper,
-                            base::Unretained(this),
-                            &has_cookies));
+                                base::Unretained(this), &has_cookies));
   return has_cookies;
 }
 
 // TODO(kristianm): Simplify this, copying the entire list around
 // should not be needed.
 void CookieManager::HasCookiesAsyncHelper(bool* result,
                                           base::Closure complete) {
   GetCookieStore()->GetAllCookiesAsync(
       base::Bind(&CookieManager::HasCookiesCompleted, base::Unretained(this),
                  complete, result));
@@ skipping 64 matching lines @@
 static void RemoveSessionCookies(JNIEnv* env,
                                  const JavaParamRef<jobject>& obj,
                                  const JavaParamRef<jobject>& java_callback) {
   std::unique_ptr<BoolCookieCallbackHolder> callback(
       new BoolCookieCallbackHolder(env, java_callback));
   CookieManager::GetInstance()->RemoveSessionCookies(std::move(callback));
 }
 
 static void RemoveSessionCookiesSync(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
-    CookieManager::GetInstance()->RemoveSessionCookiesSync();
+  CookieManager::GetInstance()->RemoveSessionCookiesSync();
 }
 
 static void RemoveAllCookies(JNIEnv* env,
                              const JavaParamRef<jobject>& obj,
                              const JavaParamRef<jobject>& java_callback) {
   std::unique_ptr<BoolCookieCallbackHolder> callback(
       new BoolCookieCallbackHolder(env, java_callback));
   CookieManager::GetInstance()->RemoveAllCookies(std::move(callback));
 }
 
@@ skipping 36 matching lines @@
 
 net::CookieStore* GetCookieStore() {
   return CookieManager::GetInstance()->GetCookieStore();
 }
 
 bool RegisterCookieManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // android_webview namespace