From: Automatic source maintenance Date: Tue, 24 Aug 2010 00:12:54 +0000 (-0600) Subject: SourceFormat Enforcement X-Git-Tag: take1~341 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=4cb2536f0d9cd228beb799c87e48657029641394;p=thirdparty%2Fsquid.git SourceFormat Enforcement --- diff --git a/src/BodyPipe.cc b/src/BodyPipe.cc index e967bda499..4b8b6bd261 100644 --- a/src/BodyPipe.cc +++ b/src/BodyPipe.cc @@ -42,8 +42,8 @@ public: typedef UnaryMemFunT Parent; BodyProducerDialer(const BodyProducer::Pointer &aProducer, - Parent::Method aHandler, BodyPipe::Pointer bp): - Parent(aProducer, aHandler, bp) {} + Parent::Method aHandler, BodyPipe::Pointer bp): + Parent(aProducer, aHandler, bp) {} virtual bool canDial(AsyncCall &call); }; @@ -57,8 +57,8 @@ public: typedef UnaryMemFunT Parent; BodyConsumerDialer(const BodyConsumer::Pointer &aConsumer, - Parent::Method aHandler, BodyPipe::Pointer bp): - Parent(aConsumer, aHandler, bp) {} + Parent::Method aHandler, BodyPipe::Pointer bp): + Parent(aConsumer, aHandler, bp) {} virtual bool canDial(AsyncCall &call); }; diff --git a/src/CommCalls.h b/src/CommCalls.h index e00754214a..84e4a72875 100644 --- a/src/CommCalls.h +++ b/src/CommCalls.h @@ -148,8 +148,8 @@ public: typedef void (C::*Method)(const Params &io); CommCbMemFunT(const CbcPointer &job, Method meth): JobDialer(job), - CommDialerParamsT(job.get()), - method(meth) {} + CommDialerParamsT(job.get()), + method(meth) {} virtual bool canDial(AsyncCall &c) { return JobDialer::canDial(c) && diff --git a/src/HttpVersion.h b/src/HttpVersion.h index 43952c91f1..4b90a8c811 100644 --- a/src/HttpVersion.h +++ b/src/HttpVersion.h @@ -68,12 +68,12 @@ public: bool operator <(const HttpVersion& that) const { return (this->major < that.major || - this->major == that.major && this->minor < that.minor); + this->major == that.major && this->minor < that.minor); } bool operator >(const HttpVersion& that) const { return (this->major > that.major || - this->major == that.major && this->minor > that.minor); + this->major == that.major && this->minor > that.minor); } bool operator <=(const HttpVersion& that) const { diff --git a/src/Server.cc b/src/Server.cc index a1eeee04dc..bc70bf2fd9 100644 --- a/src/Server.cc +++ b/src/Server.cc @@ -418,7 +418,7 @@ ServerStateData::sendMoreRequestBody() debugs(9,3, HERE << "will write " << buf.contentSize() << " request body bytes"); typedef CommCbMemFunT Dialer; requestSender = JobCallback(93,3, - Dialer, this, ServerStateData::sentRequestBody); + Dialer, this, ServerStateData::sentRequestBody); comm_write_mbuf(fd, &buf, requestSender); } else { debugs(9,3, HERE << "will wait for more request body bytes or eof"); @@ -544,7 +544,7 @@ ServerStateData::startAdaptation(const Adaptation::ServiceGroupPointer &group, H } adaptedHeadSource = initiateAdaptation( - new Adaptation::Iterator(vrep, cause, group)); + new Adaptation::Iterator(vrep, cause, group)); startedAdaptation = initiated(adaptedHeadSource); Must(startedAdaptation); } diff --git a/src/adaptation/Initiate.cc b/src/adaptation/Initiate.cc index dcec474770..ffba5bc923 100644 --- a/src/adaptation/Initiate.cc +++ b/src/adaptation/Initiate.cc @@ -19,7 +19,7 @@ public: typedef UnaryMemFunT Parent; AnswerDialer(const Parent::JobPointer &job, Parent::Method meth, - HttpMsg *msg): Parent(job, meth, msg) { HTTPMSGLOCK(arg1); } + HttpMsg *msg): Parent(job, meth, msg) { HTTPMSGLOCK(arg1); } AnswerDialer(const AnswerDialer &d): Parent(d) { HTTPMSGLOCK(arg1); } virtual ~AnswerDialer() { HTTPMSGUNLOCK(arg1); } @@ -74,7 +74,7 @@ void Adaptation::Initiate::sendAnswer(HttpMsg *msg) { assert(msg); CallJob(93, 5, __FILE__, __LINE__, "Initiator::noteAdaptationAnswer", - AnswerDialer(theInitiator, &Initiator::noteAdaptationAnswer, msg)); + AnswerDialer(theInitiator, &Initiator::noteAdaptationAnswer, msg)); clearInitiator(); } @@ -82,7 +82,7 @@ void Adaptation::Initiate::sendAnswer(HttpMsg *msg) void Adaptation::Initiate::tellQueryAborted(bool final) { CallJobHere1(93, 5, theInitiator, - Initiator, noteAdaptationQueryAbort, final); + Initiator, noteAdaptationQueryAbort, final); clearInitiator(); } diff --git a/src/adaptation/Iterator.cc b/src/adaptation/Iterator.cc index 57a277ea61..6f46121c38 100644 --- a/src/adaptation/Iterator.cc +++ b/src/adaptation/Iterator.cc @@ -15,8 +15,8 @@ Adaptation::Iterator::Iterator( - HttpMsg *aMsg, HttpRequest *aCause, - const ServiceGroupPointer &aGroup): + HttpMsg *aMsg, HttpRequest *aCause, + const ServiceGroupPointer &aGroup): AsyncJob("Iterator"), Adaptation::Initiate("Iterator"), theGroup(aGroup), @@ -69,7 +69,7 @@ void Adaptation::Iterator::step() debugs(93,5, HERE << "using adaptation service: " << service->cfg().key); theLauncher = initiateAdaptation( - service->makeXactLauncher(theMsg, theCause)); + service->makeXactLauncher(theMsg, theCause)); Must(initiated(theLauncher)); Must(!done()); } diff --git a/src/adaptation/ecap/ServiceRep.cc b/src/adaptation/ecap/ServiceRep.cc index 0a5e52dcd9..6d8566d4c6 100644 --- a/src/adaptation/ecap/ServiceRep.cc +++ b/src/adaptation/ecap/ServiceRep.cc @@ -58,7 +58,7 @@ bool Adaptation::Ecap::ServiceRep::wantsUrl(const String &urlPath) const Adaptation::Initiate * Adaptation::Ecap::ServiceRep::makeXactLauncher(HttpMsg *virgin, - HttpRequest *cause) + HttpRequest *cause) { Must(up()); XactionRep *rep = new XactionRep(virgin, cause, Pointer(this)); diff --git a/src/adaptation/ecap/XactionRep.cc b/src/adaptation/ecap/XactionRep.cc index 3bc8bf11ac..462dc160ed 100644 --- a/src/adaptation/ecap/XactionRep.cc +++ b/src/adaptation/ecap/XactionRep.cc @@ -15,8 +15,8 @@ CBDATA_NAMESPACED_CLASS_INIT(Adaptation::Ecap::XactionRep, XactionRep); Adaptation::Ecap::XactionRep::XactionRep( - HttpMsg *virginHeader, HttpRequest *virginCause, - const Adaptation::ServicePointer &aService): + HttpMsg *virginHeader, HttpRequest *virginCause, + const Adaptation::ServicePointer &aService): AsyncJob("Adaptation::Ecap::XactionRep"), Adaptation::Initiate("Adaptation::Ecap::XactionRep"), theService(aService), diff --git a/src/adaptation/icap/Launcher.cc b/src/adaptation/icap/Launcher.cc index a0fc7795fa..f6a417cf50 100644 --- a/src/adaptation/icap/Launcher.cc +++ b/src/adaptation/icap/Launcher.cc @@ -15,7 +15,7 @@ Adaptation::Icap::Launcher::Launcher(const char *aTypeName, - Adaptation::ServicePointer &aService): + Adaptation::ServicePointer &aService): AsyncJob(aTypeName), Adaptation::Initiate(aTypeName), theService(aService), theXaction(0), theLaunches(0) diff --git a/src/adaptation/icap/Launcher.h b/src/adaptation/icap/Launcher.h index a8f40be0f8..054b96bf98 100644 --- a/src/adaptation/icap/Launcher.h +++ b/src/adaptation/icap/Launcher.h @@ -129,7 +129,8 @@ private: inline std::ostream & -operator <<(std::ostream &os, const XactAbortInfo &xai) { +operator <<(std::ostream &os, const XactAbortInfo &xai) +{ return xai.print(os); } diff --git a/src/adaptation/icap/ModXact.cc b/src/adaptation/icap/ModXact.cc index 97c917097c..93b4da74c9 100644 --- a/src/adaptation/icap/ModXact.cc +++ b/src/adaptation/icap/ModXact.cc @@ -38,7 +38,7 @@ Adaptation::Icap::ModXact::State::State() } Adaptation::Icap::ModXact::ModXact(HttpMsg *virginHeader, - HttpRequest *virginCause, Adaptation::Icap::ServiceRep::Pointer &aService): + HttpRequest *virginCause, Adaptation::Icap::ServiceRep::Pointer &aService): AsyncJob("Adaptation::Icap::ModXact"), Adaptation::Icap::Xaction("Adaptation::Icap::ModXact", aService), virginConsumed(0), @@ -97,7 +97,7 @@ void Adaptation::Icap::ModXact::waitForService() state.serviceWaiting = true; typedef NullaryMemFunT Dialer; AsyncCall::Pointer call = JobCallback(93,5, - Dialer, this, Adaptation::Icap::ModXact::noteServiceReady); + Dialer, this, Adaptation::Icap::ModXact::noteServiceReady); service().callWhenReady(call); } diff --git a/src/adaptation/icap/ServiceRep.cc b/src/adaptation/icap/ServiceRep.cc index 806a6f3344..7f06646764 100644 --- a/src/adaptation/icap/ServiceRep.cc +++ b/src/adaptation/icap/ServiceRep.cc @@ -339,7 +339,7 @@ void Adaptation::Icap::ServiceRep::callException(const std::exception &e) { clearAdaptation(theOptionsFetcher); debugs(93,2, "ICAP probably failed to fetch options (" << e.what() << - ")" << status()); + ")" << status()); handleNewOptions(0); } @@ -361,7 +361,7 @@ void Adaptation::Icap::ServiceRep::startGettingOptions() // XXX: "this" here is "self"; works until refcounting API changes theOptionsFetcher = initiateAdaptation( - new Adaptation::Icap::OptXactLauncher(this)); + new Adaptation::Icap::OptXactLauncher(this)); // TODO: timeout in case Adaptation::Icap::OptXact never calls us back? // Such a timeout should probably be a generic AsyncStart feature. } @@ -429,7 +429,7 @@ Adaptation::Icap::ServiceRep::optionsFetchTime() const Adaptation::Initiate * Adaptation::Icap::ServiceRep::makeXactLauncher(HttpMsg *virgin, - HttpRequest *cause) + HttpRequest *cause) { return new Adaptation::Icap::ModXactLauncher(virgin, cause, this); } diff --git a/src/adaptation/icap/Xaction.cc b/src/adaptation/icap/Xaction.cc index e8bc9b0cb4..9c2784eec0 100644 --- a/src/adaptation/icap/Xaction.cc +++ b/src/adaptation/icap/Xaction.cc @@ -25,7 +25,7 @@ static PconnPool *icapPconnPool = new PconnPool("ICAP Servers"); //CBDATA_NAMESPACED_CLASS_INIT(Adaptation::Icap, Xaction); Adaptation::Icap::Xaction::Xaction(const char *aTypeName, - Adaptation::Icap::ServiceRep::Pointer &aService): + Adaptation::Icap::ServiceRep::Pointer &aService): AsyncJob(aTypeName), Adaptation::Initiate(aTypeName), icapRequest(NULL), @@ -139,18 +139,18 @@ void Adaptation::Icap::Xaction::openConnection() // TODO: service bypass status may differ from that of a transaction typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(93, 5, - TimeoutDialer, this, Adaptation::Icap::Xaction::noteCommTimedout); + TimeoutDialer, this, Adaptation::Icap::Xaction::noteCommTimedout); commSetTimeout(connection, TheConfig.connect_timeout( service().cfg().bypass), timeoutCall); typedef CommCbMemFunT CloseDialer; closer = JobCallback(93, 5, - CloseDialer, this, Adaptation::Icap::Xaction::noteCommClosed); + CloseDialer, this, Adaptation::Icap::Xaction::noteCommClosed); comm_add_close_handler(connection, closer); typedef CommCbMemFunT ConnectDialer; connector = JobCallback(93,3, - ConnectDialer, this, Adaptation::Icap::Xaction::noteCommConnected); + ConnectDialer, this, Adaptation::Icap::Xaction::noteCommConnected); commConnectStart(connection, s.cfg().host.termedBuf(), s.cfg().port, connector); } @@ -234,7 +234,7 @@ void Adaptation::Icap::Xaction::scheduleWrite(MemBuf &buf) // comm module will free the buffer typedef CommCbMemFunT Dialer; writer = JobCallback(93,3, - Dialer, this, Adaptation::Icap::Xaction::noteCommWrote); + Dialer, this, Adaptation::Icap::Xaction::noteCommWrote); comm_write_mbuf(connection, &buf, writer); updateTimeout(); @@ -316,7 +316,7 @@ void Adaptation::Icap::Xaction::updateTimeout() // TODO: service bypass status may differ from that of a transaction typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer call = JobCallback(93,5, - TimeoutDialer, this, Adaptation::Icap::Xaction::noteCommTimedout); + TimeoutDialer, this, Adaptation::Icap::Xaction::noteCommTimedout); commSetTimeout(connection, TheConfig.io_timeout(service().cfg().bypass), call); @@ -340,7 +340,7 @@ void Adaptation::Icap::Xaction::scheduleRead() */ typedef CommCbMemFunT Dialer; reader = JobCallback(93,3, - Dialer, this, Adaptation::Icap::Xaction::noteCommRead); + Dialer, this, Adaptation::Icap::Xaction::noteCommRead); comm_read(connection, commBuf, readBuf.spaceSize(), reader); updateTimeout(); @@ -474,11 +474,11 @@ void Adaptation::Icap::Xaction::tellQueryAborted() { if (theInitiator.set()) { Adaptation::Icap::XactAbortInfo abortInfo(icapRequest, icapReply, - retriable(), repeatable()); + retriable(), repeatable()); Launcher *launcher = dynamic_cast(theInitiator.get()); // launcher may be nil if initiator is invalid CallJobHere1(91,5, CbcPointer(launcher), - Launcher, noteXactAbort, abortInfo); + Launcher, noteXactAbort, abortInfo); clearInitiator(); } } diff --git a/src/base/AsyncJob.cc b/src/base/AsyncJob.cc index ab8b0ac819..3fd5557138 100644 --- a/src/base/AsyncJob.cc +++ b/src/base/AsyncJob.cc @@ -50,7 +50,7 @@ void AsyncJob::deleteThis(const char *aReason) debugs(93, 5, typeName << " will delete this, reason: " << stopReason); CbcPointer self(this); AsyncCall::Pointer fakeCall = asyncCall(93,4, "FAKE-deleteThis", - JobMemFun(self, &AsyncJob::deleteThis, aReason)); + JobMemFun(self, &AsyncJob::deleteThis, aReason)); inCall = fakeCall; callEnd(); // delete fakeCall; diff --git a/src/base/AsyncJobCalls.h b/src/base/AsyncJobCalls.h index 1d6ebe8d9c..ef9a285f4b 100644 --- a/src/base/AsyncJobCalls.h +++ b/src/base/AsyncJobCalls.h @@ -90,7 +90,7 @@ class NullaryMemFunT: public JobDialer public: typedef void (Job::*Method)(); explicit NullaryMemFunT(const CbcPointer &aJob, Method aMethod): - JobDialer(aJob), method(aMethod) {} + JobDialer(aJob), method(aMethod) {} virtual void print(std::ostream &os) const { os << "()"; } @@ -107,7 +107,7 @@ class UnaryMemFunT: public JobDialer public: typedef void (Job::*Method)(Argument1); explicit UnaryMemFunT(const CbcPointer &aJob, Method aMethod, - const Argument1 &anArg1): JobDialer(aJob), + const Argument1 &anArg1): JobDialer(aJob), method(aMethod), arg1(anArg1) {} virtual void print(std::ostream &os) const { os << '(' << arg1 << ')'; } @@ -137,7 +137,7 @@ JobMemFun(const CbcPointer &job, typename NullaryMemFunT::Method method) template UnaryMemFunT JobMemFun(const CbcPointer &job, typename UnaryMemFunT::Method method, - Argument1 arg1) + Argument1 arg1) { return UnaryMemFunT(job, method, arg1); } diff --git a/src/base/CbcPointer.h b/src/base/CbcPointer.h index 62a9463b86..622d963f97 100644 --- a/src/base/CbcPointer.h +++ b/src/base/CbcPointer.h @@ -11,7 +11,7 @@ /** \ingroup CBDATAAPI * - * Safely points to a cbdata-protected class (cbc), such as an AsyncJob. + * Safely points to a cbdata-protected class (cbc), such as an AsyncJob. * When a cbc we communicate with disappears without * notice or a notice has not reached us yet, this class prevents * dereferencing the pointer to the gone cbc object. @@ -66,7 +66,8 @@ private: template inline -std::ostream &operator <<(std::ostream &os, const CbcPointer &p) { +std::ostream &operator <<(std::ostream &os, const CbcPointer &p) +{ return p.print(os); } @@ -148,7 +149,8 @@ CbcPointer::operator ->() const } template -std::ostream &CbcPointer::print(std::ostream &os) const { +std::ostream &CbcPointer::print(std::ostream &os) const +{ return os << cbc << '/' << lock; } diff --git a/src/client_side.cc b/src/client_side.cc index dc6feaad7a..96c6348ea7 100644 --- a/src/client_side.cc +++ b/src/client_side.cc @@ -243,7 +243,7 @@ ConnStateData::readSomeData() typedef CommCbMemFunT Dialer; reader = JobCallback(33, 5, - Dialer, this, ConnStateData::clientReadRequest); + Dialer, this, ConnStateData::clientReadRequest); comm_read(fd, in.addressToReadInto(), getAvailableBufferLength(), reader); } @@ -1361,7 +1361,7 @@ clientSocketRecipient(clientStreamNode * node, ClientHttpRequest * http, // After sending Transfer-Encoding: chunked (at least), always send // the last-chunk if there was no error, ignoring responseFinishedOrFailed. const bool mustSendLastChunk = http->request->flags.chunked_reply && - !http->request->flags.stream_error && !context->startOfOutput(); + !http->request->flags.stream_error && !context->startOfOutput(); if (responseFinishedOrFailed(rep, receivedData) && !mustSendLastChunk) { context->writeComplete(fd, NULL, 0, COMM_OK); PROF_stop(clientSocketRecipient); @@ -1423,7 +1423,7 @@ ConnStateData::readNextRequest() */ typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(33, 5, - TimeoutDialer, this, ConnStateData::requestTimeout); + TimeoutDialer, this, ConnStateData::requestTimeout); commSetTimeout(fd, Config.Timeout.persistent_request, timeoutCall); readSomeData(); @@ -3123,7 +3123,7 @@ httpAccept(int sock, int newfd, ConnectionDetail *details, typedef CommCbMemFunT Dialer; AsyncCall::Pointer call = JobCallback(33, 5, - Dialer, connState, ConnStateData::connStateClosed); + Dialer, connState, ConnStateData::connStateClosed); comm_add_close_handler(newfd, call); if (Config.onoff.log_fqdn) @@ -3131,7 +3131,7 @@ httpAccept(int sock, int newfd, ConnectionDetail *details, typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(33, 5, - TimeoutDialer, connState, ConnStateData::requestTimeout); + TimeoutDialer, connState, ConnStateData::requestTimeout); commSetTimeout(newfd, Config.Timeout.read, timeoutCall); #if USE_IDENT @@ -3334,7 +3334,7 @@ httpsAccept(int sock, int newfd, ConnectionDetail *details, newfd, &s->http); typedef CommCbMemFunT Dialer; AsyncCall::Pointer call = JobCallback(33, 5, - Dialer, connState, ConnStateData::connStateClosed); + Dialer, connState, ConnStateData::connStateClosed); comm_add_close_handler(newfd, call); if (Config.onoff.log_fqdn) @@ -3922,7 +3922,7 @@ void ConnStateData::pinConnection(int pinning_fd, HttpRequest *request, struct p typedef CommCbMemFunT Dialer; pinning.closeHandler = JobCallback(33, 5, - Dialer, this, ConnStateData::clientPinnedConnectionClosed); + Dialer, this, ConnStateData::clientPinnedConnectionClosed); comm_add_close_handler(pinning_fd, pinning.closeHandler); } diff --git a/src/client_side_reply.cc b/src/client_side_reply.cc index d5a63c4a26..339e3670c8 100644 --- a/src/client_side_reply.cc +++ b/src/client_side_reply.cc @@ -1372,7 +1372,7 @@ clientReplyContext::buildReplyHeader() #endif const bool maySendChunkedReply = !request->multipartRangeRequest() && - (request->http_ver >= HttpVersion(1, 1)); + (request->http_ver >= HttpVersion(1, 1)); /* Check whether we should send keep-alive */ if (!Config.onoff.error_pconns && reply->sline.status >= 400 && !request->flags.must_keepalive) { @@ -1397,8 +1397,8 @@ clientReplyContext::buildReplyHeader() // Decide if we send chunked reply if (maySendChunkedReply && - request->flags.proxy_keepalive && - reply->bodySize(request->method) < 0) { + request->flags.proxy_keepalive && + reply->bodySize(request->method) < 0) { debugs(88, 3, "clientBuildReplyHeader: chunked reply"); request->flags.chunked_reply = 1; hdr->putStr(HDR_TRANSFER_ENCODING, "chunked"); diff --git a/src/client_side_request.cc b/src/client_side_request.cc index 211e47f0b3..3fbe0fada2 100644 --- a/src/client_side_request.cc +++ b/src/client_side_request.cc @@ -1374,7 +1374,7 @@ ClientHttpRequest::startAdaptation(const Adaptation::ServiceGroupPointer &g) assert(!virginHeadSource); assert(!adaptedBodySource); virginHeadSource = initiateAdaptation( - new Adaptation::Iterator(request, NULL, g)); + new Adaptation::Iterator(request, NULL, g)); // we could try to guess whether we can bypass this adaptation // initiation failure, but it should not really happen diff --git a/src/ftp.cc b/src/ftp.cc index 17cf80355f..758bc5ec38 100644 --- a/src/ftp.cc +++ b/src/ftp.cc @@ -480,7 +480,7 @@ FtpStateData::FtpStateData(FwdState *theFwdState) : AsyncJob("FtpStateData"), Se typedef CommCbMemFunT Dialer; AsyncCall::Pointer closer = JobCallback(9, 5, - Dialer, this, FtpStateData::ctrlClosed); + Dialer, this, FtpStateData::ctrlClosed); ctrl.opened(theFwdState->server_fd, closer); if (request->method == METHOD_PUT) @@ -1159,14 +1159,14 @@ FtpStateData::maybeReadVirginBody() typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, this, FtpStateData::ftpTimeout); + TimeoutDialer, this, FtpStateData::ftpTimeout); commSetTimeout(data.fd, Config.Timeout.read, timeoutCall); debugs(9,5,HERE << "queueing read on FD " << data.fd); typedef CommCbMemFunT Dialer; entry->delayAwareRead(data.fd, data.readBuf->space(), read_sz, - JobCallback(9, 5, Dialer, this, FtpStateData::dataRead)); + JobCallback(9, 5, Dialer, this, FtpStateData::dataRead)); } void @@ -1216,7 +1216,7 @@ FtpStateData::dataRead(const CommIoCbParams &io) if (ignoreErrno(io.xerrno)) { typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, this, FtpStateData::ftpTimeout); + TimeoutDialer, this, FtpStateData::ftpTimeout); commSetTimeout(io.fd, Config.Timeout.read, timeoutCall); maybeReadVirginBody(); @@ -1529,7 +1529,7 @@ FtpStateData::writeCommand(const char *buf) typedef CommCbMemFunT Dialer; AsyncCall::Pointer call = JobCallback(9, 5, - Dialer, this, FtpStateData::ftpWriteCommandCallback); + Dialer, this, FtpStateData::ftpWriteCommandCallback); comm_write(ctrl.fd, ctrl.last_command, strlen(ctrl.last_command), @@ -1667,7 +1667,7 @@ FtpStateData::scheduleReadControlReply(int buffered_ok) /* XXX What about Config.Timeout.read? */ typedef CommCbMemFunT Dialer; AsyncCall::Pointer reader = JobCallback(9, 5, - Dialer, this, FtpStateData::ftpReadControlReply); + Dialer, this, FtpStateData::ftpReadControlReply); comm_read(ctrl.fd, ctrl.buf + ctrl.offset, ctrl.size - ctrl.offset, reader); /* * Cancel the timeout on the Data socket (if any) and @@ -1681,7 +1681,7 @@ FtpStateData::scheduleReadControlReply(int buffered_ok) typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, this, FtpStateData::ftpTimeout); + TimeoutDialer, this, FtpStateData::ftpTimeout); commSetTimeout(ctrl.fd, Config.Timeout.read, timeoutCall); } @@ -2565,7 +2565,7 @@ ftpSendPassive(FtpStateData * ftpState) */ typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, ftpState, FtpStateData::ftpTimeout); + TimeoutDialer, ftpState, FtpStateData::ftpTimeout); commSetTimeout(ftpState->data.fd, 15, timeoutCall); } @@ -2947,7 +2947,7 @@ void FtpStateData::ftpAcceptDataConnection(const CommAcceptCbParams &io) /* we are ony accepting once, so need to re-open the listener socket. */ typedef CommCbMemFunT acceptDialer; AsyncCall::Pointer acceptCall = JobCallback(11, 5, - acceptDialer, this, FtpStateData::ftpAcceptDataConnection); + acceptDialer, this, FtpStateData::ftpAcceptDataConnection); data.listener = new Comm::ListenStateData(data.fd, acceptCall, false); return; } @@ -2978,7 +2978,7 @@ void FtpStateData::ftpAcceptDataConnection(const CommAcceptCbParams &io) typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, this, FtpStateData::ftpTimeout); + TimeoutDialer, this, FtpStateData::ftpTimeout); commSetTimeout(data.fd, Config.Timeout.read, timeoutCall); /*\todo XXX We should have a flag to track connect state... @@ -3071,7 +3071,7 @@ void FtpStateData::readStor() typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, this, FtpStateData::ftpTimeout); + TimeoutDialer, this, FtpStateData::ftpTimeout); commSetTimeout(data.fd, Config.Timeout.read, timeoutCall); @@ -3083,7 +3083,7 @@ void FtpStateData::readStor() debugs(9, 3, "ftpReadStor: accepting data channel"); typedef CommCbMemFunT acceptDialer; AsyncCall::Pointer acceptCall = JobCallback(11, 5, - acceptDialer, this, FtpStateData::ftpAcceptDataConnection); + acceptDialer, this, FtpStateData::ftpAcceptDataConnection); data.listener = new Comm::ListenStateData(data.fd, acceptCall, false); } else { @@ -3219,7 +3219,7 @@ ftpReadList(FtpStateData * ftpState) /* Accept data channel */ typedef CommCbMemFunT acceptDialer; AsyncCall::Pointer acceptCall = JobCallback(11, 5, - acceptDialer, ftpState, FtpStateData::ftpAcceptDataConnection); + acceptDialer, ftpState, FtpStateData::ftpAcceptDataConnection); ftpState->data.listener = new Comm::ListenStateData(ftpState->data.fd, acceptCall, false); /* @@ -3231,7 +3231,7 @@ ftpReadList(FtpStateData * ftpState) typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, ftpState,FtpStateData::ftpTimeout); + TimeoutDialer, ftpState,FtpStateData::ftpTimeout); commSetTimeout(ftpState->data.fd, Config.Timeout.read, timeoutCall); return; } else if (!ftpState->flags.tried_nlst && code > 300) { @@ -3281,7 +3281,7 @@ ftpReadRetr(FtpStateData * ftpState) /* Accept data channel */ typedef CommCbMemFunT acceptDialer; AsyncCall::Pointer acceptCall = JobCallback(11, 5, - acceptDialer, ftpState, FtpStateData::ftpAcceptDataConnection); + acceptDialer, ftpState, FtpStateData::ftpAcceptDataConnection); ftpState->data.listener = new Comm::ListenStateData(ftpState->data.fd, acceptCall, false); /* * Cancel the timeout on the Control socket and establish one @@ -3292,7 +3292,7 @@ ftpReadRetr(FtpStateData * ftpState) typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(9, 5, - TimeoutDialer, ftpState,FtpStateData::ftpTimeout); + TimeoutDialer, ftpState,FtpStateData::ftpTimeout); commSetTimeout(ftpState->data.fd, Config.Timeout.read, timeoutCall); } else if (code >= 300) { if (!ftpState->flags.try_slash_hack) { diff --git a/src/http.cc b/src/http.cc index 31f5ad62fa..349ea4c1bb 100644 --- a/src/http.cc +++ b/src/http.cc @@ -143,7 +143,7 @@ HttpStateData::HttpStateData(FwdState *theFwdState) : AsyncJob("HttpStateData"), */ typedef CommCbMemFunT Dialer; closeHandler = JobCallback(9, 5, - Dialer, this, HttpStateData::httpStateConnClosed); + Dialer, this, HttpStateData::httpStateConnClosed); comm_add_close_handler(fd, closeHandler); } @@ -1403,7 +1403,7 @@ HttpStateData::maybeReadVirginBody() flags.do_next_read = 0; typedef CommCbMemFunT Dialer; entry->delayAwareRead(fd, readBuf->space(read_size), read_size, - JobCallback(11, 5, Dialer, this, HttpStateData::readReply)); + JobCallback(11, 5, Dialer, this, HttpStateData::readReply)); } } @@ -1447,7 +1447,7 @@ HttpStateData::sendComplete(const CommIoCbParams &io) */ typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(11, 5, - TimeoutDialer, this, HttpStateData::httpTimeout); + TimeoutDialer, this, HttpStateData::httpTimeout); commSetTimeout(fd, Config.Timeout.read, timeoutCall); @@ -1989,7 +1989,7 @@ HttpStateData::sendRequest() typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = JobCallback(11, 5, - TimeoutDialer, this, HttpStateData::httpTimeout); + TimeoutDialer, this, HttpStateData::httpTimeout); commSetTimeout(fd, Config.Timeout.lifetime, timeoutCall); flags.do_next_read = 1; maybeReadVirginBody(); @@ -1999,12 +1999,12 @@ HttpStateData::sendRequest() return false; typedef CommCbMemFunT Dialer; requestSender = JobCallback(11,5, - Dialer, this, HttpStateData::sentRequestBody); + Dialer, this, HttpStateData::sentRequestBody); } else { assert(!requestBodySource); typedef CommCbMemFunT Dialer; requestSender = JobCallback(11,5, - Dialer, this, HttpStateData::sendComplete); + Dialer, this, HttpStateData::sendComplete); } if (_peer != NULL) { @@ -2099,7 +2099,7 @@ HttpStateData::doneSendingRequestBody() typedef CommCbMemFunT Dialer; AsyncCall::Pointer call = JobCallback(11,5, - Dialer, this, HttpStateData::sendComplete); + Dialer, this, HttpStateData::sendComplete); comm_write(fd, "\r\n", 2, call); } return; diff --git a/src/ipc/Port.cc b/src/ipc/Port.cc index c3075800d1..e4a4ab33b7 100644 --- a/src/ipc/Port.cc +++ b/src/ipc/Port.cc @@ -32,7 +32,7 @@ void Ipc::Port::listen() buf.prepForReading(); typedef CommCbMemFunT Dialer; AsyncCall::Pointer readHandler = JobCallback(54, 6, - Dialer, this, Port::noteRead); + Dialer, this, Port::noteRead); comm_read(fd(), buf.raw(), buf.size(), readHandler); } diff --git a/src/ipc/UdsOp.cc b/src/ipc/UdsOp.cc index 1c148b02fe..92383e790a 100644 --- a/src/ipc/UdsOp.cc +++ b/src/ipc/UdsOp.cc @@ -105,7 +105,7 @@ void Ipc::UdsSender::write() debugs(54, 5, HERE); typedef CommCbMemFunT Dialer; AsyncCall::Pointer writeHandler = JobCallback(54, 5, - Dialer, this, UdsSender::wrote); + Dialer, this, UdsSender::wrote); comm_write(fd(), message.raw(), message.size(), writeHandler); writing = true; }