Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,169 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.Diagnostics;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Security;
+
+    class PeerOutputChannel : TransportOutputChannel
+    {
+        PeerNode peerNode;
+        Uri via;
+        EndpointAddress to;
+        SecurityProtocol securityProtocol;
+        bool released;
+        ChannelManagerBase channelManager;
+
+        public PeerOutputChannel(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager,
+            EndpointAddress localAddress, Uri via, MessageVersion messageVersion)
+            : base(channelManager, localAddress, via, false, messageVersion)
+        {
+            PeerNodeImplementation.ValidateVia(via);
+            if (registration != null)
+            {
+                peerNode = PeerNodeImplementation.Get(via, registration);
+            }
+            this.peerNode = new PeerNode(peerNode);
+            this.via = via;
+            this.channelManager = channelManager;
+            this.to = localAddress;
+        }
+
+        public override T GetProperty<T>()
+        {
+            if (typeof(T) == typeof(PeerNode))
+            {
+                return (T)(object)this.peerNode;
+            }
+            else if (typeof(T) == typeof(PeerNodeImplementation))
+            {
+                return (T)(object)this.peerNode.InnerNode;
+            }
+            else if (typeof(T) == typeof(IOnlineStatus))
+            {
+                return (T)(object)this.peerNode;
+            }
+            else if (typeof(T) == typeof(FaultConverter))
+            {
+                return (T)(object)FaultConverter.GetDefaultFaultConverter(MessageVersion.Soap12WSAddressing10);
+            }
+            return base.GetProperty<T>();
+        }
+
+        protected override void OnAbort()
+        {
+            if (this.State < CommunicationState.Closed)
+            {
+                try
+                {
+                    this.peerNode.InnerNode.Abort();
+                }
+                catch (Exception e)
+                {
+                    if (Fx.IsFatal(e)) throw;
+                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
+                }
+            }
+        }
+
+        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
+        {
+            return this.peerNode.InnerNode.BeginClose(timeout, callback, state);
+        }
+
+        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
+        {
+            IAsyncResult result = this.peerNode.InnerNode.BeginOpen(timeout, callback, state, true);
+            return result;
+        }
+
+        protected override void OnClose(TimeSpan timeout)
+        {
+            this.peerNode.InnerNode.Close(timeout);
+        }
+
+        protected override void OnClosing()
+        {
+            base.OnClosing();
+            ReleaseNode();
+        }
+
+        void ReleaseNode()
+        {
+            if (!this.released)
+            {
+                bool release = false;
+                lock (ThisLock)
+                {
+                    if (!this.released)
+                    {
+                        release = this.released = true;
+                    }
+                }
+                if (release && (this.peerNode != null))
+                {
+                    this.peerNode.InnerNode.Release();
+                }
+            }
+        }
+
+        protected override void OnOpen(TimeSpan timeout)
+        {
+            this.peerNode.OnOpen();
+            this.peerNode.InnerNode.Open(timeout, true);
+        }
+
+        protected override void OnFaulted()
+        {
+            base.OnFaulted();
+            ReleaseNode();
+        }
+
+        protected override void OnEndClose(IAsyncResult result)
+        {
+            PeerNodeImplementation.EndClose(result);
+        }
+
+        protected override void OnEndOpen(IAsyncResult result)
+        {
+            PeerNodeImplementation.EndOpen(result);
+        }
+
+        protected override void OnSend(Message message, TimeSpan timeout)
+        {
+            EndSend(BeginSend(message, timeout, null, null));
+        }
+
+        protected override IAsyncResult OnBeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
+        {
+            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
+
+            if (this.securityProtocol == null)
+            {
+                lock (ThisLock)
+                {
+                    if (this.securityProtocol == null)
+                    {
+                        this.securityProtocol = ((IPeerFactory)channelManager).SecurityManager.CreateSecurityProtocol<IOutputChannel>(this.to, timeoutHelper.RemainingTime());
+                    }
+                }
+            }
+            return this.peerNode.InnerNode.BeginSend(this, message, this.via, (ITransportFactorySettings)Manager, timeoutHelper.RemainingTime(), callback, state, this.securityProtocol);
+        }
+
+        protected override void OnEndSend(IAsyncResult result)
+        {
+            PeerNodeImplementation.EndSend(result);
+        }
+
+        protected override void AddHeadersTo(Message message)
+        {
+            this.RemoteAddress.ApplyTo(message);
+        }
+    }
+}