Bug 1782399 - InitAsyncIterator needs to have an ErrorResult parameter. r=edgar

Differential Revision: https://phabricator.services.mozilla.com/D155418

dom/bindings/Codegen.py

@@ -22142,38 +22142,42 @@ class CGIterableMethodGenerator(CGGeneric):
                 ),
             )
             return
+
         if descriptor.interface.isIterable():
-            CGGeneric.__init__(
-                self,
-                fill(
-                    """
-                typedef ${iterClass} itrType;
-                RefPtr<itrType> result(new itrType(self,
-                                                   itrType::IteratorType::${itrMethod},
-                                                   &${ifaceName}Iterator_Binding::Wrap));
-                """,
-                    iterClass=iteratorNativeType(descriptor),
-                    ifaceName=descriptor.interface.identifier.name,
-                    itrMethod=methodName.title(),
-                ),
-            )
+            binding = descriptor.interface.identifier.name + "Iterator_Binding"
+            init = ""
         else:
             assert descriptor.interface.isAsyncIterable()
-            CGGeneric.__init__(
-                self,
-                fill(
-                    """
+
+            binding = descriptor.interface.identifier.name + "AsyncIterator_Binding"
+            init = fill(
+                """
+                {
+                  ErrorResult initError;
+                  self->InitAsyncIterator(result.get(), initError);
+                  if (initError.MaybeSetPendingException(cx, "Asynchronous iterator initialization steps for ${ifaceName} failed")) {
+                    return false;
+                  }
+                }
+                """,
+                ifaceName=descriptor.interface.identifier.name,
+            )
+        CGGeneric.__init__(
+            self,
+            fill(
+                """
                 typedef ${iterClass} itrType;
                 RefPtr<itrType> result(new itrType(self,
                                                    itrType::IteratorType::${itrMethod},
-                                                   &${ifaceName}AsyncIterator_Binding::Wrap));
-                self->InitAsyncIterator(result.get());
+                                                   &${binding}::Wrap));
+                $*{init}
                 """,
-                    iterClass=iteratorNativeType(descriptor),
-                    ifaceName=descriptor.interface.identifier.name,
-                    itrMethod=methodName.title(),
-                ),
-            )
+                iterClass=iteratorNativeType(descriptor),
+                itrMethod=methodName.title(),
+                binding=binding,
+                init=init,
+            ),
+        )
 
 
 def getObservableArrayBackingObject(descriptor, attr, errorReturn="return false;\n"):

dom/bindings/test/TestInterfaceAsyncIterableDouble.cpp

@@ -54,7 +54,8 @@ nsPIDOMWindowInner* TestInterfaceAsyncIterableDouble::GetParentObject() const {
   return mParent;
 }
 
-void TestInterfaceAsyncIterableDouble::InitAsyncIterator(Iterator* aIterator) {
+void TestInterfaceAsyncIterableDouble::InitAsyncIterator(Iterator* aIterator,
+                                                         ErrorResult& aError) {
   UniquePtr<IteratorData> data(new IteratorData(0));
   aIterator->SetData((void*)data.release());
 }

dom/bindings/test/TestInterfaceAsyncIterableDouble.h

@@ -39,7 +39,7 @@ class TestInterfaceAsyncIterableDouble final : public nsISupports,
       const GlobalObject& aGlobal, ErrorResult& rv);
 
   using Iterator = AsyncIterableIterator<TestInterfaceAsyncIterableDouble>;
-  void InitAsyncIterator(Iterator* aIterator);
+  void InitAsyncIterator(Iterator* aIterator, ErrorResult& aError);
   void DestroyAsyncIterator(Iterator* aIterator);
   already_AddRefed<Promise> GetNextPromise(JSContext* aCx, Iterator* aIterator,
                                            ErrorResult& aRv);

dom/bindings/test/TestInterfaceAsyncIterableDoubleUnion.cpp

@@ -61,7 +61,7 @@ nsPIDOMWindowInner* TestInterfaceAsyncIterableDoubleUnion::GetParentObject()
 }
 
 void TestInterfaceAsyncIterableDoubleUnion::InitAsyncIterator(
-    Iterator* aIterator) {
+    Iterator* aIterator, ErrorResult& aError) {
   UniquePtr<IteratorData> data(new IteratorData(0));
   aIterator->SetData((void*)data.release());
 }

dom/bindings/test/TestInterfaceAsyncIterableDoubleUnion.h

@@ -39,7 +39,7 @@ class TestInterfaceAsyncIterableDoubleUnion final : public nsISupports,
       const GlobalObject& aGlobal, ErrorResult& rv);
 
   using Iterator = AsyncIterableIterator<TestInterfaceAsyncIterableDoubleUnion>;
-  void InitAsyncIterator(Iterator* aIterator);
+  void InitAsyncIterator(Iterator* aIterator, ErrorResult& aError);
   void DestroyAsyncIterator(Iterator* aIterator);
   already_AddRefed<Promise> GetNextPromise(JSContext* aCx, Iterator* aIterator,
                                            ErrorResult& aRv);

dom/bindings/test/TestInterfaceAsyncIterableSingle.cpp

@@ -23,13 +23,14 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TestInterfaceAsyncIterableSingle)
 NS_INTERFACE_MAP_END
 
 TestInterfaceAsyncIterableSingle::TestInterfaceAsyncIterableSingle(
-    nsPIDOMWindowInner* aParent)
-    : mParent(aParent) {}
+    nsPIDOMWindowInner* aParent, bool aFailToInit)
+    : mParent(aParent), mFailToInit(aFailToInit) {}
 
 // static
 already_AddRefed<TestInterfaceAsyncIterableSingle>
-TestInterfaceAsyncIterableSingle::Constructor(const GlobalObject& aGlobal,
-                                              ErrorResult& aRv) {
+TestInterfaceAsyncIterableSingle::Constructor(
+    const GlobalObject& aGlobal,
+    const TestInterfaceAsyncIterableSingleOptions& aOptions, ErrorResult& aRv) {
   nsCOMPtr<nsPIDOMWindowInner> window =
       do_QueryInterface(aGlobal.GetAsSupports());
   if (!window) {
@@ -38,7 +39,7 @@ TestInterfaceAsyncIterableSingle::Constructor(const GlobalObject& aGlobal,
   }
 
   RefPtr<TestInterfaceAsyncIterableSingle> r =
-      new TestInterfaceAsyncIterableSingle(window);
+      new TestInterfaceAsyncIterableSingle(window, aOptions.mFailToInit);
   return r.forget();
 }
 
@@ -51,7 +52,13 @@ nsPIDOMWindowInner* TestInterfaceAsyncIterableSingle::GetParentObject() const {
   return mParent;
 }
 
-void TestInterfaceAsyncIterableSingle::InitAsyncIterator(Iterator* aIterator) {
+void TestInterfaceAsyncIterableSingle::InitAsyncIterator(Iterator* aIterator,
+                                                         ErrorResult& aError) {
+  if (mFailToInit) {
+    aError.ThrowTypeError("Caller asked us to fail");
+    return;
+  }
+
   UniquePtr<IteratorData> data(new IteratorData(0));
   aIterator->SetData((void*)data.release());
 }

dom/bindings/test/TestInterfaceAsyncIterableSingle.h

@@ -21,6 +21,7 @@ class ErrorResult;
 namespace dom {
 
 class GlobalObject;
+struct TestInterfaceAsyncIterableSingleOptions;
 
 // Implementation of test binding for webidl iterable interfaces, using
 // primitives for value type
@@ -30,15 +31,17 @@ class TestInterfaceAsyncIterableSingle final : public nsISupports,
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(TestInterfaceAsyncIterableSingle)
 
-  explicit TestInterfaceAsyncIterableSingle(nsPIDOMWindowInner* aParent);
+  TestInterfaceAsyncIterableSingle(nsPIDOMWindowInner* aParent,
+                                   bool aFailToInit);
   nsPIDOMWindowInner* GetParentObject() const;
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
   static already_AddRefed<TestInterfaceAsyncIterableSingle> Constructor(
-      const GlobalObject& aGlobal, ErrorResult& rv);
+      const GlobalObject& aGlobal,
+      const TestInterfaceAsyncIterableSingleOptions& aOptions, ErrorResult& rv);
 
   using Iterator = AsyncIterableIterator<TestInterfaceAsyncIterableSingle>;
-  void InitAsyncIterator(Iterator* aIterator);
+  void InitAsyncIterator(Iterator* aIterator, ErrorResult& aError);
   void DestroyAsyncIterator(Iterator* aIterator);
   already_AddRefed<Promise> GetNextPromise(JSContext* aCx, Iterator* aIterator,
                                            ErrorResult& aRv);
@@ -59,6 +62,7 @@ class TestInterfaceAsyncIterableSingle final : public nsISupports,
   void ResolvePromise(IteratorData* aData);
 
   nsCOMPtr<nsPIDOMWindowInner> mParent;
+  bool mFailToInit;
 };
 
 }  // namespace dom

dom/bindings/test/test_async_iterable.html

@@ -18,7 +18,20 @@ async function test_data_single() {
   info(`AsyncIterableSingle: Testing simple iterable creation and functionality`);
 
   // eslint-disable-next-line no-undef
-  let itr = new TestInterfaceAsyncIterableSingle();
+  let itr = new TestInterfaceAsyncIterableSingle({ failToInit: true });
+  let initFailed = false;
+  try {
+    itr.values();
+  } catch (e) {
+    initFailed = true;
+  }
+  ok(initFailed,
+     "AsyncIterableSingle: A failure in asynchronous iterator initialization " +
+     "steps should propagate to the caller of the asynchronous iterator's " +
+     "constructor.");
+
+  // eslint-disable-next-line no-undef
+  itr = new TestInterfaceAsyncIterableSingle();
   is(itr.values, itr[Symbol.asyncIterator],
     `AsyncIterableSingle: Should be using @@asyncIterator for 'values'`);
 

dom/webidl/TestInterfaceJSMaplikeSetlikeIterable.webidl

@@ -96,11 +96,15 @@ interface TestInterfaceIterableDoubleUnion {
   iterable<DOMString, (DOMString or long)>;
 };
 
+dictionary TestInterfaceAsyncIterableSingleOptions {
+  boolean failToInit = false;
+};
+
 [Pref="dom.expose_test_interfaces",
  Exposed=Window]
 interface TestInterfaceAsyncIterableSingle {
   [Throws]
-  constructor();
+  constructor(optional TestInterfaceAsyncIterableSingleOptions options = {});
 
   async iterable<long>;
 };