Progress Bar is NULL after the execution of a thread

I have a form with a progress bar and a button that uploads an xml to a server. While the button is pressed a new thread is created that creates a socket and then it sends the data to the server in chunks and in the meanwhile it updates the progress bar. Now, when the upload button is pressed for a second time i get an access violation and in the debugger the address of the Progress Bar object is NULL. I can't figure out why the Progress Bar is getting freed so if anyone has any idea i would be grateful.

P.S. The target OS is windows P.S.2 If the same code runs on the main thread without the usage of a thread then i don't seem to have this issue and even if i skip the usage of the progress bar in overall in the thread it is set to null again after the first push of the upload button.

The thread Constructor:

__fastcall UploadRouteThread::UploadRouteThread(bool CreateSuspended) : TThread(CreateSuspended)
{
    this->OnTerminate = OnTerminateHandler;
    ioHandlerStack = new TIdIOHandlerStack();
    tcpClient = new TIdTCPClient();

    tcpClient->ReadTimeout = -1;
    tcpClient->UseNagle = true;

    tcpClient->IOHandler = ioHandlerStack;
    tcpClient->OnConnected = OnConnectedHandler;

}

The OnTerminate handler:

void __fastcall UploadRouteThread::OnTerminateHandler(TObject *Sender)
{
    TabbedwithNavigationForm->UploadButton->Text = "Upload";
    TabbedwithNavigationForm->UploadButton->Enabled = false;
    TabbedwithNavigationForm->ProgressBar->Visible = false;

    tcpClient->DisconnectNotifyPeer();

    ShowMessage("Data uploaded.");

    delete ioHandlerStack;
    delete tcpClient;

    TabbedwithNavigationForm->OptionButton->Enabled = true;
    TabbedwithNavigationForm->RetrieveRoutesButton->Enabled = true;
    TabbedwithNavigationForm->TrackButton->Enabled = true;
    TabbedwithNavigationForm->MediaButton->Enabled = true;
}

The Execute method:

void __fastcall UploadRouteThread::Execute()
{
    FreeOnTerminate = true;
    tcpClient->Connect();
}

Two supplumentary functions:

void __fastcall UploadRouteThread::SetHostPort(UnicodeString host, unsigned short port)
{
    tcpClient->Host = host;
    tcpClient->Port = port;
}

void __fastcall UploadRouteThread::SetXML(AnsiString xmlString)
{
    this->xmlString = xmlString;
}

The OnConnect Handler:

void __fastcall UploadRouteThread::OnConnectedHandler(TObject *Sender)
{
    NextPacketSize nps;
    TIdBytes bytes;
    int chunks;
    int bytesLength;

    nps.PacketID = BasicPacket::DATA_UPLOAD;
    nps.size = xmlString.Length();

    tcpClient->IOHandler->WriteDirect(RawToBytes(&nps, sizeof(nps)), sizeof(NextPacketSize));
    bytes = RawToBytes(xmlString.c_str(), xmlString.Length());

    bytesLength = bytes.get_length();
    chunks = ceil(float(bytesLength) / 256.0);

    int previousSizeSent(0);
    for(int i = 1; i <= chunks; i++)
    {
        if(Terminated)
            break;
        int bytesToSend = 256;
        TByteDynArray byteDynArray;

        if((bytesToSend > bytesLength))
        {
              bytesToSend = bytesLength;
        }

        byteDynArray = bytes.CopyRange(previousSizeSent, bytesToSend);

        tcpClient->IOHandler->WriteDirect(ToBytes(byteDynArray, byteDynArray.get_length(), 0),
        byteDynArray.get_length());

        sent = (float(i) / float(chunks)) * 100;
        TThread::Synchronize(this, UpdateProgressBarInternal);

        previousSizeSent += bytesToSend;
        bytesLength -= bytesToSend;
    }
}

And the Update method for the progress bar:

