BASELINE: Update Chromium to 78.0.3904.130

Change-Id: If185e0c0061b3437531c97c9c8c78f239352a68b
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 48 insertions, 36 deletions

diff --git a/chromium/base/task/promise/helpers_unittest.cc b/chromium/base/task/promise/helpers_unittest.cc
index a8fe61dd3af..afdc9e7079e 100644
--- a/chromium/base/task/promise/helpers_unittest.cc
+++ b/chromium/base/task/promise/helpers_unittest.cc
@@ -169,92 +169,103 @@ TEST(PromiseCombiner, NoResolveAndNoReject2) {
 }
 
 TEST(EmplaceHelper, EmplacePromiseResult) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
-  scoped_refptr<AbstractPromise> reject = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> resolve =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
+  scoped_refptr<AbstractPromise> reject =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanReject(true).SetRejectPolicy(
+          RejectPolicy::kCatchNotRequired);
 
   EmplaceHelper<Resolved<int>, Rejected<std::string>>::Emplace(
       resolve.get(), PromiseResult<int, std::string>(123));
   EmplaceHelper<Resolved<int>, Rejected<std::string>>::Emplace(
       reject.get(), PromiseResult<int, std::string>("Oh no!"));
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(resolve->value()).value, 123);
-  EXPECT_EQ(unique_any_cast<Rejected<std::string>>(reject->value()).value,
-            "Oh no!");
+  EXPECT_EQ(resolve->value().Get<Resolved<int>>()->value, 123);
+  EXPECT_EQ(reject->value().Get<Rejected<std::string>>()->value, "Oh no!");
 }
 
 TEST(EmplaceHelper, EmplacePromise) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> promise =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
   scoped_refptr<AbstractPromise> curried = DoNothingPromiseBuilder(FROM_HERE);
 
   EmplaceHelper<Resolved<int>, Rejected<NoReject>>::Emplace(
-      resolve.get(), Promise<int>(std::move(curried)));
+      promise.get(), Promise<int>(std::move(curried)));
 
-  EXPECT_TRUE(resolve->IsResolvedWithPromise());
+  EXPECT_TRUE(promise->IsResolvedWithPromise());
 }
 
 TEST(EmplaceHelper, NakedType) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> promise =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
 
-  EmplaceHelper<Resolved<int>, Rejected<NoReject>>::Emplace(resolve.get(), 123);
+  EmplaceHelper<Resolved<int>, Rejected<NoReject>>::Emplace(promise.get(), 123);
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(resolve->value()).value, 123);
+  EXPECT_EQ(promise->value().template Get<Resolved<int>>()->value, 123);
 }
 
 TEST(EmplaceHelper, ReferenceType) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> promise =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
 
   int a = 12345;
 
   EmplaceHelper<Resolved<int&>, Rejected<NoReject>>::Emplace<int&>(
-      resolve.get(), a);
+      promise.get(), a);
 
-  EXPECT_EQ(unique_any_cast<Resolved<int&>>(resolve->value()).value, 12345);
+  EXPECT_EQ(promise->value().template Get<Resolved<int&>>()->value, 12345);
 }
 
 TEST(EmplaceHelper, ResolvedInt) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> promise =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
 
-  EmplaceHelper<Resolved<int>, Rejected<NoReject>>::Emplace(resolve.get(),
+  EmplaceHelper<Resolved<int>, Rejected<NoReject>>::Emplace(promise.get(),
                                                             Resolved<int>(123));
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(resolve->value()).value, 123);
+  EXPECT_EQ(promise->value().template Get<Resolved<int>>()->value, 123);
 }
 
 TEST(EmplaceHelper, RejectedString) {
-  scoped_refptr<AbstractPromise> resolve = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> promise =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanReject(true).SetRejectPolicy(
+          RejectPolicy::kCatchNotRequired);
 
   EmplaceHelper<Resolved<void>, Rejected<std::string>>::Emplace(
-      resolve.get(), Rejected<std::string>("Whoops!"));
+      promise.get(), Rejected<std::string>("Whoops!"));
 
