Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/MessageBuffer.cs

@@ -0,0 +1,339 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+namespace System.ServiceModel.Channels
+{
+    using System.Xml;
+    using System.ServiceModel;
+    using System.ServiceModel.Dispatcher;
+    using System.Xml.XPath;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Collections.Generic;
+
+    public abstract class MessageBuffer : IXPathNavigable, IDisposable
+    {
+        public abstract int BufferSize { get; }
+
+        void IDisposable.Dispose()
+        {
+            Close();
+        }
+
+        public abstract void Close();
+
+        public virtual void WriteMessage(Stream stream)
+        {
+            if (stream == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
+            Message message = CreateMessage();
+            using (message)
+            {
+                XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream, XD.Dictionary, null, false);
+                using (writer)
+                {
+                    message.WriteMessage(writer);
+                }
+            }
+        }
+
+        public virtual string MessageContentType
+        {
+            get { return FramingEncodingString.Binary; }
+        }
+
+        public abstract Message CreateMessage();
+
+        internal Exception CreateBufferDisposedException()
+        {
+            return new ObjectDisposedException("", SR.GetString(SR.MessageBufferIsClosed));
+        }
+
+        public XPathNavigator CreateNavigator()
+        {
+            return CreateNavigator(int.MaxValue, XmlSpace.None);
+        }
+
+        public XPathNavigator CreateNavigator(int nodeQuota)
+        {
+            return CreateNavigator(nodeQuota, XmlSpace.None);
+        }
+
+        public XPathNavigator CreateNavigator(XmlSpace space)
+        {
+            return CreateNavigator(int.MaxValue, space);
+        }
+
+        public XPathNavigator CreateNavigator(int nodeQuota, XmlSpace space)
+        {
+            if (nodeQuota <= 0)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("nodeQuota", SR.GetString(SR.FilterQuotaRange)));
+
+            return new SeekableMessageNavigator(this.CreateMessage(), nodeQuota, space, true, true);
+        }
+    }
+
+    class DefaultMessageBuffer : MessageBuffer
+    {
+        XmlBuffer msgBuffer;
+        KeyValuePair<string, object>[] properties;
+        bool[] understoodHeaders;
+        bool closed;
+        MessageVersion version;
+        Uri to;
+        string action;
+        bool isNullMessage;
+
+        public DefaultMessageBuffer(Message message, XmlBuffer msgBuffer)
+        {
+            this.msgBuffer = msgBuffer;
+            this.version = message.Version;
+            this.isNullMessage = message is NullMessage;
+
+            properties = new KeyValuePair<string, object>[message.Properties.Count];
+            ((ICollection<KeyValuePair<string, object>>)message.Properties).CopyTo(properties, 0);
+            understoodHeaders = new bool[message.Headers.Count];
+            for (int i = 0; i < understoodHeaders.Length; ++i)
+                understoodHeaders[i] = message.Headers.IsUnderstood(i);
+
+            //CSDMain 17837: CreateBufferedCopy should have code to copy over the To and Action headers
+            if (version == MessageVersion.None)
+            {
+                this.to = message.Headers.To;
+                this.action = message.Headers.Action;
+            }
+        }
+
+        object ThisLock
+        {
+            get { return msgBuffer; }
+        }
+
+        public override int BufferSize
+        {
+            get { return msgBuffer.BufferSize; }
+        }
+
+        public override void Close()
+        {
+            lock (ThisLock)
+            {
+                if (closed)
+                    return;
+
+                closed = true;
+                for (int i = 0; i < this.properties.Length; i++)
+                {
+                    IDisposable disposable = this.properties[i].Value as IDisposable;
+                    if (disposable != null)
+                        disposable.Dispose();
+                }
+            }
+        }
+
+        public override Message CreateMessage()
+        {
+            if (closed)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
+
+            Message msg;
+            if (this.isNullMessage)
+            {
+                msg = new NullMessage();
+            }
+            else
+            {
+                msg = Message.CreateMessage(msgBuffer.GetReader(0), int.MaxValue, this.version);
+            }
+
+            lock (ThisLock)
+            {
+                msg.Properties.CopyProperties(properties);
+            }
+
+            for (int i = 0; i < understoodHeaders.Length; ++i)
+            {
+                if (understoodHeaders[i])
+                    msg.Headers.AddUnderstood(i);
+            }
+
+            if (this.to != null)
+            {
+                msg.Headers.To = this.to;
+            }
+
+            if (this.action != null)
+            {
+                msg.Headers.Action = this.action;
+            }
+
+            return msg;
+        }
+    }
+
+    class BufferedMessageBuffer : MessageBuffer
+    {
+        IBufferedMessageData messageData;
+        KeyValuePair<string, object>[] properties;
+        bool closed;
+        object thisLock = new object();
+        bool[] understoodHeaders;
+        bool understoodHeadersModified;
+
+        public BufferedMessageBuffer(IBufferedMessageData messageData,
+            KeyValuePair<string, object>[] properties, bool[] understoodHeaders, bool understoodHeadersModified)
+        {
+            this.messageData = messageData;
+            this.properties = properties;
+            this.understoodHeaders = understoodHeaders;
+            this.understoodHeadersModified = understoodHeadersModified;
+            messageData.Open();
+        }
+
+        public override int BufferSize
+        {
+            get
+            {
+                lock (ThisLock)
+                {
+                    if (closed)
+#pragma warning suppress 56503 // [....], Invalid State after dispose
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
+                    return messageData.Buffer.Count;
+                }
+            }
+        }
+
+        public override void WriteMessage(Stream stream)
+        {
+            if (stream == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
+            lock (ThisLock)
+            {
+                if (closed)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
+                ArraySegment<byte> buffer = messageData.Buffer;
+                stream.Write(buffer.Array, buffer.Offset, buffer.Count);
+            }
+        }
+
+        public override string MessageContentType
+        {
+            get
+            {
+                lock (ThisLock)
+                {
+                    if (closed)
+#pragma warning suppress 56503 // [....], Invalid State after dispose
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
+                    return messageData.MessageEncoder.ContentType;
+                }
+            }
+        }
+
+        object ThisLock
+        {
+            get { return thisLock; }
+        }
+
+        public override void Close()
+        {
+            lock (ThisLock)
+            {
+                if (!closed)
+                {
+                    closed = true;
+                    messageData.Close();
+                    messageData = null;
+                }
+            }
+        }
+
+        public override Message CreateMessage()
+        {
+            lock (ThisLock)
+            {
+                if (closed)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
+                RecycledMessageState recycledMessageState = messageData.TakeMessageState();
+                if (recycledMessageState == null)
+                    recycledMessageState = new RecycledMessageState();
+                BufferedMessage bufferedMessage = new BufferedMessage(messageData, recycledMessageState, this.understoodHeaders, this.understoodHeadersModified);
+                bufferedMessage.Properties.CopyProperties(this.properties);
+                messageData.Open();
+                return bufferedMessage;
+            }
+        }
+    }
+
+    class BodyWriterMessageBuffer : MessageBuffer
+    {
+        BodyWriter bodyWriter;
+        KeyValuePair<string, object>[] properties;
+        MessageHeaders headers;
+        bool closed;
+        object thisLock = new object();
+
+        public BodyWriterMessageBuffer(MessageHeaders headers,
+            KeyValuePair<string, object>[] properties, BodyWriter bodyWriter)
+        {
+            this.bodyWriter = bodyWriter;
+            this.headers = new MessageHeaders(headers);
+            this.properties = properties;
+        }
+
+        protected object ThisLock
+        {
+            get { return thisLock; }
+        }
+
+        public override int BufferSize
+        {
+            get { return 0; }
+        }
+
+        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(CreateBufferDisposedException());
+                return new BodyWriterMessage(headers, properties, bodyWriter);
+            }
+        }
+
+        protected BodyWriter BodyWriter
+        {
+            get { return bodyWriter; }
+        }
+
+        protected MessageHeaders Headers
+        {
+            get { return headers; }
+        }
+
+        protected KeyValuePair<string, object>[] Properties
+        {
+            get { return properties; }
+        }
+
+        protected bool Closed
+        {
+            get { return closed; }
+        }
+    }
+}