Fix race between zlib Inflate/Deflate and Dispose

src/libraries/Common/src/System/IO/Compression/ZLibNative.cs

@@ -288,11 +288,6 @@ public uint AvailOut
                 set { _zStream.availOut = value; }
             }
 
-            private void EnsureNotDisposed()
-            {
-                ObjectDisposedException.ThrowIf(InitializationState == State.Disposed, this);
-            }
-
             private void EnsureState(State requiredState)
             {
                 if (InitializationState != requiredState)
@@ -348,18 +343,28 @@ private unsafe void DeflateInit2_(CompressionLevel level, int windowBits, int me
 
             public unsafe ErrorCode Deflate(FlushCode flush)
             {
-                EnsureNotDisposed();
-                EnsureState(State.InitializedForDeflate);
+                bool refAdded = false;
+                try
+                {
+                    DangerousAddRef(ref refAdded);
+                    EnsureState(State.InitializedForDeflate);
 
-                fixed (ZStream* stream = &_zStream)
+                    fixed (ZStream* stream = &_zStream)
+                    {
+                        return Interop.ZLib.Deflate(stream, flush);
+                    }
+                }
+                finally
                 {
-                    return Interop.ZLib.Deflate(stream, flush);
+                    if (refAdded)
+                    {
+                        DangerousRelease();
+                    }
                 }
             }
 
             public unsafe ErrorCode DeflateEnd()
             {
-                EnsureNotDisposed();
                 EnsureState(State.InitializedForDeflate);
 
                 fixed (ZStream* stream = &_zStream)
@@ -395,29 +400,50 @@ private unsafe void InflateInit2_(int windowBits)
 
             public unsafe ErrorCode InflateReset2_(int windowBits)
             {
-                EnsureNotDisposed();
-                EnsureState(State.InitializedForInflate);
+                bool refAdded = false;
+                try
+                {
+                    DangerousAddRef(ref refAdded);
+                    EnsureState(State.InitializedForInflate);
 
-                fixed (ZStream* stream = &_zStream)
+                    fixed (ZStream* stream = &_zStream)
+                    {
+                        return Interop.ZLib.InflateReset2_(stream, windowBits);
+                    }
+                }
+                finally
                 {
-                    return Interop.ZLib.InflateReset2_(stream, windowBits);
+                    if (refAdded)
+                    {
+                        DangerousRelease();
+                    }
                 }
             }
 
             public unsafe ErrorCode Inflate(FlushCode flush)
             {
-                EnsureNotDisposed();
-                EnsureState(State.InitializedForInflate);
+                bool refAdded = false;
+                try
+                {
+                    DangerousAddRef(ref refAdded);
+                    EnsureState(State.InitializedForInflate);
 
-                fixed (ZStream* stream = &_zStream)
+                    fixed (ZStream* stream = &_zStream)
+                    {
+                        return Interop.ZLib.Inflate(stream, flush);
+                    }
+                }
+                finally
                 {
-                    return Interop.ZLib.Inflate(stream, flush);
+                    if (refAdded)
+                    {
+                        DangerousRelease();
+                    }
                 }
             }
 
             public unsafe ErrorCode InflateEnd()
             {
-                EnsureNotDisposed();
                 EnsureState(State.InitializedForInflate);
 
                 fixed (ZStream* stream = &_zStream)