Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel.Web/System/ServiceModel/Channels/HttpStreamMessage.cs

@@ -0,0 +1,234 @@
+//----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//----------------------------------------------------------------------------
+
+#pragma warning disable 1634 // Stops compiler from warning about unknown warnings (for Presharp)
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.IO;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.Xml;
+    using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
+
+    class HttpStreamMessage : Message
+    {
+        internal const string StreamElementName = "Binary";
+        BodyWriter bodyWriter;
+        MessageHeaders headers;
+        MessageProperties properties;
+
+        public HttpStreamMessage(BodyWriter writer)
+        {
+            if (writer == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
+            }
+            this.bodyWriter = writer;
+            this.headers = new MessageHeaders(MessageVersion.None, 1);
+            this.properties = new MessageProperties();
+        }
+
+        public HttpStreamMessage(MessageHeaders headers, MessageProperties properties, BodyWriter bodyWriter)
+        {
+            if (bodyWriter == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bodyWriter");
+            }
+            this.headers = new MessageHeaders(headers);
+            this.properties = new MessageProperties(properties);
+            this.bodyWriter = bodyWriter;
+        }
+
+        public override MessageHeaders Headers
+        {
+            get
+            {
+                if (IsDisposed)
+                {
+#pragma warning suppress 56503
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateDisposedException());
+                }
+                return headers;
+            }
+        }
+
+        public override bool IsEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool IsFault
+        {
+            get { return false; }
+        }
+
+        public override MessageProperties Properties
+        {
+            get
+            {
+                if (IsDisposed)
+                {
+#pragma warning suppress 56503
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateDisposedException());
+                }
+                return properties;
+            }
+        }
+
+        public override MessageVersion Version
+        {
+            get
+            {
+                if (IsDisposed)
+                {
+#pragma warning suppress 56503
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateDisposedException());
+                }
+                return MessageVersion.None;
+            }
+        }
+
+        protected override void OnBodyToString(XmlDictionaryWriter writer)
+        {
+            if (this.bodyWriter.IsBuffered)
+            {
+                bodyWriter.WriteBodyContents(writer);
+            }
+            else
+            {
+                writer.WriteString(SR2.GetString(SR2.MessageBodyIsStream));
+            }
+        }
+
+        protected override void OnClose()
+        {
+            Exception ex = null;
+            try
+            {
+                base.OnClose();
+            }
+            catch (Exception e)
+            {
+                if (Fx.IsFatal(e))
+                {
+                    throw;
+                }
+                ex = e;
+            }
+
+            try
+            {
+                if (properties != null)
+                {
+                    properties.Dispose();
+                }
+            }
+            catch (Exception e)
+            {
+                if (Fx.IsFatal(e))
+                {
+                    throw;
+                }
+                if (ex == null)
+                {
+                    ex = e;
+                }
+            }
+
+            if (ex != null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ex);
+            }
+
+            this.bodyWriter = null;
+        }
+
+        protected override MessageBuffer OnCreateBufferedCopy(int maxBufferSize)
+        {
+            BodyWriter bufferedBodyWriter;
+            if (this.bodyWriter.IsBuffered)
+            {
+                bufferedBodyWriter = this.bodyWriter;
+            }
+            else
+            {
+                bufferedBodyWriter = this.bodyWriter.CreateBufferedCopy(maxBufferSize);
+            }
+            return new HttpStreamMessageBuffer(this.Headers, new MessageProperties(this.Properties), bufferedBodyWriter);
+        }
+
+        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
+        {
+            this.bodyWriter.WriteBodyContents(writer);
+        }
+
+        Exception CreateDisposedException()
+        {
+            return new ObjectDisposedException("", SR2.GetString(SR2.MessageClosed));
+        }
+
+        class HttpStreamMessageBuffer : MessageBuffer
+        {
+            BodyWriter bodyWriter;
+            bool closed;
+            MessageHeaders headers;
+            MessageProperties properties;
+            object thisLock = new object();
+
+            public HttpStreamMessageBuffer(MessageHeaders headers,
+                MessageProperties properties, BodyWriter bodyWriter)
+                : base()
+            {
+                this.bodyWriter = bodyWriter;
+                this.headers = headers;
+                this.properties = properties;
+            }
+
+            public override int BufferSize
+            {
+                get { return 0; }
+            }
+
+            object ThisLock
+            {
+                get { return thisLock; }
+            }
+
+            public override void Close()
+            {
+                lock (ThisLock)
+                {
+                    if (!closed)
+                    {
+                        closed = true;
+                        bodyWriter = null;
+                        headers = null;
+                        properties = null;
+                    }
+                }
+            }
+
+            public override Message CreateMessage()
+            {
+                lock (ThisLock)
+                {
+                    if (closed)
+                    {
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateDisposedException());
+                    }
+                    return new HttpStreamMessage(this.headers, this.properties, this.bodyWriter);
+                }
+            }
+
+            Exception CreateDisposedException()
+            {
+                return new ObjectDisposedException("", SR2.GetString(SR2.MessageBufferIsClosed));
+            }
+        }
+    }
+}