Backed out 6 changesets (bug 1582348) for build bustage in streams/WritableStreamOperations.cpp

Backed out changeset bb2e05de0638 (bug 1582348)
Backed out changeset c5b476005983 (bug 1582348)
Backed out changeset 0d8e86bb06d0 (bug 1582348)
Backed out changeset 7628d3f14514 (bug 1582348)
Backed out changeset 728075c80f4d (bug 1582348)
Backed out changeset 4ceb625e5eb0 (bug 1582348)

Author: dgluca

js/public/Stream.h

@@ -485,21 +485,6 @@ extern JS_PUBLIC_API bool ReadableStreamReaderReleaseLock(JSContext* cx,
 extern JS_PUBLIC_API JSObject* ReadableStreamDefaultReaderRead(
     JSContext* cx, HandleObject reader);
 
-class JS_PUBLIC_API WritableStreamUnderlyingSink {
- public:
-  virtual ~WritableStreamUnderlyingSink() {}
-
-  /**
-   * Invoked when the associated WritableStream object is finalized. The
-   * stream object is not passed as an argument, as it might not be in a
-   * valid state anymore.
-   *
-   * Note: Finalization can happen on a background thread, so the embedding
-   * must be prepared for `finalize()` to be invoked from any thread.
-   */
-  virtual void finalize() = 0;
-};
-
 }  // namespace JS
 
 #endif  // js_Stream_h

js/src/builtin/streams/MiscellaneousOperations.cpp

