Ignore:
Timestamp:
Jan 9, 2017, 11:09:38 AM (2 years ago)
Author:
jrpelegrina
Message:

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/engine/engineprivate.cpp

    r130 r3185  
    33#include "directorycache.h"
    44#include "engineprivate.h"
    5 #include "event_loop.h"
    65#include "ftpcontrolsocket.h"
    76#include "httpcontrolsocket.h"
     
    1110#include "sftpcontrolsocket.h"
    1211
     12#include <libfilezilla/event_loop.hpp>
     13
    1314#include <algorithm>
    1415
    15 mutex CFileZillaEnginePrivate::mutex_;
     16fz::mutex CFileZillaEnginePrivate::mutex_;
    1617std::vector<CFileZillaEnginePrivate*> CFileZillaEnginePrivate::m_engineList;
    1718std::atomic_int CFileZillaEnginePrivate::m_activeStatus[2] = {{0}, {0}};
     
    1920
    2021CFileZillaEnginePrivate::CFileZillaEnginePrivate(CFileZillaEngineContext& context, CFileZillaEngine& parent)
    21         : CEventHandler(context.GetEventLoop())
     22        : event_handler(context.GetEventLoop())
    2223        , transfer_status_(*this)
    2324        , m_options(context.GetOptions())
     
    3031
    3132        {
    32                 scoped_lock lock(mutex_);
     33                fz::scoped_lock lock(mutex_);
    3334                static int id = 0;
    3435                m_engine_id = ++id;
     
    3940        {
    4041                bool queue_logs = ShouldQueueLogsFromOptions();
    41                 scoped_lock lock(notification_mutex_);
     42                fz::scoped_lock lock(notification_mutex_);
    4243                queue_logs_ = queue_logs;
    4344        }
     
    5859CFileZillaEnginePrivate::~CFileZillaEnginePrivate()
    5960{
    60         RemoveHandler();
     61        remove_handler();
    6162        m_maySendNotificationEvent = false;
    6263
     
    101102bool CFileZillaEnginePrivate::IsBusy() const
    102103{
    103         scoped_lock lock(mutex_);
     104        fz::scoped_lock lock(mutex_);
    104105        return m_pCurrentCommand != 0;
    105106}
     
    107108bool CFileZillaEnginePrivate::IsConnected() const
    108109{
    109         scoped_lock lock(mutex_);
     110        fz::scoped_lock lock(mutex_);
    110111        if (!m_pControlSocket)
    111112                return false;
     
    116117const CCommand *CFileZillaEnginePrivate::GetCurrentCommand() const
    117118{
    118         scoped_lock lock(mutex_);
     119        fz::scoped_lock lock(mutex_);
    119120        return m_pCurrentCommand.get();
    120121}
     
    122123Command CFileZillaEnginePrivate::GetCurrentCommandId() const
    123124{
    124         scoped_lock lock(mutex_);
     125        fz::scoped_lock lock(mutex_);
    125126        if (!m_pCurrentCommand)
    126127                return Command::none;
     
    132133{
    133134        {
    134                 scoped_lock lock(notification_mutex_);
     135                fz::scoped_lock lock(notification_mutex_);
    135136                m_NotificationList.push_back(pNotification);
    136137
     
    146147void CFileZillaEnginePrivate::AddLogNotification(CLogmsgNotification *pNotification)
    147148{
    148         scoped_lock lock(notification_mutex_);
     149        fz::scoped_lock lock(notification_mutex_);
    149150
    150151        if (pNotification->msgType == MessageType::Error) {
     
    168169{
    169170        {
    170                 scoped_lock lock(notification_mutex_);
     171                fz::scoped_lock lock(notification_mutex_);
    171172                m_NotificationList.insert(m_NotificationList.end(), queued_logs_.begin(), queued_logs_.end());
    172173                queued_logs_.clear();
     
    187188void CFileZillaEnginePrivate::ClearQueuedLogs(bool reset_flag)
    188189{
    189         scoped_lock lock(notification_mutex_);
     190        fz::scoped_lock lock(notification_mutex_);
    190191
    191192        for (auto msg : queued_logs_) {
     
    201202int CFileZillaEnginePrivate::ResetOperation(int nErrorCode)
    202203{
    203         scoped_lock lock(mutex_);
     204        fz::scoped_lock lock(mutex_);
    204205        m_pLogging->LogMessage(MessageType::Debug_Debug, _T("CFileZillaEnginePrivate::ResetOperation(%d)"), nErrorCode);
    205206
     
    227228                                                        delay = 1;
    228229                                                m_pLogging->LogMessage(MessageType::Status, _("Waiting to retry..."));
    229                                                 StopTimer(m_retryTimer);
    230                                                 m_retryTimer = AddTimer(duration::from_milliseconds(delay), true);
     230                                                stop_timer(m_retryTimer);
     231                                                m_retryTimer = add_timer(fz::duration::from_milliseconds(delay), true);
    231232                                                return FZ_REPLY_WOULDBLOCK;
    232233                                        }
     
    267268unsigned int CFileZillaEnginePrivate::GetNextAsyncRequestNumber()
    268269{
    269         scoped_lock lock(notification_mutex_);
     270        fz::scoped_lock lock(notification_mutex_);
    270271        return ++m_asyncRequestCounter;
    271272}
     
    327328                                                if (!avoid) {
    328329                                                        m_lastListDir = pListing->path;
    329                                                         m_lastListTime = CMonotonicClock::now();
     330                                                        m_lastListTime = fz::monotonic_clock::now();
    330331                                                        CDirectoryListingNotification *pNotification = new CDirectoryListingNotification(pListing->path);
    331332                                                        AddNotification(pNotification);
     
    353354{
    354355        {
    355                 scoped_lock lock(notification_mutex_);
     356                fz::scoped_lock lock(notification_mutex_);
    356357                queue_logs_ = false;
    357358        }
     
    392393void CFileZillaEnginePrivate::SendDirectoryListingNotification(const CServerPath& path, bool onList, bool modified, bool failed)
    393394{
    394         scoped_lock lock(mutex_);
     395        fz::scoped_lock lock(mutex_);
    395396
    396397        wxASSERT(m_pControlSocket);
     
    403404        if (failed) {
    404405                AddNotification(new CDirectoryListingNotification(path, false, true));
    405                 m_lastListTime = CMonotonicClock::now();
     406                m_lastListTime = fz::monotonic_clock::now();
    406407
    407408                // On failed messages, we don't notify other engines
     
    409410        }
    410411
    411         CMonotonicClock changeTime;
     412        fz::monotonic_clock changeTime;
    412413        if (!directory_cache_.GetChangeTime(changeTime, *pOwnServer, path))
    413414                return;
     
    443444void CFileZillaEnginePrivate::RegisterFailedLoginAttempt(const CServer& server, bool critical)
    444445{
    445         scoped_lock lock(mutex_);
     446        fz::scoped_lock lock(mutex_);
    446447        std::list<t_failedLogins>::iterator iter = m_failedLogins.begin();
    447448        while (iter != m_failedLogins.end()) {
    448                 duration const span = CDateTime::Now() - iter->time;
     449                fz::duration const span = fz::datetime::now() - iter->time;
    449450                if (span.get_seconds() >= m_options.GetOptionVal(OPTION_RECONNECTDELAY) ||
    450451                        iter->server == server || (!critical && (iter->server.GetHost() == server.GetHost() && iter->server.GetPort() == server.GetPort())))
     
    460461        t_failedLogins failure;
    461462        failure.server = server;
    462         failure.time = CDateTime::Now();
     463        failure.time = fz::datetime::now();
    463464        failure.critical = critical;
    464465        m_failedLogins.push_back(failure);
     
    467468unsigned int CFileZillaEnginePrivate::GetRemainingReconnectDelay(const CServer& server)
    468469{
    469         scoped_lock lock(mutex_);
     470        fz::scoped_lock lock(mutex_);
    470471        std::list<t_failedLogins>::iterator iter = m_failedLogins.begin();
    471472        while (iter != m_failedLogins.end()) {
    472                 duration const span = CDateTime::Now() - iter->time;
     473                fz::duration const span = fz::datetime::now() - iter->time;
    473474                const int delay = m_options.GetOptionVal(OPTION_RECONNECTDELAY);
    474475                if (span.get_seconds() >= delay) {
     
    508509int CFileZillaEnginePrivate::ContinueConnect()
    509510{
    510         scoped_lock lock(mutex_);
     511        fz::scoped_lock lock(mutex_);
    511512
    512513        if (!m_pCurrentCommand || m_pCurrentCommand->GetId() != Command::connect) {
     
    520521        if (delay) {
    521522                m_pLogging->LogMessage(MessageType::Status, wxPLURAL("Delaying connection for %d second due to previously failed connection attempt...", "Delaying connection for %d seconds due to previously failed connection attempt...", (delay + 999) / 1000), (delay + 999) / 1000);
    522                 StopTimer(m_retryTimer);
    523                 m_retryTimer = AddTimer(duration::from_milliseconds(delay), true);
     523                stop_timer(m_retryTimer);
     524                m_retryTimer = add_timer(fz::duration::from_milliseconds(delay), true);
    524525                return FZ_REPLY_WOULDBLOCK;
    525526        }
     
    554555void CFileZillaEnginePrivate::InvalidateCurrentWorkingDirs(const CServerPath& path)
    555556{
    556         scoped_lock lock(mutex_);
     557        fz::scoped_lock lock(mutex_);
    557558
    558559        wxASSERT(m_pControlSocket);
     
    575576}
    576577
    577 void CFileZillaEnginePrivate::operator()(CEventBase const& ev)
    578 {
    579         scoped_lock lock(mutex_);
    580 
    581         Dispatch<CFileZillaEngineEvent, CCommandEvent, CAsyncRequestReplyEvent, CTimerEvent>(ev, this,
     578void CFileZillaEnginePrivate::operator()(fz::event_base const& ev)
     579{
     580        fz::scoped_lock lock(mutex_);
     581
     582        fz::dispatch<CFileZillaEngineEvent, CCommandEvent, CAsyncRequestReplyEvent, fz::timer_event>(ev, this,
    582583                &CFileZillaEnginePrivate::OnEngineEvent,
    583584                &CFileZillaEnginePrivate::OnCommandEvent,
     
    606607void CFileZillaEnginePrivate::OnCommandEvent()
    607608{
    608         scoped_lock lock(mutex_);
     609        fz::scoped_lock lock(mutex_);
    609610
    610611        if (m_pCurrentCommand) {
     
    664665void CFileZillaEnginePrivate::DoCancel()
    665666{
    666         scoped_lock lock(mutex_);
     667        fz::scoped_lock lock(mutex_);
    667668        if (!IsBusy())
    668669                return;
     
    675676                m_pCurrentCommand.reset();
    676677
    677                 StopTimer(m_retryTimer);
     678                stop_timer(m_retryTimer);
    678679                m_retryTimer = 0;
    679680
     
    703704        bool match;
    704705        {
    705                 scoped_lock l(notification_mutex_);
     706                fz::scoped_lock l(notification_mutex_);
    706707                match = reply->requestNumber == m_asyncRequestCounter;
    707708        }
     
    712713void CFileZillaEnginePrivate::OnSetAsyncRequestReplyEvent(std::unique_ptr<CAsyncRequestNotification> const& reply)
    713714{
    714         scoped_lock lock(mutex_);
     715        fz::scoped_lock lock(mutex_);
    715716        if (!CheckAsyncRequestReplyPreconditions(reply)) {
    716717                return;
     
    723724int CFileZillaEnginePrivate::Init(wxEvtHandler *pEventHandler)
    724725{
    725         scoped_lock lock(mutex_);
     726        fz::scoped_lock lock(mutex_);
    726727        m_pEventHandler = pEventHandler;
    727728        return FZ_REPLY_OK;
     
    730731int CFileZillaEnginePrivate::Execute(const CCommand &command)
    731732{
    732         scoped_lock lock(mutex_);
     733        fz::scoped_lock lock(mutex_);
    733734
    734735        int res = CheckCommandPreconditions(command, true);
     
    738739
    739740        m_pCurrentCommand.reset(command.Clone());
    740         SendEvent<CCommandEvent>();
     741        send_event<CCommandEvent>();
    741742
    742743        return FZ_REPLY_WOULDBLOCK;
     
    745746std::unique_ptr<CNotification> CFileZillaEnginePrivate::GetNextNotification()
    746747{
    747         scoped_lock lock(notification_mutex_);
     748        fz::scoped_lock lock(notification_mutex_);
    748749
    749750        if (m_NotificationList.empty()) {
     
    759760bool CFileZillaEnginePrivate::SetAsyncRequestReply(std::unique_ptr<CAsyncRequestNotification> && pNotification)
    760761{
    761         scoped_lock lock(mutex_);
     762        fz::scoped_lock lock(mutex_);
    762763        if (!CheckAsyncRequestReplyPreconditions(pNotification)) {
    763764                return false;
    764765        }
    765766
    766         SendEvent<CAsyncRequestReplyEvent>(std::move(pNotification));
     767        send_event<CAsyncRequestReplyEvent>(std::move(pNotification));
    767768
    768769        return true;
     
    777778                return false;
    778779
    779         scoped_lock lock(notification_mutex_);
     780        fz::scoped_lock lock(notification_mutex_);
    780781        return pNotification->requestNumber == m_asyncRequestCounter;
    781782}
     
    809810{
    810811        // TODO: Possible optimization: Atomically get current server. The cache has its own mutex.
    811         scoped_lock lock(mutex_);
     812        fz::scoped_lock lock(mutex_);
    812813
    813814        if (!IsConnected())
     
    825826int CFileZillaEnginePrivate::Cancel()
    826827{
    827         scoped_lock lock(mutex_);
     828        fz::scoped_lock lock(mutex_);
    828829        if (!IsBusy())
    829830                return FZ_REPLY_OK;
    830831
    831         SendEvent<CFileZillaEngineEvent>(engineCancel);
     832        send_event<CFileZillaEngineEvent>(engineCancel);
    832833        return FZ_REPLY_WOULDBLOCK;
    833834}
     
    836837{
    837838        bool queue_logs = ShouldQueueLogsFromOptions();
    838         scoped_lock lock(notification_mutex_);
     839        fz::scoped_lock lock(notification_mutex_);
    839840        queue_logs_ = queue_logs;
    840841
     
    853854{
    854855        {
    855                 scoped_lock lock(mutex_);
     856                fz::scoped_lock lock(mutex_);
    856857                status_.clear();
    857858                send_state_ = 0;
     
    863864void CTransferStatusManager::Init(wxFileOffset totalSize, wxFileOffset startOffset, bool list)
    864865{
    865         scoped_lock lock(mutex_);
     866        fz::scoped_lock lock(mutex_);
    866867        if (startOffset < 0)
    867868                startOffset = 0;
     
    873874void CTransferStatusManager::SetStartTime()
    874875{
    875         scoped_lock lock(mutex_);
     876        fz::scoped_lock lock(mutex_);
    876877        if (!status_)
    877878                return;
    878879
    879         status_.started = CDateTime::Now();
     880        status_.started = fz::datetime::now();
    880881}
    881882
    882883void CTransferStatusManager::SetMadeProgress()
    883884{
    884         scoped_lock lock(mutex_);
     885        fz::scoped_lock lock(mutex_);
    885886        if (!status_)
    886887                return;
     
    896897                int64_t oldOffset = currentOffset_.fetch_add(transferredBytes);
    897898                if (!oldOffset) {
    898                         scoped_lock lock(mutex_);
     899                        fz::scoped_lock lock(mutex_);
    899900                        if (!status_) {
    900901                                return;
     
    916917CTransferStatus CTransferStatusManager::Get(bool &changed)
    917918{
    918         scoped_lock lock(mutex_);
     919        fz::scoped_lock lock(mutex_);
    919920        if (!status_) {
    920921                changed = false;
     
    937938bool CTransferStatusManager::empty()
    938939{
    939         scoped_lock lock(mutex_);
     940        fz::scoped_lock lock(mutex_);
    940941        return status_.empty();
    941942}
Note: See TracChangeset for help on using the changeset viewer.