From c551f43206405019121bd2b2c93714319a0a3300 Mon Sep 17 00:00:00 2001
From: Allan Sandfeld Jensen <allan.jensen@qt.io>
Date: Thu, 23 Jan 2020 17:21:03 +0100
Subject: BASELINE: Update Chromium to 79.0.3945.139

Change-Id: I336b7182fab9bca80b709682489c07db112eaca5
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
---
 .../base/task/promise/then_and_catch_executor.h    | 87 ++++++++++++----------
 1 file changed, 49 insertions(+), 38 deletions(-)

(limited to 'chromium/base/task/promise/then_and_catch_executor.h')

diff --git a/chromium/base/task/promise/then_and_catch_executor.h b/chromium/base/task/promise/then_and_catch_executor.h
index 56d30ba2a11..7668fc1fbcb 100644
--- a/chromium/base/task/promise/then_and_catch_executor.h
+++ b/chromium/base/task/promise/then_and_catch_executor.h
@@ -17,11 +17,11 @@ namespace internal {
 // Exists to reduce template bloat.
 class BASE_EXPORT ThenAndCatchExecutorCommon {
  public:
-  ThenAndCatchExecutorCommon(internal::CallbackBase&& resolve_executor,
-                             internal::CallbackBase&& reject_executor) noexcept
-      : resolve_callback_(std::move(resolve_executor)),
-        reject_callback_(std::move(reject_executor)) {
-    DCHECK(!resolve_callback_.is_null() || !reject_callback_.is_null());
+  ThenAndCatchExecutorCommon(internal::CallbackBase&& then_callback,
+                             internal::CallbackBase&& catch_callback) noexcept
+      : then_callback_(std::move(then_callback)),
+        catch_callback_(std::move(catch_callback)) {
+    DCHECK(!then_callback_.is_null() || !catch_callback_.is_null());
   }
 
   ~ThenAndCatchExecutorCommon() = default;
@@ -44,24 +44,23 @@ class BASE_EXPORT ThenAndCatchExecutorCommon {
                                   AbstractPromise* arg,
                                   AbstractPromise* result);
 
-  CallbackBase resolve_callback_;
-  CallbackBase reject_callback_;
+  CallbackBase then_callback_;
+  CallbackBase catch_callback_;
 };
 
 // Tag signals no callback which is used to eliminate dead code.
 struct NoCallback {};
 
-template <typename ResolveOnceCallback,
-          typename RejectOnceCallback,
+template <typename ThenOnceCallback,
+          typename CatchOnceCallback,
           typename ArgResolve,
           typename ArgReject,
           typename ResolveStorage,
           typename RejectStorage>
 class ThenAndCatchExecutor {
  public:
-  using ResolveReturnT =
-      typename CallbackTraits<ResolveOnceCallback>::ReturnType;
-  using RejectReturnT = typename CallbackTraits<RejectOnceCallback>::ReturnType;
+  using ThenReturnT = typename CallbackTraits<ThenOnceCallback>::ReturnType;
+  using CatchReturnT = typename CallbackTraits<CatchOnceCallback>::ReturnType;
   using PrerequisiteCouldResolve =
       std::integral_constant<bool,
                              !std::is_same<ArgResolve, NoCallback>::value>;
@@ -69,8 +68,8 @@ class ThenAndCatchExecutor {
       std::integral_constant<bool, !std::is_same<ArgReject, NoCallback>::value>;
 
   ThenAndCatchExecutor(CallbackBase&& resolve_callback,
-                       CallbackBase&& reject_callback) noexcept
-      : common_(std::move(resolve_callback), std::move(reject_callback)) {}
+                       CallbackBase&& catch_callback) noexcept
+      : common_(std::move(resolve_callback), std::move(catch_callback)) {}
 
   bool IsCancelled() const { return common_.IsCancelled(); }
 
@@ -85,29 +84,29 @@ class ThenAndCatchExecutor {
 
 #if DCHECK_IS_ON()
   PromiseExecutor::ArgumentPassingType ResolveArgumentPassingType() const {
-    return common_.resolve_callback_.is_null()
+    return common_.then_callback_.is_null()
                ? PromiseExecutor::ArgumentPassingType::kNoCallback
-               : CallbackTraits<ResolveOnceCallback>::argument_passing_type;
+               : CallbackTraits<ThenOnceCallback>::argument_passing_type;
   }
 
   PromiseExecutor::ArgumentPassingType RejectArgumentPassingType() const {
-    return common_.reject_callback_.is_null()
+    return common_.catch_callback_.is_null()
                ? PromiseExecutor::ArgumentPassingType::kNoCallback
-               : CallbackTraits<RejectOnceCallback>::argument_passing_type;
+               : CallbackTraits<CatchOnceCallback>::argument_passing_type;
   }
 
   bool CanResolve() const {
-    return (!common_.resolve_callback_.is_null() &&
-            PromiseCallbackTraits<ResolveReturnT>::could_resolve) ||
-           (!common_.reject_callback_.is_null() &&
-            PromiseCallbackTraits<RejectReturnT>::could_resolve);
+    return (!common_.then_callback_.is_null() &&
+            PromiseCallbackTraits<ThenReturnT>::could_resolve) ||
+           (!common_.catch_callback_.is_null() &&
+            PromiseCallbackTraits<CatchReturnT>::could_resolve);
   }
 
   bool CanReject() const {
-    return (!common_.resolve_callback_.is_null() &&
-            PromiseCallbackTraits<ResolveReturnT>::could_reject) ||
-           (!common_.reject_callback_.is_null() &&
-            PromiseCallbackTraits<RejectReturnT>::could_reject);
+    return (!common_.then_callback_.is_null() &&
+            PromiseCallbackTraits<ThenReturnT>::could_reject) ||
+           (!common_.catch_callback_.is_null() &&
+            PromiseCallbackTraits<CatchReturnT>::could_reject);
   }
 #endif
 
@@ -121,8 +120,8 @@ class ThenAndCatchExecutor {
 
   static void ExecuteCatch(AbstractPromise* prerequisite,
                            AbstractPromise* promise,
-                           CallbackBase* reject_callback) {
-    ExecuteCatchInternal(prerequisite, promise, reject_callback,
+                           CallbackBase* catch_callback) {
+    ExecuteCatchInternal(prerequisite, promise, catch_callback,
                          PrerequisiteCouldReject());
   }
 
@@ -130,10 +129,16 @@ class ThenAndCatchExecutor {
                                   AbstractPromise* promise,
                                   CallbackBase* resolve_callback,
                                   std::true_type can_resolve) {
-    RunHelper<ResolveOnceCallback, Resolved<ArgResolve>, ResolveStorage,
-              RejectStorage>::
-        Run(std::move(*static_cast<ResolveOnceCallback*>(resolve_callback)),
-            prerequisite, promise);
+    // Internally RunHelper uses const RepeatingCallback<>& to avoid the
+    // binary size overhead of moving a scoped_refptr<> about.  We respect
+    // the onceness of the callback and RunHelper will overwrite the callback
+    // with the result.
+    using RepeatingThenCB =
+        typename ToRepeatingCallback<ThenOnceCallback>::value;
+    RunHelper<
+        RepeatingThenCB, Resolved<ArgResolve>, ResolveStorage,
+        RejectStorage>::Run(*static_cast<RepeatingThenCB*>(resolve_callback),
+                            prerequisite, promise);
   }
 
   static void ExecuteThenInternal(AbstractPromise* prerequisite,
@@ -145,17 +150,23 @@ class ThenAndCatchExecutor {
 
   static void ExecuteCatchInternal(AbstractPromise* prerequisite,
                                    AbstractPromise* promise,
-                                   CallbackBase* reject_callback,
+                                   CallbackBase* catch_callback,
                                    std::true_type can_reject) {
-    RunHelper<RejectOnceCallback, Rejected<ArgReject>, ResolveStorage,
-              RejectStorage>::
-        Run(std::move(*static_cast<RejectOnceCallback*>(reject_callback)),
-            prerequisite, promise);
+    // Internally RunHelper uses const RepeatingCallback<>& to avoid the
+    // binary size overhead of moving a scoped_refptr<> about.  We respect
+    // the onceness of the callback and RunHelper will overwrite the callback
+    // with the result.
+    using RepeatingCatchCB =
+        typename ToRepeatingCallback<CatchOnceCallback>::value;
+    RunHelper<
+        RepeatingCatchCB, Rejected<ArgReject>, ResolveStorage,
+        RejectStorage>::Run(*static_cast<RepeatingCatchCB*>(catch_callback),
+                            prerequisite, promise);
   }
 
   static void ExecuteCatchInternal(AbstractPromise* prerequisite,
                                    AbstractPromise* promise,
-                                   CallbackBase* reject_callback,
+                                   CallbackBase* catch_callback,
                                    std::false_type can_reject) {
     // |prerequisite| can't reject so don't generate dead code.
   }
-- 
cgit v1.2.3