-  EXPECT_EQ(unique_any_cast<Rejected<std::string>>(resolve->value()).value,
+  EXPECT_EQ(promise->value().template Get<Rejected<std::string>>()->value,
             "Whoops!");
 }
 
 TEST(RunHelper, CallbackVoidArgumentIntResult) {
   scoped_refptr<AbstractPromise> arg = DoNothingPromiseBuilder(FROM_HERE);
-  scoped_refptr<AbstractPromise> result = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> result =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
 
   RunHelper<OnceCallback<int()>, Resolved<void>, Resolved<int>,
             Rejected<std::string>>::Run(BindOnce([]() { return 123; }),
                                         arg.get(), result.get());
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(result->value()).value, 123);
+  EXPECT_EQ(result->value().template Get<Resolved<int>>()->value, 123);
 }
 
 TEST(RunHelper, CallbackVoidArgumentVoidResult) {
   scoped_refptr<AbstractPromise> arg = DoNothingPromiseBuilder(FROM_HERE);
-  scoped_refptr<AbstractPromise> result = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> result =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
 
   RunHelper<OnceCallback<void()>, Resolved<void>, Resolved<void>,
             Rejected<std::string>>::Run(BindOnce([]() {}), arg.get(),
                                         result.get());
 
-  EXPECT_EQ(result->value().type(), TypeId::From<Resolved<void>>());
+  EXPECT_TRUE(result->value().ContainsResolved());
 }
 
 TEST(RunHelper, CallbackIntArgumentIntResult) {
   scoped_refptr<AbstractPromise> arg = DoNothingPromiseBuilder(FROM_HERE);
-  scoped_refptr<AbstractPromise> result = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> result =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
   arg->emplace(Resolved<int>(123));
 
   RunHelper<OnceCallback<int(int)>, Resolved<int>, Resolved<int>,
@@ -263,12 +274,13 @@ TEST(RunHelper, CallbackIntArgumentIntResult) {
                                         }),
                                         arg.get(), result.get());
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(result->value()).value, 124);
+  EXPECT_EQ(result->value().template Get<Resolved<int>>()->value, 124);
 }
 
 TEST(RunHelper, CallbackIntArgumentArgumentVoidResult) {
   scoped_refptr<AbstractPromise> arg = DoNothingPromiseBuilder(FROM_HERE);
-  scoped_refptr<AbstractPromise> result = DoNothingPromiseBuilder(FROM_HERE);
+  scoped_refptr<AbstractPromise> result =
+      DoNothingPromiseBuilder(FROM_HERE).SetCanResolve(true);
   arg->emplace(Resolved<int>(123));
 
   int value;
@@ -279,7 +291,7 @@ TEST(RunHelper, CallbackIntArgumentArgumentVoidResult) {
                                         arg.get(), result.get());
 
   EXPECT_EQ(value, 123);
-  EXPECT_EQ(result->value().type(), TypeId::From<Resolved<void>>());
+  EXPECT_TRUE(result->value().ContainsResolved());
 }
 
 TEST(PromiseCallbackHelper, GetResolveCallback) {
@@ -291,7 +303,7 @@ TEST(PromiseCallbackHelper, GetResolveCallback) {
 
   std::move(resolve_cb).Run(1234);
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(promise->value()).value, 1234);
+  EXPECT_EQ(promise->value().template Get<Resolved<int>>()->value, 1234);
 }
 
 TEST(PromiseCallbackHelper, GetResolveReferenceCallback) {
@@ -304,7 +316,7 @@ TEST(PromiseCallbackHelper, GetResolveReferenceCallback) {
 
   std::move(resolve_cb).Run(foo);
 
-  EXPECT_EQ(&unique_any_cast<Resolved<int&>>(promise->value()).value, &foo);
+  EXPECT_EQ(&promise->value().template Get<Resolved<int&>>()->value, &foo);
 }
 
 TEST(PromiseCallbackHelper, GetRejectCallback) {
@@ -317,7 +329,7 @@ TEST(PromiseCallbackHelper, GetRejectCallback) {
 
   std::move(reject_cb).Run(1234);
 
-  EXPECT_EQ(unique_any_cast<Rejected<int>>(promise->value()).value, 1234);
+  EXPECT_EQ(promise->value().template Get<Rejected<int>>()->value, 1234);
 }
 
 TEST(PromiseCallbackHelper, GetRejectReferenceCallback) {
@@ -331,7 +343,7 @@ TEST(PromiseCallbackHelper, GetRejectReferenceCallback) {
 
   std::move(reject_cb).Run(foo);
 
-  EXPECT_EQ(&unique_any_cast<Rejected<int&>>(promise->value()).value, &foo);
+  EXPECT_EQ(&promise->value().template Get<Rejected<int&>>()->value, &foo);
 }
 
 TEST(PromiseCallbackHelper, GetRepeatingResolveCallback) {
@@ -344,7 +356,7 @@ TEST(PromiseCallbackHelper, GetRepeatingResolveCallback) {
 
   resolve_cb.Run(1234);
 
-  EXPECT_EQ(unique_any_cast<Resolved<int>>(promise->value()).value, 1234);
+  EXPECT_EQ(promise->value().template Get<Resolved<int>>()->value, 1234);
 
   // Can't run |resolve_cb| more than once.
   EXPECT_DCHECK_DEATH({ resolve_cb.Run(1234); });
@@ -361,7 +373,7 @@ TEST(PromiseCallbackHelper, GetRepeatingResolveReferenceCallback) {
 
   resolve_cb.Run(foo);
 
-  EXPECT_EQ(&unique_any_cast<Resolved<int&>>(promise->value()).value, &foo);
+  EXPECT_EQ(&promise->value().template Get<Resolved<int&>>()->value, &foo);
 
   // Can't run |resolve_cb| more than once.
   EXPECT_DCHECK_DEATH({ resolve_cb.Run(foo); });
@@ -378,7 +390,7 @@ TEST(PromiseCallbackHelper, GetRepeatingRejectCallback) {
 
   reject_cb.Run(1234);
 
-  EXPECT_EQ(unique_any_cast<Rejected<int>>(promise->value()).value, 1234);
+  EXPECT_EQ(promise->value().template Get<Rejected<int>>()->value, 1234);
 
   // Can't run |reject_cb| more than once.
   EXPECT_DCHECK_DEATH({ reject_cb.Run(1234); });
@@ -396,7 +408,7 @@ TEST(PromiseCallbackHelper, GetRepeatingRejectReferenceCallback) {
 
   reject_cb.Run(foo);
 
-  EXPECT_EQ(&unique_any_cast<Rejected<int&>>(promise->value()).value, &foo);
+  EXPECT_EQ(&promise->value().template Get<Rejected<int&>>()->value, &foo);
 
   // Can't run |reject_cb| more than once.
   EXPECT_DCHECK_DEATH({ reject_cb.Run(foo); });