Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Extensions/Util/HeaderUtility.cs

@@ -0,0 +1,37 @@
+//------------------------------------------------------------------------------
+// <copyright file="HeaderUtility.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+ 
+namespace System.Web.Util {
+    using System;
+
+    internal static class HeaderUtility {
+        public static bool IsEncodingInAcceptList(string acceptEncodingHeader, string expectedEncoding) {
+            if (String.IsNullOrEmpty(acceptEncodingHeader)) {
+                return false;
+            }
+
+            foreach (string encoding in acceptEncodingHeader.Split(',')) {
+                string e = encoding.Trim();
+
+                // This code will typically handle all existing browsers, which
+                // use "encoding1, encoding2" for this header.
+                // IE, Firefox and Safari are sending "gzip, deflate"
+                // Opera is sending "deflate, gzip, x-gzip, identity, *;q=0"
+                // There is a currently hypothetical case where a browser would use the quantified syntax
+                // on specific encodings ("encoding1;q=0.8, encoding2 ;q=0.2") which we don't handle here.
+                // For those situations, the browser would get the uncompressed version.
+                // See RFC 2068 for details.
+                if (String.Equals(e, expectedEncoding, StringComparison.Ordinal)) {
+                    return true;
+                }
+            }
+
+            // no match found
+            return false;
+        }
+
+    }
+}

mcs/class/referencesource/System.Web.Extensions/Util/HexParser.cs

@@ -0,0 +1,29 @@
+//------------------------------------------------------------------------------
+// <copyright file="HexParser.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+ 
+namespace System.Web.Util {
+    using System;
+    using System.Globalization;
+    using System.Text;
+
+    internal static class HexParser {
+        public static byte[] Parse(string token) {
+            byte[] tokenBytes = new byte[token.Length / 2];
+            for (int i = 0; i < tokenBytes.Length; i++) {
+                tokenBytes[i] = Byte.Parse(token.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            }
+            return tokenBytes;
+        }
+
+        public static string ToString(byte[] tokenBytes) {
+            StringBuilder tokenBuilder = new StringBuilder(tokenBytes.Length * 2);
+            for (int i = 0; i < tokenBytes.Length; i++) {
+                tokenBuilder.Append(tokenBytes[i].ToString("x2", CultureInfo.InvariantCulture));
+            }
+            return tokenBuilder.ToString();
+        }
+    }
+}

mcs/class/referencesource/System.Web.Extensions/Util/ListEqualityComparer.cs

@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <copyright file="ListEqualityComparer.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.Util {
+    using System;
+    using System.Collections;
+
+    // Compares two non-generic IList objects for equality.
+
+    internal sealed class ListEqualityComparer : IEqualityComparer {
+
+        internal static readonly ListEqualityComparer Instance = new ListEqualityComparer();
+
+        private ListEqualityComparer() {
+        }
+
+        bool IEqualityComparer.Equals(object x, object y) {
+            if (Object.ReferenceEquals(x, y)) {
+                return true;
+            }
+
+            IList xList = (IList)x;
+            IList yList = (IList)y;
+
+            if (xList.Count != yList.Count) {
+                return false;
+            }
+
+            for (int i = 0; i < xList.Count; i++) {
+                if (!Object.Equals(xList[i], yList[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        int IEqualityComparer.GetHashCode(object obj) {
+            if (obj == null) {
+                return 0;
+            }
+
+            HashCodeCombiner combiner = new HashCodeCombiner();
+            foreach (object item in (IList)obj) {
+                combiner.AddObject(item);
+            }
+
+            return combiner.CombinedHash32;
+        }
+
+    }
+}

mcs/class/referencesource/System.Web.Extensions/Util/OrderedDictionary.cs

@@ -0,0 +1,152 @@
+//------------------------------------------------------------------------------
+// <copyright file="OrderedDictionary.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+ 
+namespace System.Web.Util {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    // This is different from the BCL's SortedDictionary in that SortedDictionary sorts by the keys'
+    // values (e.g., alphabetical order), but OrderedDictionary sorts by the order in which the keys
+    // were inserted into the dictionary.
+
+    internal class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
+        private Dictionary<TKey, TValue> _dictionary;
+        private List<TKey> _keys;
+        private List<TValue> _values;
+
+        // Cannot easily support ctor that takes IEqualityComparer, since List doesn't have an easy
+        // way to use the IEqualityComparer.
+        public OrderedDictionary()
+            : this(0) {
+        }
+
+        public OrderedDictionary(int capacity) {
+            _dictionary = new Dictionary<TKey, TValue>(capacity);
+            _keys = new List<TKey>(capacity);
+            _values = new List<TValue>(capacity);
+        }
+
+        public int Count {
+            get {
+                return _dictionary.Count;
+            }
+        }
+
+        public ICollection<TKey> Keys {
+            get {
+                return _keys.AsReadOnly();
+            }
+        }
+
+        public TValue this[TKey key] {
+            get {
+                return _dictionary[key];
+            }
+            set {
+                // If key has already been added, we must first remove it from the lists so it is not
+                // in the lists multiple times.
+                RemoveFromLists(key);
+
+                _dictionary[key] = value;
+                _keys.Add(key);
+                _values.Add(value);
+            }
+        }
+
+        public ICollection<TValue> Values {
+            get {
+                return _values.AsReadOnly();
+            }
+        }
+
+        public void Add(TKey key, TValue value) {
+            // Dictionary.Add() will throw if it already contains key
+            _dictionary.Add(key, value);
+            _keys.Add(key);
+            _values.Add(value);
+        }
+
+        public void Clear() {
+            _dictionary.Clear();
+            _keys.Clear();
+            _values.Clear();
+        }
+
+        public bool ContainsKey(TKey key) {
+            return _dictionary.ContainsKey(key);
+        }
+
+        public bool ContainsValue(TValue value) {
+            return _dictionary.ContainsValue(value);
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() {
+            int i = 0;
+            // Must use foreach instead of a for loop, since we want the underlying List enumerator to
+            // throw an exception if the list is modified during enumeration.
+            foreach (TKey key in _keys) {
+                yield return new KeyValuePair<TKey, TValue>(key, _values[i]);
+                i++;
+            }
+        }
+
+        private void RemoveFromLists(TKey key) {
+            int index = _keys.IndexOf(key);
+            if (index != -1) {
+                _keys.RemoveAt(index);
+                _values.RemoveAt(index);
+            }
+        }
+
+        public bool Remove(TKey key) {
+            RemoveFromLists(key);
+            return _dictionary.Remove(key);
+        }
+
+        public bool TryGetValue(TKey key, out TValue value) {
+            return _dictionary.TryGetValue(key, out value);
+        }
+
+        #region ICollection<KeyValuePair<TKey,TValue>> Members
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
+            get {
+                return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).IsReadOnly;
+            }
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) {
+            Add(item.Key, item.Value);
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) {
+            return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Contains(item);
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) {
+            ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).CopyTo(array, arrayIndex);
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) {
+            bool removed = ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Remove(item);
+
+            // Only remove from lists if it was removed from the dictionary, since the dictionary may contain
+            // the key but not the value.
+            if (removed) {
+                RemoveFromLists(item.Key);
+            }
+
+            return removed;
+        }
+        #endregion
+
+        #region IEnumerable Members
+        IEnumerator IEnumerable.GetEnumerator() {
+            return GetEnumerator();
+        }
+        #endregion
+    }
+}