@@ -187,9 +187,9 @@ MOZ_MUST_USE bool js::ValidateAndNormalizeHighWaterMark(
  * The standard makes a big deal of turning JavaScript functions (grubby,
  * touched by users, covered with germs) into algorithms (pristine,
  * respectable, purposeful). We don't bother. Here we only check for errors and
- * leave `size` unchanged. Then, in ReadableStreamDefaultControllerEnqueue and
- * WritableStreamDefaultControllerGetChunkSize where this value is used, we
- * check for undefined and behave as if we had "made" an "algorithm" for it.
+ * leave `size` unchanged. Then, in ReadableStreamDefaultControllerEnqueue,
+ * where this value is used, we have to check for undefined and behave as if we
+ * had "made" an "algorithm" as described below.
  */
 MOZ_MUST_USE bool js::MakeSizeAlgorithmFromSizeFunction(JSContext* cx,
                                                         Handle<Value> size) {

js/src/builtin/streams/MiscellaneousOperations.h

@@ -78,6 +78,13 @@ extern MOZ_MUST_USE bool ValidateAndNormalizeHighWaterMark(
 
 /**
  * Streams spec, 6.3.8. MakeSizeAlgorithmFromSizeFunction ( size )
+ *
+ * The standard makes a big deal of turning JavaScript functions (grubby,
+ * touched by users, covered with germs) into algorithms (pristine,
+ * respectable, purposeful). We don't bother. Here we only check for errors and
+ * leave `size` unchanged. Then, in ReadableStreamDefaultControllerEnqueue,
+ * where this value is used, we have to check for undefined and behave as if we
+ * had "made" an "algorithm" as described below.
  */
 extern MOZ_MUST_USE bool MakeSizeAlgorithmFromSizeFunction(
     JSContext* cx, JS::Handle<JS::Value> size);

js/src/builtin/streams/ReadableStreamDefaultControllerOperations.cpp

@@ -37,7 +37,7 @@
 #include "builtin/streams/HandlerFunction-inl.h"  // js::NewHandler
 #include "vm/Compartment-inl.h"  // JS::Compartment::wrap, js::UnwrapCalleeSlot
 #include "vm/JSContext-inl.h"    // JSContext::check
-#include "vm/JSObject-inl.h"     // js::IsCallable, js::NewBuiltinClassInstance
+#include "vm/JSObject-inl.h"     // js::IsCallable
 #include "vm/Realm-inl.h"        // js::AutoRealm
 
 using js::ReadableByteStreamController;

js/src/builtin/streams/StreamController-inl.h

@@ -11,14 +11,12 @@
 
 #include "builtin/streams/StreamController.h"  // js::StreamController
 #include "builtin/streams/ReadableStreamController.h"  // js::Readable{ByteStream,StreamDefault}Controller
-#include "builtin/streams/WritableStreamDefaultController.h"  // js::WritableStreamDefaultController
 #include "vm/JSObject.h"                               // JSObject
 
 template <>
 inline bool JSObject::is<js::StreamController>() const {
   return is<js::ReadableStreamDefaultController>() ||
-         is<js::ReadableByteStreamController>() ||
-         is<js::WritableStreamDefaultController>();
+         is<js::ReadableByteStreamController>();
 }
 
 #endif  // builtin_streams_ReadableStreamController_inl_h

js/src/builtin/streams/WritableStream-inl.h

@@ -17,7 +17,6 @@
 #include "builtin/streams/ClassSpecMacro.h"  // JS_STREAMS_CLASS_SPEC
 #include "builtin/streams/MiscellaneousOperations.h"  // js::MakeSizeAlgorithmFromSizeFunction, js::ValidateAndNormalizeHighWaterMark
 #include "builtin/streams/WritableStreamDefaultControllerOperations.h"  // js::SetUpWritableStreamDefaultControllerFromUnderlyingSink
-#include "builtin/streams/WritableStreamDefaultWriter.h"  // js::CreateWritableStreamDefaultWriter
 #include "js/CallArgs.h"  // JS::CallArgs{,FromVp}
 #include "js/Class.h"  // JS{Function,Property}Spec, JS_{FS,PS}_END, JSCLASS_PRIVATE_IS_NSISUPPORTS, JSCLASS_HAS_PRIVATE, JS_NULL_CLASS_OPS
 #include "js/RealmOptions.h"      // JS::RealmCreationOptions
@@ -29,12 +28,9 @@
 #include "vm/ObjectOperations.h"  // js::GetProperty
 #include "vm/Realm.h"             // JS::Realm
 
-#include "vm/Compartment-inl.h"  // js::UnwrapAndTypeCheckThis
 #include "vm/JSObject-inl.h"      // js::NewBuiltinClassInstance
 #include "vm/NativeObject-inl.h"  // js::ThrowIfNotConstructing
 
-using js::CreateWritableStreamDefaultWriter;
-using js::UnwrapAndTypeCheckThis;
 using js::WritableStream;
 
 using JS::CallArgs;
@@ -148,30 +144,7 @@ bool WritableStream::constructor(JSContext* cx, unsigned argc, Value* vp) {
   return true;
 }
 
-/**
- * Streams spec, 4.2.5.3. getWriter()
- */
-static bool WritableStream_getWriter(JSContext* cx, unsigned argc, Value* vp) {
-  CallArgs args = CallArgsFromVp(argc, vp);
-
-  // Step 1: If ! WritableStream(this) is false, throw a TypeError exception.
-  Rooted<WritableStream*> unwrappedStream(
-      cx, UnwrapAndTypeCheckThis<WritableStream>(cx, args, "getWriter"));
-  if (!unwrappedStream) {
-    return false;
-  }
-
-  auto* writer = CreateWritableStreamDefaultWriter(cx, unwrappedStream);
-  if (!writer) {
-    return false;
-  }
-
-  args.rval().setObject(*writer);
-  return true;
-}
-
-static const JSFunctionSpec WritableStream_methods[] = {
-    JS_FN("getWriter", WritableStream_getWriter, 0, 0), JS_FS_END};
+static const JSFunctionSpec WritableStream_methods[] = {JS_FS_END};
 
 static const JSPropertySpec WritableStream_properties[] = {JS_PS_END};
 

js/src/builtin/streams/WritableStream.cpp

@@ -27,7 +27,6 @@ struct JSContext;
 namespace js {
 
 class WritableStreamDefaultController;
-class WritableStreamDefaultWriter;
 
 class WritableStream : public NativeObject {
  public:
@@ -183,14 +182,9 @@ class WritableStream : public NativeObject {
 
  public:
   bool writable() const { return state() == Writable; }
-
   bool closed() const { return state() == Closed; }
-
   bool erroring() const { return state() == Erroring; }
-  void setErroring() { setState(Erroring); }
-
   bool errored() const { return state() == Errored; }
-  void setErrored() { setState(Errored); }
 
   bool backpressure() const { return flags() & Backpressure; }
 
@@ -211,8 +205,9 @@ class WritableStream : public NativeObject {
   }
 
   bool hasWriter() const { return !getFixedSlot(Slot_Writer).isUndefined(); }
-  inline WritableStreamDefaultWriter* writer() const;
-  inline void setWriter(WritableStreamDefaultWriter* writer);
+  void setWriter(JSObject* writer) {
+    setFixedSlot(Slot_Writer, JS::ObjectValue(*writer));
+  }
   void clearWriter() { setFixedSlot(Slot_Writer, JS::UndefinedValue()); }
 
   JS::Value storedError() const { return getFixedSlot(Slot_StoredError); }