Use git_blob_fromstream instead of fromchunks

Make GitWriteStream a struct instead of a class so that we can
accept a native `git_writestream`.  Use `git_blob_fromstream` to
stream data into a blob instead of the now-removed
`git_blob_fromchunks`.

Author: Edward Thomson

LibGit2Sharp/Core/GitWriteStream.cs

@@ -4,7 +4,7 @@
 namespace LibGit2Sharp.Core
 {
     [StructLayout(LayoutKind.Sequential)]
-    internal class GitWriteStream
+    internal struct GitWriteStream
     {
         [MarshalAs(UnmanagedType.FunctionPtr)]
         public write_fn write;

LibGit2Sharp/Core/NativeMethods.cs

@@ -126,6 +126,17 @@ internal delegate int source_callback(
             int max_length,
             IntPtr data);
 
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_blob_create_fromstream(
+            out IntPtr stream,
+            git_repository* repositoryPtr,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath hintpath);
+
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_blob_create_fromstream_commit(
+            ref GitOid oid,
+            IntPtr stream);
+
         [DllImport(libgit2)]
         internal static extern unsafe int git_blob_create_fromchunks(
             ref GitOid oid,

LibGit2Sharp/Core/Proxy.cs

@@ -115,18 +115,18 @@ public static unsafe BlameHandle git_blame_file(
 
         #region git_blob_
 
-        public static unsafe ObjectId git_blob_create_fromchunks(RepositoryHandle repo, FilePath hintpath, NativeMethods.source_callback fileCallback)
+        public static unsafe IntPtr git_blob_create_fromstream(RepositoryHandle repo, FilePath hintpath)
         {
-            var oid = new GitOid();
-            int res = NativeMethods.git_blob_create_fromchunks(ref oid, repo, hintpath, fileCallback, IntPtr.Zero);
-
-            if (res == (int)GitErrorCode.User)
-            {
-                throw new EndOfStreamException("The stream ended unexpectedly");
-            }
+            IntPtr writestream_ptr;
 
-            Ensure.ZeroResult(res);
+            Ensure.ZeroResult(NativeMethods.git_blob_create_fromstream(out writestream_ptr, repo, hintpath));
+            return writestream_ptr;
+        }
 
+        public static unsafe ObjectId git_blob_create_fromstream_commit(IntPtr writestream_ptr)
+        {
+            var oid = new GitOid();
+            Ensure.ZeroResult(NativeMethods.git_blob_create_fromstream_commit(ref oid, writestream_ptr));
             return oid;
         }
 

LibGit2Sharp/Filter.cs

@@ -261,8 +261,7 @@ int StreamCreateCallback(out IntPtr git_writestream_out, GitFilter self, IntPtr
                 Marshal.StructureToPtr(state.thisStream, state.thisPtr, false);
 
                 state.nextPtr = git_writestream_next;
-                state.nextStream = new GitWriteStream();
-                Marshal.PtrToStructure(state.nextPtr, state.nextStream);
+                state.nextStream = (GitWriteStream)Marshal.PtrToStructure(state.nextPtr, typeof(GitWriteStream));
 
                 state.filterSource = FilterSource.FromNativePtr(filterSourcePtr);
                 state.output = new WriteStream(state.nextStream, state.nextPtr);

LibGit2Sharp/ObjectDatabase.cs

@@ -213,7 +213,7 @@ public virtual Blob CreateBlob(Stream stream, string hintpath, long numberOfByte
             return CreateBlob(stream, hintpath, (long?)numberOfBytesToConsume);
         }
 
-        private Blob CreateBlob(Stream stream, string hintpath, long? numberOfBytesToConsume)
+        private unsafe Blob CreateBlob(Stream stream, string hintpath, long? numberOfBytesToConsume)
         {
             Ensure.ArgumentNotNull(stream, "stream");
 
@@ -228,9 +228,51 @@ private Blob CreateBlob(Stream stream, string hintpath, long? numberOfBytesToCon
                 throw new ArgumentException("The stream cannot be read from.", "stream");
             }
 
-            var proc = new Processor(stream, numberOfBytesToConsume);
-            ObjectId id = Proxy.git_blob_create_fromchunks(repo.Handle, hintpath, proc.Provider);
+            IntPtr writestream_ptr = Proxy.git_blob_create_fromstream(repo.Handle, hintpath);
+            GitWriteStream writestream = (GitWriteStream)Marshal.PtrToStructure(writestream_ptr, typeof(GitWriteStream));
 
+            try
+            {
+                var buffer = new byte[4 * 1024];
+                long totalRead = 0;
+                int read = 0;
+
+                while (true)
+                {
+                    int toRead = numberOfBytesToConsume.HasValue ?
+                        (int)Math.Min(numberOfBytesToConsume.Value - totalRead, (long)buffer.Length) :
+                        buffer.Length;
+
+                    if (toRead > 0)
+                    {
+                        read = (toRead > 0) ? stream.Read(buffer, 0, toRead) : 0;
+                    }
+
+                    if (read == 0)
+                    {
+                        break;
+                    }
+
+                    fixed (byte* buffer_ptr = buffer)
+                    {
+                        writestream.write(writestream_ptr, (IntPtr)buffer_ptr, (UIntPtr)read);
+                    }
+
+                    totalRead += read;
+                }
+
+                if (numberOfBytesToConsume.HasValue && totalRead < numberOfBytesToConsume.Value)
+                {
+                    throw new EndOfStreamException("The stream ended unexpectedly");
+                }
+            }
+            catch(Exception e)
+            {
+                writestream.free(writestream_ptr);
+                throw e;
+            }
+
+            ObjectId id = Proxy.git_blob_create_fromstream_commit(writestream_ptr);
             return repo.Lookup<Blob>(id);
         }