View difference between Paste ID: 5uyuuL1V and SFHU3hYR

 type
  {
   Default TIdIOHandler implementation hangs in ReadBytes until it reads at least
   RecvBufferSize, see:
     http://stackoverflow.com/questions/15615347/http-continuous-packeted-stream-with-indy
   This is unacceptable with event streams as events have to be handled timely
   as they received.
  }
   TIdStreamIoHandler = class(TIdIOHandlerStack)
   public
     function TryReadBytes(var VBuffer: TIdBytes; AByteCount: Integer;
       AAppend: Boolean = True): integer; virtual;
     procedure ReadStream(AStream: TStream; AByteCount: TIdStreamSize = -1;
      AReadUntilDisconnect: Boolean = False); override;
   end;
 
 
 //Reads up to AByteCount bytes in one go. Returns the number of bytes read, >0.
 //Copied from ReadBytes with some modifications.
 function TIdStreamIOHandler.TryReadBytes(var VBuffer: TIdBytes; AByteCount: Integer;
   AAppend: Boolean = True): integer;
 begin
   Assert(FInputBuffer<>nil);
   if AByteCount > 0 then begin
     // Read from stack if we have not enough data
     if FInputBuffer.Size < AByteCount then begin
       ReadFromSource(False); //whatever we can
       CheckForDisconnect(True, True);
     end;
     Result := IndyMin(AByteCount, FInputBuffer.Size);
     FInputBuffer.ExtractToBytes(VBuffer, Result, AAppend);
   end else if AByteCount < 0 then begin
     ReadFromSource(False, ReadTimeout, False);
     CheckForDisconnect(True, True);
     Result := FInputBuffer.Size;
     FInputBuffer.ExtractToBytes(VBuffer, Result, AAppend);
   end else
     Result := 0;
 end;
 
 { Copied from TIdIOHandler.ReadStream with adjustments and simplifications.
 ReadUntilDisconnect: Read all data until the connection closes.
   Data is processed in RecvBufferSize chunks, or in how much is available.
 AByteCount>0 + !ReadUntilDisconnect: Read up to AByteCount in one go.
 AByteCount<0 + !ReadUntilDisconnect: Read all available data in one go.
 }
 procedure TIdStreamIOHandler.ReadStream(AStream: TStream; AByteCount: TIdStreamSize;
   AReadUntilDisconnect: Boolean);
 var
   i: Integer;
   LBuf: TIdBytes;
   LByteCount: TIdStreamSize;
 begin
   Assert(AStream<>nil);
   LByteCount := AByteCount;
 
   if AReadUntilDisconnect and (AByteCount>0) then
     AByteCount := -1;
 
   if AReadUntilDisconnect then begin
     BeginWork(wmRead);
   end else begin
     BeginWork(wmRead, LByteCount);
   end;
 
   try
     // If data already exists in the buffer, write it out first.
     // should this loop for all data in buffer up to workcount? not just one block?
     if FInputBuffer.Size > 0 then begin
       if AByteCount<0 then begin
         i := FInputBuffer.Size;
       end else begin
         i := IndyMin(FInputBuffer.Size, LByteCount);
         Dec(LByteCount, i);
       end;
       FInputBuffer.ExtractToStream(AStream, i);
     end;
 
     // RLebeau - don't call Connected() here!  ReadBytes() already
     // does that internally. Calling Connected() here can cause an
     // EIdConnClosedGracefully exception that breaks the loop
     // prematurely and thus leave unread bytes in the InputBuffer.
     // Let the loop catch the exception before exiting...
 
     SetLength(LBuf, RecvBufferSize); // preallocate the buffer
     repeat
 
       if AByteCount<0 then begin
         i := -1;
       end else begin
         i := IndyMin(LByteCount, RecvBufferSize);
         if i < 1 then break;
       end;
 
       try
         try
           i := TryReadBytes(LBuf, i, False);
         except
           on E: Exception do begin
             // RLebeau - ReadFromSource() inside of ReadBytes()
             // could have filled the InputBuffer with more bytes
             // than actually requested, so don't extract too
             // many bytes here...
             if i>0 then //else it's already -1 or 0
               i := IndyMin(i, FInputBuffer.Size);
             FInputBuffer.ExtractToBytes(LBuf, i, False);
             if (E is EIdConnClosedGracefully) and AReadUntilDisconnect then
               break
             else
               raise;
           end;
         end;
         TIdAntiFreezeBase.DoProcess;
       finally
         if i > 0 then begin //how much was read
           TIdStreamHelper.Write(AStream, LBuf, i);
           if not AReadUntilDisconnect then
             Dec(LByteCount, i);
         end;
       end;
 
     until false;
 
   finally
     EndWork(wmRead);
     LBuf := nil;
   end;
 end;