void __fastcall UploadRouteThread::UpdateProgressBarInternal()
{
    if(!TabbedwithNavigationForm->ProgressBar->Visible)
    {
        TabbedwithNavigationForm->ProgressBar->Visible = true;
        TabbedwithNavigationForm->ProgressBar->Max = 100;
    }

    TabbedwithNavigationForm->ProgressBar->Value = sent;
}

I don't see anything in this code that would cause the ProgressBar pointer to become NULL. So either you are corrupting memory, or something else in other code not shown here is the culprit. Either way, to troubleshoot this you can run your app in the IDE debugger and set a Data Breakpoint on the ProgressBar variable before you run your thread for the first time. If something changes the value of that pointer, the breakpoint will be hit, and you can look at the call stack to figure out what is happening.

With that said, your thread is not very well organized. And there is a much simpler way to handle the chunking - let Indy do it for you. It has an OnWork event that you can use for your ProgressBar updates.

Try something more like this:

__fastcall UploadRouteThread::UploadRouteThread(String host, TIdPort port, AnsiString xmlString)
    : TThread(false)
{
    this->FreeOnTerminate = true;
    this->OnTerminate = OnTerminateHandler;
    this->xmlString = xmlString;

    tcpClient = new TIdTCPClient();
    tcpClient->Host = host;
    tcpClient->Port = port;
    tcpClient->UseNagle = true;
    tcpClient->OnWork = OnWorkHandler;
}

__fastcall UploadRouteThread::~UploadRouteThread()
{
    delete tcpClient;
}

void __fastcall UploadRouteThread::OnTerminateHandler(TObject *Sender)
{
    TabbedwithNavigationForm->UploadButton->Text = "Upload";
    TabbedwithNavigationForm->UploadButton->Enabled = false;
    TabbedwithNavigationForm->ProgressBar->Visible = false;

    if (FatalException)
        ShowMessage("Data not uploaded.");
    else
        ShowMessage("Data uploaded.");

    TabbedwithNavigationForm->OptionButton->Enabled = true;
    TabbedwithNavigationForm->RetrieveRoutesButton->Enabled = true;
    TabbedwithNavigationForm->TrackButton->Enabled = true;
    TabbedwithNavigationForm->MediaButton->Enabled = true;
}

void __fastcall UploadRouteThread::OnWorkHandler(TObject *ASender, TWorkMode AWorkMode, __int64 AWorkCount)
{
    if (Terminated)
        Sysutils::Abort();

    sent = (double(AWorkCount) * 100.0) / xmlString.Length();

    // consider using TThread::Queue() instead so that you don't block
    // the upload waiting for the UI to be updated...
    TThread::Synchronize(this, &UpdateProgressBarInternal);
}

void __fastcall UploadRouteThread::Execute()
{
    tcpClient->Connect();
    try
    {
        NextPacketSize nps;
        nps.PacketID = BasicPacket::DATA_UPLOAD;
        nps.size = xmlString.Length();
        tcpClient->IOHandler->Write(RawToBytes(&nps, sizeof(nps)));

        tcpClient->BeginWork(wmWrite, xmlString.Length());
        tcpClient->IOHandler->Write(RawToBytes(xmlString.c_str(), xmlString.Length()));
        tcpClient->EndWork(wmWrite);

        /* alternatively:
        TIdMemoryBufferStream *strm = new TIdMemoryBufferStream(xmlString.c_str(), xmlString.Length());
        try
        {
            // optional
            tcpClient->IOHandler->SendBufferSize = 256;

            // this calls (Begin|End)Work() internally...
            tcpClient->IOHandler->Write(strm, 0, false);
        }
        __finally
        {
            delete strm;
        }
        */
    }
    __finally
    {
        tcpClient->Disconnect();
    }
}

void __fastcall UploadRouteThread::UpdateProgressBarInternal()
{
    if (!TabbedwithNavigationForm->ProgressBar->Visible)
    {
        TabbedwithNavigationForm->ProgressBar->Visible = true;
        TabbedwithNavigationForm->ProgressBar->Max = 100;
    }

    TabbedwithNavigationForm->ProgressBar->Value = sent;
}