Shift cookie system callbacks to OnceCallback to impedance match mojo.

net/cookies/cookie_store_test_helpers.cc

 // Copyright (c) 2012 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 "net/cookies/cookie_store_test_helpers.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
@@ skipping 44 matching lines @@
 void DelayedCookieMonster::GetCookieListWithOptionsInternalCallback(
     const CookieList& cookie_list) {
   cookie_list_ = cookie_list;
   did_run_ = true;
 }
 
 void DelayedCookieMonster::SetCookieWithOptionsAsync(
     const GURL& url,
     const std::string& cookie_line,
     const CookieOptions& options,
-    const CookieMonster::SetCookiesCallback& callback) {
+    CookieMonster::SetCookiesCallback callback) {
   did_run_ = false;
   cookie_monster_->SetCookieWithOptionsAsync(
       url, cookie_line, options,
       base::Bind(&DelayedCookieMonster::SetCookiesInternalCallback,
                  base::Unretained(this)));
   DCHECK_EQ(did_run_, true);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&DelayedCookieMonster::InvokeSetCookiesCallback,
-                            base::Unretained(this), callback),
+      FROM_HERE,
+      base::BindOnce(&DelayedCookieMonster::InvokeSetCookiesCallback,
+                     base::Unretained(this), std::move(callback)),
       base::TimeDelta::FromMilliseconds(kDelayedTime));
 }
 
 void DelayedCookieMonster::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     base::Time creation_time,
     base::Time expiration_time,
     base::Time last_access_time,
     bool secure,
     bool http_only,
     CookieSameSite same_site,
     CookiePriority priority,
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   NOTREACHED();
 }
 
 void DelayedCookieMonster::SetCanonicalCookieAsync(
     std::unique_ptr<CanonicalCookie> cookie,
     bool secure_source,
     bool modify_http_only,
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   NOTREACHED();
 }
 
 void DelayedCookieMonster::GetCookiesWithOptionsAsync(
     const GURL& url,
     const CookieOptions& options,
-    const CookieMonster::GetCookiesCallback& callback) {
+    CookieMonster::GetCookiesCallback callback) {
   did_run_ = false;
   cookie_monster_->GetCookiesWithOptionsAsync(
       url, options,
       base::Bind(&DelayedCookieMonster::GetCookiesWithOptionsInternalCallback,
                  base::Unretained(this)));
   DCHECK_EQ(did_run_, true);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&DelayedCookieMonster::InvokeGetCookieStringCallback,
-                 base::Unretained(this), callback),
+      base::BindOnce(&DelayedCookieMonster::InvokeGetCookieStringCallback,
+                     base::Unretained(this), std::move(callback)),
       base::TimeDelta::FromMilliseconds(kDelayedTime));
 }
 
 void DelayedCookieMonster::GetCookieListWithOptionsAsync(
     const GURL& url,
     const CookieOptions& options,
-    const CookieMonster::GetCookieListCallback& callback) {
+    CookieMonster::GetCookieListCallback callback) {
   did_run_ = false;
   cookie_monster_->GetCookieListWithOptionsAsync(
       url, options,
       base::Bind(
           &DelayedCookieMonster::GetCookieListWithOptionsInternalCallback,
           base::Unretained(this)));
   DCHECK_EQ(did_run_, true);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&DelayedCookieMonster::InvokeGetCookieListCallback,
-                            base::Unretained(this), callback),
+      FROM_HERE,
+      base::BindOnce(&DelayedCookieMonster::InvokeGetCookieListCallback,
+                     base::Unretained(this), std::move(callback)),
       base::TimeDelta::FromMilliseconds(kDelayedTime));
 }
 
-void DelayedCookieMonster::GetAllCookiesAsync(
-    const GetCookieListCallback& callback) {
-  cookie_monster_->GetAllCookiesAsync(callback);
+void DelayedCookieMonster::GetAllCookiesAsync(GetCookieListCallback callback) {
+  cookie_monster_->GetAllCookiesAsync(std::move(callback));
 }
 
 void DelayedCookieMonster::InvokeSetCookiesCallback(
-    const CookieMonster::SetCookiesCallback& callback) {
+    CookieMonster::SetCookiesCallback callback) {
   if (!callback.is_null())
-    callback.Run(result_);
+    std::move(callback).Run(result_);
 }
 
 void DelayedCookieMonster::InvokeGetCookieStringCallback(
-    const CookieMonster::GetCookiesCallback& callback) {
+    CookieMonster::GetCookiesCallback callback) {
   if (!callback.is_null())
-    callback.Run(cookie_);
+    std::move(callback).Run(cookie_);
 }
 
 void DelayedCookieMonster::InvokeGetCookieListCallback(
-    const CookieMonster::GetCookieListCallback& callback) {
+    CookieMonster::GetCookieListCallback callback) {
   if (!callback.is_null())
-    callback.Run(cookie_list_);
+    std::move(callback).Run(cookie_list_);
 }
 
 bool DelayedCookieMonster::SetCookieWithOptions(
     const GURL& url,
     const std::string& cookie_line,
     const CookieOptions& options) {
   ADD_FAILURE();
   return false;
 }
 
 std::string DelayedCookieMonster::GetCookiesWithOptions(
     const GURL& url,
     const CookieOptions& options) {
   ADD_FAILURE();
   return std::string();
 }
 
 void DelayedCookieMonster::DeleteCookie(const GURL& url,
                                         const std::string& cookie_name) {
   ADD_FAILURE();
 }
 
 void DelayedCookieMonster::DeleteCookieAsync(const GURL& url,
                                              const std::string& cookie_name,
-                                             const base::Closure& callback) {
+                                             base::OnceClosure callback) {
   ADD_FAILURE();
 }
 
 void DelayedCookieMonster::DeleteCanonicalCookieAsync(
     const CanonicalCookie& cookie,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   ADD_FAILURE();
 }
 
 void DelayedCookieMonster::DeleteAllCreatedBetweenAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   ADD_FAILURE();
 }
 
 void DelayedCookieMonster::DeleteAllCreatedBetweenWithPredicateAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const base::Callback<bool(const CanonicalCookie&)>& predicate,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   ADD_FAILURE();
 }
 
-void DelayedCookieMonster::DeleteSessionCookiesAsync(const DeleteCallback&) {
+void DelayedCookieMonster::DeleteSessionCookiesAsync(DeleteCallback) {
   ADD_FAILURE();
 }
 
-void DelayedCookieMonster::FlushStore(const base::Closure& callback) {
+void DelayedCookieMonster::FlushStore(base::OnceClosure callback) {
   ADD_FAILURE();
 }
 
 std::unique_ptr<CookieStore::CookieChangedSubscription>
 DelayedCookieMonster::AddCallbackForCookie(
     const GURL& url,
     const std::string& name,
     const CookieChangedCallback& callback) {
   ADD_FAILURE();
   return std::unique_ptr<CookieStore::CookieChangedSubscription>();
@@ skipping 18 matching lines @@
 
 std::string CookieURLHelper::Format(const std::string& format_string) const {
   std::string new_string = format_string;
   base::ReplaceSubstringsAfterOffset(&new_string, 0, "%D",
                                      domain_and_registry_);
   base::ReplaceSubstringsAfterOffset(&new_string, 0, "%R", registry_);
   return new_string;
 }
 
 }  // namespace net