RequestSender.handleCHKDataFound.BlockReceiverCompletion

// Line 1100 of https://github.com/freenet/fred/blob/3fcc2d1b3a0d5ccbeb73928d6b267440e5b4c17b/src/freenet/node/RequestSender.java#L1

final BlockReceiver br = new BlockReceiver(node.usm, next, uid, prb, this, node.getTicker(), true, realTimeFlag, myTimeoutHandler, true);

        if(failNow) {
            if(logMINOR) Logger.minor(this, "Terminating forked transfer on "+this+" from "+next);
            prb.abort(RetrievalException.CANCELLED_BY_RECEIVER, "Cancelling fork", true);
            br.receive(new BlockReceiverCompletion() {

                @Override
                public void blockReceived(byte[] buf) {
                    if(!wasFork)
                        origTag.senderTransferEnds((NodeCHK)key, RequestSender.this);
                    next.noLongerRoutingTo(origTag, false);
                }

                @Override
                public void blockReceiveFailed(RetrievalException e) {
                    if(!wasFork)
                        origTag.senderTransferEnds((NodeCHK)key, RequestSender.this);
                    next.noLongerRoutingTo(origTag, false);
                }

            });
            return;
        }

        if(logMINOR) Logger.minor(this, "Receiving data");
        if(!wasFork) {
            synchronized(this) {
                transferringFrom = next;
            }
        } else
            if(logMINOR) Logger.minor(this, "Receiving data from fork");

        receivingAsync = true;
        br.receive(new BlockReceiverCompletion() {

            @Override
            public void blockReceived(byte[] data) {
                try {
                    long tEnd = System.currentTimeMillis();
                    transferTime = tEnd - tStart;
                    boolean haveSetPRB = false;
                    synchronized(RequestSender.this) {
                        transferringFrom = null;
                        if(RequestSender.this.prb == null || !RequestSender.this.prb.allReceivedAndNotAborted()) {
                            RequestSender.this.prb = prb;
                            haveSetPRB = true;
                        }
                    }
                    if(!wasFork)
                        origTag.senderTransferEnds((NodeCHK)key, RequestSender.this);
                    next.transferSuccess(realTimeFlag);
                    next.successNotOverload(realTimeFlag);
                    node.nodeStats.successfulBlockReceive(realTimeFlag, source == null);
                    if(logMINOR) Logger.minor(this, "Received data");
                    // Received data
                    try {
                        verifyAndCommit(waiter.headers, data);
                        if(logMINOR) Logger.minor(this, "Written to store");
                    } catch (KeyVerifyException e1) {
                        Logger.normal(this, "Got data but verify failed: "+e1, e1);
                        node.failureTable.onFinalFailure(key, next, htl, origHTL, FailureTable.RECENTLY_FAILED_TIME, FailureTable.REJECT_TIME, source);
                        if(!wasFork)
                            finish(VERIFY_FAILURE, next, false);
                        else
                            next.noLongerRoutingTo(origTag, false);
                        return;
                    }
                    if(haveSetPRB) // It was a fork, so we didn't immediately send the data.
                        fireCHKTransferBegins();
                    finish(SUCCESS, next, false);
                } catch (Throwable t) {
                    Logger.error(this, "Failed on "+this, t);
                    if(!wasFork)
                        finish(INTERNAL_ERROR, next, true);
                } finally {
                    if(wasFork)
                        next.noLongerRoutingTo(origTag, false);
                }
            }