Use managed HTTP stack

LibGit2Sharp.Tests/GlobalSettingsFixture.cs

@@ -15,7 +15,6 @@ public void CanGetMinimumCompiledInFeatures()
             BuiltInFeatures features = GlobalSettings.Version.Features;
 
             Assert.True(features.HasFlag(BuiltInFeatures.Threads));
-            Assert.True(features.HasFlag(BuiltInFeatures.Https));
         }
 
         [Fact]

LibGit2Sharp/AmbiguousSpecificationException.cs

@@ -1,3 +1,4 @@
+using LibGit2Sharp.Core;
 using System;
 using System.Runtime.Serialization;
 
@@ -7,7 +8,7 @@ namespace LibGit2Sharp
     /// The exception that is thrown when the provided specification cannot uniquely identify a reference, an object or a path.
     /// </summary>
     [Serializable]
-    public class AmbiguousSpecificationException : LibGit2SharpException
+    public class AmbiguousSpecificationException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="AmbiguousSpecificationException"/> class.
@@ -50,5 +51,13 @@ public AmbiguousSpecificationException(string message, Exception innerException)
         protected AmbiguousSpecificationException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.Ambiguous;
+            }
+        }
     }
 }

LibGit2Sharp/BareRepositoryException.cs

@@ -9,7 +9,7 @@ namespace LibGit2Sharp
     /// working directory is performed against a bare repository.
     /// </summary>
     [Serializable]
-    public class BareRepositoryException : LibGit2SharpException
+    public class BareRepositoryException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.BareRepositoryException"/> class.
@@ -52,8 +52,16 @@ protected BareRepositoryException(SerializationInfo info, StreamingContext conte
             : base(info, context)
         { }
 
-        internal BareRepositoryException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal BareRepositoryException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.BareRepo;
+            }
+        }
     }
 }

LibGit2Sharp/CertificateX509.cs

@@ -10,7 +10,6 @@ namespace LibGit2Sharp
     /// </summary>
     public class CertificateX509 : Certificate
     {
-
         /// <summary>
         /// For mocking purposes
         /// </summary>
@@ -30,6 +29,11 @@ internal unsafe CertificateX509(git_certificate_x509* cert)
             Certificate = new X509Certificate(data);
         }
 
+        internal CertificateX509(X509Certificate cert)
+        {
+            Certificate = cert;
+        }
+
         internal unsafe IntPtr ToPointers(out IntPtr dataPtr)
         {
             var certData = Certificate.Export(X509ContentType.Cert);

LibGit2Sharp/CheckoutConflictException.cs

@@ -10,7 +10,7 @@ namespace LibGit2Sharp
     /// in the working directory.
     /// </summary>
     [Serializable]
-    public class CheckoutConflictException : LibGit2SharpException
+    public class CheckoutConflictException : NativeException
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="LibGit2Sharp.CheckoutConflictException"/> class.
@@ -53,8 +53,16 @@ protected CheckoutConflictException(SerializationInfo info, StreamingContext con
             : base(info, context)
         { }
 
-        internal CheckoutConflictException(string message, GitErrorCode code, GitErrorCategory category)
-            : base(message, code, category)
+        internal CheckoutConflictException(string message, GitErrorCategory category)
+            : base(message, category)
         { }
+
+        internal override GitErrorCode ErrorCode
+        {
+            get
+            {
+                return GitErrorCode.Conflict;
+            }
+        }
     }
 }

LibGit2Sharp/Core/Ensure.cs

@@ -114,20 +114,20 @@ public static void ArgumentIsExpectedIntPtr(IntPtr argumentValue, IntPtr expecte
             }
         }
 
-        private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
+        private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCategory, LibGit2SharpException>>
             GitErrorsToLibGit2SharpExceptions =
-                new Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
+                new Dictionary<GitErrorCode, Func<string, GitErrorCategory, LibGit2SharpException>>
                 {
-                    { GitErrorCode.User, (m, r, c) => new UserCancelledException(m, r, c) },
-                    { GitErrorCode.BareRepo, (m, r, c) => new BareRepositoryException(m, r, c) },
-                    { GitErrorCode.Exists, (m, r, c) => new NameConflictException(m, r, c) },
-                    { GitErrorCode.InvalidSpecification, (m, r, c) => new InvalidSpecificationException(m, r, c) },
-                    { GitErrorCode.UnmergedEntries, (m, r, c) => new UnmergedIndexEntriesException(m, r, c) },
-                    { GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
-                    { GitErrorCode.Conflict, (m, r, c) => new CheckoutConflictException(m, r, c) },
-                    { GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
-                    { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },
-                    { GitErrorCode.Peel, (m, r, c) => new PeelException(m, r, c)  },
+                    { GitErrorCode.User, (m, c) => new UserCancelledException(m, c) },
+                    { GitErrorCode.BareRepo, (m, c) => new BareRepositoryException(m, c) },
+                    { GitErrorCode.Exists, (m, c) => new NameConflictException(m, c) },
+                    { GitErrorCode.InvalidSpecification, (m, c) => new InvalidSpecificationException(m, c) },
+                    { GitErrorCode.UnmergedEntries, (m, c) => new UnmergedIndexEntriesException(m, c) },
+                    { GitErrorCode.NonFastForward, (m, c) => new NonFastForwardException(m, c) },
+                    { GitErrorCode.Conflict, (m, c) => new CheckoutConflictException(m, c) },
+                    { GitErrorCode.LockedFile, (m, c) => new LockedFileException(m, c) },
+                    { GitErrorCode.NotFound, (m, c) => new NotFoundException(m, c) },
+                    { GitErrorCode.Peel, (m, c) => new PeelException(m, c) },
                 };
 
         private static unsafe void HandleError(int result)
@@ -145,13 +145,13 @@ private static unsafe void HandleError(int result)
                 errorMessage = LaxUtf8Marshaler.FromNative(error->Message);
             }
 
-            Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException> exceptionBuilder;
+            Func<string, GitErrorCategory, LibGit2SharpException> exceptionBuilder;
             if (!GitErrorsToLibGit2SharpExceptions.TryGetValue((GitErrorCode)result, out exceptionBuilder))
             {
-                exceptionBuilder = (m, r, c) => new LibGit2SharpException(m, r, c);
+                exceptionBuilder = (m, c) => new LibGit2SharpException(m, c);
             }
 
-            throw exceptionBuilder(errorMessage, (GitErrorCode)result, errorCategory);
+            throw exceptionBuilder(errorMessage, errorCategory);
         }
 
         /// <summary>