Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.ServiceModel.Web/System/ServiceModel/Channels/StreamBodyWriter.cs

@@ -0,0 +1,206 @@
+//----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//----------------------------------------------------------------------------
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.IO;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.Xml;
+    using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
+
+    public abstract class StreamBodyWriter : BodyWriter
+    {
+        // if isQuirkedTo40Behavior = true, does not try to write out <Binary> tags 
+        //   this maintains compatibility for 4.0 implementers of a derived StreamBodyWriter if they 
+        //   depended on behaviour where StreamBodyWriter isn't ByteStreamEncoder aware. 
+        //   e.g., if they wrote their own <Binary> tags and relied on StreamBodyWriter to only write out the body. 
+        //
+        // if isQuirkedTo40Behavior = false, XmlWriterBackedStream will write out <Binary> tags (default in 4.5)
+        readonly bool isQuirkedTo40Behavior;
+
+        // externally accessible constructor quirked: 
+        // if version <  4.5, XmlWriterBackedStream does not try to write out <Binary> tags
+        // if version >= 4.5, XmlWriterBackedStream will write out <Binary> tags
+        protected StreamBodyWriter(bool isBuffered)
+            : this(isBuffered, !OSEnvironmentHelper.IsApplicationTargeting45)
+        { }
+
+        // internally accessible constructor allows derived types to determine whether StreamBodyWriter should be ByteStream aware
+        // internal implementations SHOULD use isQuirkedTo40Behavior = false. 
+        internal StreamBodyWriter(bool isBuffered, bool isQuirkedTo40Behavior)
+            : base(isBuffered)
+        {
+            this.isQuirkedTo40Behavior = isQuirkedTo40Behavior;  
+        }
+
+        internal static StreamBodyWriter CreateStreamBodyWriter(Action<Stream> streamAction)
+        {
+            if (streamAction == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actionOfStream");
+            }
+            return new ActionOfStreamBodyWriter(streamAction);
+        }
+
+        protected abstract void OnWriteBodyContents(Stream stream);
+
+        protected override BodyWriter OnCreateBufferedCopy(int maxBufferSize)
+        {
+            using (BufferManagerOutputStream bufferedStream = new BufferManagerOutputStream(SR2.MaxReceivedMessageSizeExceeded, maxBufferSize))
+            {
+                this.OnWriteBodyContents(bufferedStream);
+                int size;
+                byte[] bytesArray = bufferedStream.ToArray(out size);
+                return new BufferedBytesStreamBodyWriter(bytesArray, size);
+            }
+        }
+
+        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
+        {
+            using (XmlWriterBackedStream stream = new XmlWriterBackedStream(writer, this.isQuirkedTo40Behavior))
+            {
+                OnWriteBodyContents(stream);
+            }
+        }
+
+        class XmlWriterBackedStream : Stream
+        {
+            private const string StreamElementName = "Binary";
+            private readonly bool isQuirkedTo40Behavior; 
+
+            XmlWriter writer;
+
+            public XmlWriterBackedStream(XmlWriter writer, bool isQuirkedTo40Behavior)
+            {
+                if (writer == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
+                }
+                this.writer = writer;
+
+                this.isQuirkedTo40Behavior = isQuirkedTo40Behavior;
+            }
+
+            public override bool CanRead
+            {
+                get { return false; }
+            }
+
+            public override bool CanSeek
+            {
+                get { return false; }
+            }
+
+            public override bool CanWrite
+            {
+                get { return true; }
+            }
+
+            public override void Flush()
+            {
+                this.writer.Flush();
+            }
+
+            public override long Length
+            {
+                get
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertyGetNotSupported, "Length")));
+                }
+            }
+
+            public override long Position
+            {
+                get
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertyGetNotSupported, "Position")));
+                }
+                set
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertySetNotSupported, "Position")));
+                }
+            }
+
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "Read")));
+            }
+
+            public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "BeginRead")));
+            }
+
+            public override int EndRead(IAsyncResult asyncResult)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "EndRead")));
+            }
+
+            public override int ReadByte()
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "ReadByte")));
+            }
+
+            public override long Seek(long offset, SeekOrigin origin)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "Seek")));
+            }
+
+            public override void SetLength(long value)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "SetLength")));
+            }
+
+            public override void Write(byte[] buffer, int offset, int count)
+            {
+                if (writer.WriteState == WriteState.Content || this.isQuirkedTo40Behavior)
+                {
+                    // if isQuirkedTo40Behavior == true, maintains compatibility for 4.0 implementers of a derived StreamBodyWriter 
+                    // if they depended on behaviour without state checks, e.g., if they wrote their own <Binary> tags 
+                    this.writer.WriteBase64(buffer, offset, count);
+                }
+                else if (writer.WriteState == WriteState.Start)
+                {
+                    writer.WriteStartElement(StreamElementName, string.Empty);
+                    this.writer.WriteBase64(buffer, offset, count);
+                }
+            }
+        }
+
+        class BufferedBytesStreamBodyWriter : StreamBodyWriter
+        {
+            byte[] array;
+            int size;
+
+            public BufferedBytesStreamBodyWriter(byte[] array, int size)
+                : base(true, false)
+            {
+                this.array = array;
+                this.size = size;
+            }
+
+            protected override void OnWriteBodyContents(Stream stream)
+            {
+                stream.Write(this.array, 0, this.size);
+            }
+        }
+
+        class ActionOfStreamBodyWriter : StreamBodyWriter
+        {
+            Action<Stream> actionOfStream;
+
+            public ActionOfStreamBodyWriter(Action<Stream> actionOfStream)
+                : base(false, false)
+            {
+                this.actionOfStream = actionOfStream;
+            }
+
+            protected override void OnWriteBodyContents(Stream stream)
+            {
+                actionOfStream(stream);
+            }
+        }
+    }
+}