VirtualBox

Changeset 43707 in vbox


Ignore:
Timestamp:
Oct 22, 2012 4:41:04 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
81569
Message:

FE/Qt: New version check will use our ssl lib to make network-requests. X11 only for now.

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
14 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r43059 r43707  
    286286        src/net/UINetworkRequest.h \
    287287        src/net/UINetworkRequestWidget.h \
     288        src/net/UINetworkReply.h \
    288289        src/net/UINetworkCustomer.h \
    289290        src/net/UIUpdateManager.h \
    … …  
    440441        src/globals/UIExtraDataEventHandler.cpp \
    441442        src/medium/UIMediumManager.cpp \
     443        src/net/UINetworkReply.cpp \
    442444        src/net/UIUpdateManager.cpp \
    443445        src/runtime/UIActionPoolRuntime.cpp \
    … …  
    519521        src/net/UINetworkRequest.cpp \
    520522        src/net/UINetworkRequestWidget.cpp \
     523        src/net/UINetworkReply.cpp \
    521524        src/net/UINetworkCustomer.cpp \
    522525        src/net/UIDownloader.cpp \

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloader.cpp

    r41140 r43707  
    1818 */
    1919
    20 /* Global includes: */
    21 #include <QNetworkReply>
    22 
    23 /* Local includes: */
     20/* GUI includes: */
     21#include <UINetworkReply.h>
    2422#include "UIDownloader.h"
    2523#include "VBoxGlobal.h"
    … …  
    7977
    8078/* Network-reply canceled handler: */
    81 void UIDownloader::processNetworkReplyCanceled(QNetworkReply *pNetworkReply)
     79void UIDownloader::processNetworkReplyCanceled(UINetworkReply *pNetworkReply)
    8280{
    8381    /* Unused variables: */
    … …  
    8987
    9088/* Network-reply finished handler: */
    91 void UIDownloader::processNetworkReplyFinished(QNetworkReply *pNetworkReply)
     89void UIDownloader::processNetworkReplyFinished(UINetworkReply *pNetworkReply)
    9290{
    9391    /* Process reply: */
    … …  
    110108
    111109/* Handle acknowledging result: */
    112 void UIDownloader::handleAcknowledgingResult(QNetworkReply *pNetworkReply)
     110void UIDownloader::handleAcknowledgingResult(UINetworkReply *pNetworkReply)
    113111{
    114112    /* Get the final source: */
    … …  
    129127
    130128/* Handle downloading result: */
    131 void UIDownloader::handleDownloadingResult(QNetworkReply *pNetworkReply)
     129void UIDownloader::handleDownloadingResult(UINetworkReply *pNetworkReply)
    132130{
    133131    /* Handle downloaded object: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloader.h

    r41140 r43707  
    2929
    3030/* Forward declarations: */
    31 class QNetworkReply;
     31class UINetworkReply;
    3232
    3333/* Downloader interface.
    … …  
    9393    void processNetworkReplyProgress(qint64 iReceived, qint64 iTotal);
    9494    /* Network-reply cancel handler: */
    95     void processNetworkReplyCanceled(QNetworkReply *pNetworkReply);
     95    void processNetworkReplyCanceled(UINetworkReply *pNetworkReply);
    9696    /* Network-reply finish handler: */
    97     void processNetworkReplyFinished(QNetworkReply *pNetworkReply);
     97    void processNetworkReplyFinished(UINetworkReply *pNetworkReply);
    9898
    9999    /* Handle acknowledging result: */
    100     virtual void handleAcknowledgingResult(QNetworkReply *pNetworkReply);
     100    virtual void handleAcknowledgingResult(UINetworkReply *pNetworkReply);
    101101    /* Handle downloading result: */
    102     virtual void handleDownloadingResult(QNetworkReply *pNetworkReply);
     102    virtual void handleDownloadingResult(UINetworkReply *pNetworkReply);
    103103
    104104    /* Pure virtual function to ask user about downloading confirmation: */
    105     virtual bool askForDownloadingConfirmation(QNetworkReply *pNetworkReply) = 0;
     105    virtual bool askForDownloadingConfirmation(UINetworkReply *pNetworkReply) = 0;
    106106    /* Pure virtual function to handle downloaded object: */
    107     virtual void handleDownloadedObject(QNetworkReply *pNetworkReply) = 0;
     107    virtual void handleDownloadedObject(UINetworkReply *pNetworkReply) = 0;
    108108
    109109private:

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderAdditions.cpp

    r41140 r43707  
    1919
    2020/* Global includes: */
    21 #include <QNetworkReply>
    2221#include <QDir>
    2322#include <QFile>
    … …  
    2524/* Local includes: */
    2625#include "UIDownloaderAdditions.h"
     26#include "UINetworkReply.h"
    2727#include "QIFileDialog.h"
    2828#include "VBoxGlobal.h"
    … …  
    7272}
    7373
    74 bool UIDownloaderAdditions::askForDownloadingConfirmation(QNetworkReply *pReply)
     74bool UIDownloaderAdditions::askForDownloadingConfirmation(UINetworkReply *pReply)
    7575{
    7676    return msgCenter().confirmDownloadAdditions(source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    7777}
    7878
    79 void UIDownloaderAdditions::handleDownloadedObject(QNetworkReply *pReply)
     79void UIDownloaderAdditions::handleDownloadedObject(UINetworkReply *pReply)
    8080{
    8181    /* Read received data into the buffer: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderAdditions.h

    r41140 r43707  
    4646
    4747    /* Virtual stuff reimplementations: */
    48     bool askForDownloadingConfirmation(QNetworkReply *pReply);
    49     void handleDownloadedObject(QNetworkReply *pReply);
     48    bool askForDownloadingConfirmation(UINetworkReply *pReply);
     49    void handleDownloadedObject(UINetworkReply *pReply);
    5050
    5151    /* Variables: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderExtensionPack.cpp

    r41689 r43707  
    1919
    2020/* Global includes: */
    21 #include <QNetworkReply>
    2221#include <QDir>
    2322#include <QFile>
    … …  
    2625/* Local includes: */
    2726#include "UIDownloaderExtensionPack.h"
     27#include "UINetworkReply.h"
    2828#include "QIFileDialog.h"
    2929#include "VBoxGlobal.h"
    … …  
    7979}
    8080
    81 bool UIDownloaderExtensionPack::askForDownloadingConfirmation(QNetworkReply *pReply)
     81bool UIDownloaderExtensionPack::askForDownloadingConfirmation(UINetworkReply *pReply)
    8282{
    8383    return msgCenter().confirmDownloadExtensionPack(GUI_ExtPackName, source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    8484}
    8585
    86 void UIDownloaderExtensionPack::handleDownloadedObject(QNetworkReply *pReply)
     86void UIDownloaderExtensionPack::handleDownloadedObject(UINetworkReply *pReply)
    8787{
    8888    /* Read received data into the buffer: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderExtensionPack.h

    r41141 r43707  
    4646
    4747    /* Virtual stuff reimplementations: */
    48     bool askForDownloadingConfirmation(QNetworkReply *pReply);
    49     void handleDownloadedObject(QNetworkReply *pReply);
     48    bool askForDownloadingConfirmation(UINetworkReply *pReply);
     49    void handleDownloadedObject(UINetworkReply *pReply);
    5050
    5151    /* Variables: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderUserManual.cpp

    r41140 r43707  
    1919
    2020/* Global includes: */
    21 #include <QNetworkReply>
    2221#include <QDir>
    2322#include <QFile>
    … …  
    2524/* Local includes: */
    2625#include "UIDownloaderUserManual.h"
     26#include "UINetworkReply.h"
    2727#include "QIFileDialog.h"
    2828#include "VBoxGlobal.h"
    … …  
    7575}
    7676
    77 bool UIDownloaderUserManual::askForDownloadingConfirmation(QNetworkReply *pReply)
     77bool UIDownloaderUserManual::askForDownloadingConfirmation(UINetworkReply *pReply)
    7878{
    7979    return msgCenter().confirmUserManualDownload(source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    8080}
    8181
    82 void UIDownloaderUserManual::handleDownloadedObject(QNetworkReply *pReply)
     82void UIDownloaderUserManual::handleDownloadedObject(UINetworkReply *pReply)
    8383{
    8484    /* Read received data into the buffer: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderUserManual.h

    r41140 r43707  
    4646
    4747    /* Virtual stuff reimplementations: */
    48     bool askForDownloadingConfirmation(QNetworkReply *pReply);
    49     void handleDownloadedObject(QNetworkReply *pReply);
     48    bool askForDownloadingConfirmation(UINetworkReply *pReply);
     49    void handleDownloadedObject(UINetworkReply *pReply);
    5050
    5151    /* Variables: */

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkCustomer.h

    r41153 r43707  
    2727
    2828/* Forward declarations: */
    29 class QNetworkReply;
     29class UINetworkReply;
    3030class QNetworkRequest;
    3131
    … …  
    4747    virtual void processNetworkReplyProgress(qint64 iReceived, qint64 iTotal) = 0;
    4848    /* Network-reply cancel handler: */
    49     virtual void processNetworkReplyCanceled(QNetworkReply *pReply) = 0;
     49    virtual void processNetworkReplyCanceled(UINetworkReply *pReply) = 0;
    5050    /* Network-reply finish handler: */
    51     virtual void processNetworkReplyFinished(QNetworkReply *pReply) = 0;
     51    virtual void processNetworkReplyFinished(UINetworkReply *pReply) = 0;
    5252
    5353protected:

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkDefs.h

    r41143 r43707  
    2424{
    2525    UINetworkRequestType_HEAD,
    26     UINetworkRequestType_GET
     26    UINetworkRequestType_GET,
     27    UINetworkRequestType_GET_Our
     28};
     29
     30/* Network-reply types: */
     31enum UINetworkReplyType
     32{
     33    UINetworkReplyType_Qt,
     34    UINetworkReplyType_Our
    2735};
    2836

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkReply.cpp

    r43700 r43707  
    33 *
    44 * VBox frontends: Qt GUI ("VirtualBox"):
    5  * UINetworkRequest stuff implementation
     5 * UINetworkReply stuff implementation
    66 */
    77
    88/*
    9  * Copyright (C) 2011-2012 Oracle Corporation
     9 * Copyright (C) 2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1818 */
    1919
    20 /* Global includes: */
    21 #include <QNetworkReply>
    22 
    23 /* Local includes: */
    24 #include "UINetworkRequest.h"
    25 #include "UINetworkRequestWidget.h"
     20/* GUI includes: */
     21#include "UINetworkReply.h"
    2622#include "UINetworkManager.h"
    27 #include "UINetworkManagerDialog.h"
    28 #include "UINetworkManagerIndicator.h"
    29 #include "UINetworkCustomer.h"
    30 #include "VBoxGlobal.h"
    31 
    32 /* Constructor: */
    33 UINetworkRequest::UINetworkRequest(const QNetworkRequest &request, UINetworkRequestType type, const QString &strDescription,
    34                                    UINetworkCustomer *pCustomer,
    35                                    UINetworkManager *pNetworkManager)
    36     : QObject(pNetworkManager)
    37     , m_pNetworkManagerDialog(pNetworkManager->window())
    38     , m_pNetworkManagerIndicator(pNetworkManager->indicator())
    39     , m_uuid(QUuid::createUuid())
    40     , m_requests(QList<QNetworkRequest>() << request)
    41     , m_iCurrentRequestIndex(0)
    42     , m_type(type)
    43     , m_strDescription(strDescription)
    44     , m_pCustomer(pCustomer)
    45     , m_fRunning(false)
    46 {
    47     /* Initialize: */
    48     initialize();
    49 }
    50 
    51 UINetworkRequest::UINetworkRequest(const QList<QNetworkRequest> &requests, UINetworkRequestType type, const QString &strDescription,
    52                                    UINetworkCustomer *pCustomer,
    53                                    UINetworkManager *pNetworkManager)
    54     : QObject(pNetworkManager)
    55     , m_pNetworkManagerDialog(pNetworkManager->window())
    56     , m_pNetworkManagerIndicator(pNetworkManager->indicator())
    57     , m_uuid(QUuid::createUuid())
    58     , m_requests(requests)
    59     , m_iCurrentRequestIndex(0)
    60     , m_type(type)
    61     , m_strDescription(strDescription)
    62     , m_pCustomer(pCustomer)
    63     , m_fRunning(false)
    64 {
    65     /* Initialize: */
    66     initialize();
    67 }
    68 
    69 /* Destructor: */
    70 UINetworkRequest::~UINetworkRequest()
    71 {
    72     /* Destroy network-reply: */
    73     cleanupNetworkReply();
    74 
    75     /* Remove network-request description from network-manager state-indicator: */
    76     if (m_pNetworkManagerIndicator)
    77         m_pNetworkManagerIndicator->removeNetworkRequest(m_uuid);
    78 
    79     /* Remove network-request widget from network-manager dialog: */
    80     m_pNetworkManagerDialog->removeNetworkRequestWidget(m_uuid);
    81 }
    82 
    83 /* Network-reply progress handler: */
    84 void UINetworkRequest::sltHandleNetworkReplyProgress(qint64 iReceived, qint64 iTotal)
    85 {
    86     /* Notify general network-requests listeners: */
    87     emit sigProgress(m_uuid, iReceived, iTotal);
    88     /* Notify particular network-request listeners: */
    89     emit sigProgress(iReceived, iTotal);
    90 }
    91 
    92 /* Network-reply finish handler: */
    93 void UINetworkRequest::sltHandleNetworkReplyFinish()
    94 {
    95     /* Set as non-running: */
    96     m_fRunning = false;
    97 
    98     /* Get sender network-reply: */
    99     QNetworkReply *pNetworkReply = static_cast<QNetworkReply*>(sender());
    100 
    101     /* If network-request was canceled: */
    102     if (pNetworkReply->error() == QNetworkReply::OperationCanceledError)
    103     {
    104         /* Notify network-manager: */
    105         emit sigCanceled(m_uuid);
    106     }
    107     /* If network-reply has no errors: */
    108     else if (pNetworkReply->error() == QNetworkReply::NoError)
    109     {
    110         /* Check if redirection required: */
    111         QUrl redirect = pNetworkReply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
    112         if (redirect.isValid())
     23
     24/* Other VBox includes; */
     25#include <iprt/err.h>
     26#include <iprt/http.h>
     27#include <iprt/stream.h>
     28#include <iprt/initterm.h>
     29#include <iprt/mem.h>
     30
     31/* Our network-reply thread: */
     32class UINetworkReplyPrivateThread : public QThread
     33{
     34    Q_OBJECT;
     35
     36public:
     37
     38    /* Constructor: */
     39    UINetworkReplyPrivateThread(const QNetworkRequest &request)
     40        : m_request(request)
     41        , m_iError(VINF_SUCCESS)
     42    {
     43    }
     44
     45    /* API: */
     46    const QByteArray& readAll() const { return m_reply; }
     47    int error() const { return m_iError; }
     48
     49private:
     50
     51    /* Thread runner: */
     52    void run()
     53    {
     54        /* Init: */
     55        RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
     56
     57        /* Create: */
     58        RTHTTP hHttp;
     59        m_iError = RTHttpCreate(&hHttp);
     60
     61        /* Acquire: */
     62        if (RT_SUCCESS(m_iError))
    11363        {
    114             /* Cleanup current network-reply first: */
    115             cleanupNetworkReply();
    116 
    117             /* Choose redirect-source as current: */
    118             m_request.setUrl(redirect);
    119 
    120             /* Create new network-reply finally: */
    121             prepareNetworkReply();
     64            char *pszBuf = 0;
     65            m_iError = RTHttpGet(hHttp,
     66                                 m_request.url().toString().toAscii().constData(),
     67                                 &pszBuf);
     68            m_reply = QByteArray(pszBuf);
     69            RTMemFree(pszBuf);
    12270        }
    123         else
     71
     72        /* Destroy: */
     73        RTHttpDestroy(hHttp);
     74    }
     75
     76    /* Variables: */
     77    QNetworkRequest m_request;
     78    int m_iError;
     79    QByteArray m_reply;
     80};
     81
     82/* Our network-reply object: */
     83class UINetworkReplyPrivate : public QObject
     84{
     85    Q_OBJECT;
     86
     87signals:
     88
     89    /* Notifiers: */
     90    void downloadProgress(qint64 iBytesReceived, qint64 iBytesTotal);
     91    void finished();
     92
     93public:
     94
     95    /* Constructor: */
     96    UINetworkReplyPrivate(const QNetworkRequest &request)
     97        : m_error(QNetworkReply::NoError)
     98        , m_pThread(0)
     99    {
     100        /* Create and run network-reply thread: */
     101        m_pThread = new UINetworkReplyPrivateThread(request);
     102        connect(m_pThread, SIGNAL(finished()), this, SLOT(sltFinished()));
     103        m_pThread->start();
     104    }
     105
     106    /* Destructor: */
     107    ~UINetworkReplyPrivate()
     108    {
     109        /* Terminate network-reply thread: */
     110        m_pThread->wait();
     111        delete m_pThread;
     112        m_pThread = 0;
     113    }
     114
     115    /* API: Abort reply: */
     116    void abort()
     117    {
     118        m_error = QNetworkReply::OperationCanceledError;
     119        emit finished();
     120    }
     121
     122    /* API: Error-code getter: */
     123    QNetworkReply::NetworkError error() const { return m_error; }
     124
     125    /* API: Error-string getter: */
     126    QString errorString() const
     127    {
     128        switch (m_error)
    124129        {
    125             /* Notify particular network-request listeners: */
    126             emit sigFinished();
    127             /* Notify general network-requests listeners: */
    128             emit sigFinished(m_uuid);
     130            case QNetworkReply::NoError:
     131                break;
     132            case QNetworkReply::HostNotFoundError:
     133                return tr("The server has not found anything matching the URI given");
     134                break;
     135            case QNetworkReply::ContentAccessDenied:
     136                return tr("The request is for something forbidden, authorization will not help");
     137                break;
     138            case QNetworkReply::ProtocolFailure:
     139                return tr("The server did not understand the request due to bad syntax");
     140                break;
     141            default:
     142                return tr("Unrecognized network error");
     143                break;
    129144        }
    130     }
    131     /* If some error occured: */
    132     else
    133     {
    134         /* Check if we have other requests in set: */
    135         if (m_iCurrentRequestIndex < m_requests.size() - 1)
     145        return QString();
     146    }
     147
     148    /* API: Reply getter: */
     149    QByteArray readAll() { return m_pThread->readAll(); }
     150
     151private slots:
     152
     153    /* Handler: Thread finished: */
     154    void sltFinished()
     155    {
     156        switch (m_pThread->error())
    136157        {
    137             /* Cleanup current network-reply first: */
    138             cleanupNetworkReply();
    139 
    140             /* Choose next network-request as current: */
    141             ++m_iCurrentRequestIndex;
    142             m_request = m_requests[m_iCurrentRequestIndex];
    143 
    144             /* Create new network-reply finally: */
    145             prepareNetworkReply();
     158            case VINF_SUCCESS:
     159                m_error = QNetworkReply::NoError;
     160                break;
     161            case VERR_HTTP_NOT_FOUND:
     162                m_error = QNetworkReply::HostNotFoundError;
     163                break;
     164            case VERR_HTTP_ACCESS_DENIED:
     165                m_error = QNetworkReply::ContentAccessDenied;
     166                break;
     167            case VERR_HTTP_BAD_REQUEST:
     168                m_error = QNetworkReply::ProtocolFailure;
     169                break;
     170            default:
     171                m_error = QNetworkReply::UnknownNetworkError;
     172                break;
    146173        }
    147         else
    148         {
    149             /* Notify particular network-request listeners: */
    150             emit sigFailed(pNetworkReply->errorString());
    151             /* Notify general network-requests listeners: */
    152             emit sigFailed(m_uuid, pNetworkReply->errorString());
    153         }
    154     }
    155 }
    156 
    157 /* Slot to retry network-request: */
    158 void UINetworkRequest::sltRetry()
    159 {
    160     /* Cleanup current network-reply first: */
    161     cleanupNetworkReply();
    162 
    163     /* Choose first network-request as current: */
    164     m_iCurrentRequestIndex = 0;
    165     m_request = m_requests[m_iCurrentRequestIndex];
    166 
    167     /* Create new network-reply finally: */
    168     prepareNetworkReply();
    169 }
    170 
    171 /* Slot to cancel network-request: */
    172 void UINetworkRequest::sltCancel()
    173 {
    174     /* Abort network-reply if present: */
    175     abortNetworkReply();
    176 }
    177 
    178 /* Initialize: */
    179 void UINetworkRequest::initialize()
    180 {
    181     /* Prepare listeners for parent(): */
    182     connect(parent(), SIGNAL(sigCancelNetworkRequests()), this, SLOT(sltCancel()));
    183 
    184     /* Create network-request widget in network-manager dialog: */
    185     m_pNetworkManagerDialog->addNetworkRequestWidget(this);
    186 
    187     /* Create network-request description in network-manager state-indicator: */
    188     if (m_pNetworkManagerIndicator)
    189         m_pNetworkManagerIndicator->addNetworkRequest(this);
    190 
    191     /* Choose first network-request as current: */
    192     m_iCurrentRequestIndex = 0;
    193     m_request = m_requests[m_iCurrentRequestIndex];
    194 
    195     /* Create network-reply: */
    196     prepareNetworkReply();
    197 }
    198 
    199 /* Prepare network-reply: */
    200 void UINetworkRequest::prepareNetworkReply()
    201 {
    202     /* Make network-request: */
    203     switch (m_type)
    204     {
     174        emit finished();
     175    }
     176
     177private:
     178
     179    /* Variables: */
     180    QNetworkReply::NetworkError m_error;
     181    UINetworkReplyPrivateThread *m_pThread;
     182};
     183
     184UINetworkReply::UINetworkReply(const QNetworkRequest &request, UINetworkRequestType requestType)
     185    : m_replyType(UINetworkReplyType_Qt)
     186    , m_pReply(0)
     187{
     188    /* Create network-reply object: */
     189    switch (requestType)
     190    {
     191        /* Prepare Qt network-reply (HEAD): */
    205192        case UINetworkRequestType_HEAD:
    206         {
    207             m_pReply = gNetworkManager->head(m_request);
     193            m_replyType = UINetworkReplyType_Qt;
     194            m_pReply = gNetworkManager->head(request);
    208195            break;
    209         }
     196        /* Prepare Qt network-reply (GET): */
    210197        case UINetworkRequestType_GET:
    211         {
    212             m_pReply = gNetworkManager->get(m_request);
     198            m_replyType = UINetworkReplyType_Qt;
     199            m_pReply = gNetworkManager->get(request);
    213200            break;
    214         }
    215         default:
     201        /* Prepare our network-reply (GET): */
     202        case UINetworkRequestType_GET_Our:
     203            m_replyType = UINetworkReplyType_Our;
     204            m_pReply = new UINetworkReplyPrivate(request);
    216205            break;
    217206    }
    218207
    219     /* Prepare listeners for m_pReply: */
    220     AssertMsg(m_pReply, ("Unable to make network-request!\n"));
    221     connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(sltHandleNetworkReplyProgress(qint64, qint64)));
    222     connect(m_pReply, SIGNAL(finished()), this, SLOT(sltHandleNetworkReplyFinish()));
    223 
    224     /* Set as running: */
    225     m_fRunning = true;
    226 
    227     /* Notify general network-requests listeners: */
    228     emit sigStarted(m_uuid);
    229     /* Notify particular network-request listeners: */
    230     emit sigStarted();
    231 }
    232 
    233 /* Cleanup network-reply: */
    234 void UINetworkRequest::cleanupNetworkReply()
    235 {
    236     /* Destroy current reply: */
    237     AssertMsg(m_pReply, ("Network-reply already destroyed!\n"));
    238     m_pReply->disconnect();
    239     m_pReply->deleteLater();
    240     m_pReply = 0;
    241 }
    242 
    243 /* Abort network-reply: */
    244 void UINetworkRequest::abortNetworkReply()
    245 {
    246     /* Abort network-reply if present: */
     208    /* Prepare network-reply object connections: */
     209    connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SIGNAL(downloadProgress(qint64, qint64)));
     210    connect(m_pReply, SIGNAL(finished()), this, SIGNAL(finished()));
     211}
     212
     213UINetworkReply::~UINetworkReply()
     214{
     215    /* Cleanup network-reply object: */
    247216    if (m_pReply)
    248217    {
    249         if (m_fRunning)
    250             m_pReply->abort();
    251         else
    252             emit sigCanceled(m_uuid);
    253     }
    254 }
    255 
     218        delete m_pReply;
     219        m_pReply = 0;
     220    }
     221}
     222
     223QVariant UINetworkReply::header(QNetworkRequest::KnownHeaders header) const
     224{
     225    QVariant result;
     226    switch (m_replyType)
     227    {
     228        case UINetworkReplyType_Qt: result = qobject_cast<QNetworkReply*>(m_pReply)->header(header); break;
     229        case UINetworkReplyType_Our: /* TODO: header() */ break;
     230    }
     231    return result;
     232}
     233
     234QVariant UINetworkReply::attribute(QNetworkRequest::Attribute code) const
     235{
     236    QVariant result;
     237    switch (m_replyType)
     238    {
     239        case UINetworkReplyType_Qt: result = qobject_cast<QNetworkReply*>(m_pReply)->attribute(code); break;
     240        case UINetworkReplyType_Our: /* TODO: attribute() */ break;
     241    }
     242    return result;
     243}
     244
     245void UINetworkReply::abort()
     246{
     247    switch (m_replyType)
     248    {
     249        case UINetworkReplyType_Qt: qobject_cast<QNetworkReply*>(m_pReply)->abort(); break;
     250        case UINetworkReplyType_Our: qobject_cast<UINetworkReplyPrivate*>(m_pReply)->abort(); break;
     251    }
     252}
     253
     254QNetworkReply::NetworkError UINetworkReply::error() const
     255{
     256    QNetworkReply::NetworkError result = QNetworkReply::NoError;
     257    switch (m_replyType)
     258    {
     259        case UINetworkReplyType_Qt: result = qobject_cast<QNetworkReply*>(m_pReply)->error(); break;
     260        case UINetworkReplyType_Our: result = qobject_cast<UINetworkReplyPrivate*>(m_pReply)->error(); break;
     261    }
     262    return result;
     263}
     264
     265QString UINetworkReply::errorString() const
     266{
     267    QString strResult;
     268    switch (m_replyType)
     269    {
     270        case UINetworkReplyType_Qt: strResult = qobject_cast<QNetworkReply*>(m_pReply)->errorString(); break;
     271        case UINetworkReplyType_Our: strResult = qobject_cast<UINetworkReplyPrivate*>(m_pReply)->errorString(); break;
     272    }
     273    return strResult;
     274}
     275
     276QByteArray UINetworkReply::readAll()
     277{
     278    QByteArray result;
     279    switch (m_replyType)
     280    {
     281        case UINetworkReplyType_Qt: result = qobject_cast<QNetworkReply*>(m_pReply)->readAll(); break;
     282        case UINetworkReplyType_Our: result = qobject_cast<UINetworkReplyPrivate*>(m_pReply)->readAll(); break;
     283    }
     284    return result;
     285}
     286
     287QUrl UINetworkReply::url() const
     288{
     289    QUrl result;
     290    switch (m_replyType)
     291    {
     292        case UINetworkReplyType_Qt: result = qobject_cast<QNetworkReply*>(m_pReply)->url(); break;
     293        case UINetworkReplyType_Our: /* TODO: url() */ break;
     294    }
     295    return result;
     296}
     297
     298#include "UINetworkReply.moc"
     299

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkReply.h

    r43700 r43707  
    22 *
    33 * VBox frontends: Qt GUI ("VirtualBox"):
    4  * UINetworkRequest stuff declaration
     4 * UINetworkReply stuff declaration
    55 */
    66
    77/*
    8  * Copyright (C) 2011-2012 Oracle Corporation
     8 * Copyright (C) 2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1717 */
    1818
    19 #ifndef __UINetworkRequest_h__
    20 #define __UINetworkRequest_h__
     19#ifndef __UINetworkReply_h__
     20#define __UINetworkReply_h__
    2121
    22 /* Global includes: */
    23 #include <QUuid>
    24 #include <QNetworkRequest>
     22/* Qt includes: */
     23#include <QPointer>
     24#include <QThread>
    2525#include <QNetworkReply>
    26 #include <QPointer>
    2726
    28 /* Local inludes: */
     27/* GUI includes: */
    2928#include "UINetworkDefs.h"
    3029
    3130/* Forward declarations: */
    32 class UINetworkManager;
    33 class UINetworkManagerDialog;
    34 class UINetworkManagerIndicator;
    35 class UINetworkRequestWidget;
    36 class UINetworkCustomer;
     31class UINetworkReplyPrivateThread;
    3732
    38 /* Network-request contianer: */
    39 class UINetworkRequest : public QObject
     33/* Network-reply interface: */
     34class UINetworkReply : public QObject
    4035{
    4136    Q_OBJECT;
    … …  
    4338signals:
    4439
    45     /* Notifications to UINetworkManager: */
    46     void sigProgress(const QUuid &uuid, qint64 iReceived, qint64 iTotal);
    47     void sigStarted(const QUuid &uuid);
    48     void sigCanceled(const QUuid &uuid);
    49     void sigFinished(const QUuid &uuid);
    50     void sigFailed(const QUuid &uuid, const QString &strError);
    51 
    52     /* Notifications to UINetworkRequestWidget: */
    53     void sigProgress(qint64 iReceived, qint64 iTotal);
    54     void sigStarted();
    55     void sigFinished();
    56     void sigFailed(const QString &strError);
     40    /* Notifiers: */
     41    void downloadProgress(qint64 iBytesReceived, qint64 iBytesTotal);
     42    void finished();
    5743
    5844public:
    5945
    6046    /* Constructor/destructor: */
    61     UINetworkRequest(const QNetworkRequest &request, UINetworkRequestType type, const QString &strDescription,
    62                      UINetworkCustomer *pCustomer,
    63                      UINetworkManager *pNetworkManager);
    64     UINetworkRequest(const QList<QNetworkRequest> &requests, UINetworkRequestType type, const QString &strDescription,
    65                      UINetworkCustomer *pCustomer,
    66                      UINetworkManager *pNetworkManager);
    67     ~UINetworkRequest();
     47    UINetworkReply(const QNetworkRequest &request, UINetworkRequestType requestType);
     48    ~UINetworkReply();
    6849
    69     /* Getters: */
    70     const QUuid& uuid() const { return m_uuid; }
    71     const QString& description() const { return m_strDescription; }
    72     UINetworkCustomer* customer() { return m_pCustomer; }
    73     QNetworkReply* reply() { return m_pReply; }
    74 
    75 private slots:
    76 
    77     /* Network-reply progress handler: */
    78     void sltHandleNetworkReplyProgress(qint64 iReceived, qint64 iTotal);
    79     /* Network-reply finish handler: */
    80     void sltHandleNetworkReplyFinish();
    81 
    82     /* Slot to retry network-request: */
    83     void sltRetry();
    84     /* Slot to cancel network-request: */
    85     void sltCancel();
     50    /* API: */
     51    QVariant header(QNetworkRequest::KnownHeaders header) const;
     52    QVariant attribute(QNetworkRequest::Attribute code) const;
     53    void abort();
     54    QNetworkReply::NetworkError error() const;
     55    QString errorString() const;
     56    QByteArray readAll();
     57    QUrl url() const;
    8658
    8759private:
    8860
    89     /* Initialize: */
    90     void initialize();
    91 
    92     /* Prepare network-reply: */
    93     void prepareNetworkReply();
    94     /* Cleanup network-reply: */
    95     void cleanupNetworkReply();
    96     /* Abort network-reply: */
    97     void abortNetworkReply();
    98 
    99     /* Widgets: */
    100     UINetworkManagerDialog *m_pNetworkManagerDialog;
    101     UINetworkManagerIndicator *m_pNetworkManagerIndicator;
    102 
    10361    /* Variables: */
    104     QUuid m_uuid;
    105     QList<QNetworkRequest> m_requests;
    106     QNetworkRequest m_request;
    107     int m_iCurrentRequestIndex;
    108     UINetworkRequestType m_type;
    109     QString m_strDescription;
    110     UINetworkCustomer *m_pCustomer;
    111     QPointer<QNetworkReply> m_pReply;
    112     bool m_fRunning;
     62    UINetworkReplyType m_replyType;
     63    QPointer<QObject> m_pReply;
    11364};
    11465
    115 #endif // __UINetworkRequest_h__
     66#endif // __UINetworkReply_h__

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkRequest.cpp

    r42901 r43707  
    1818 */
    1919
    20 /* Global includes: */
     20/* Qt includes: */
    2121#include <QNetworkReply>
    2222
    23 /* Local includes: */
     23/* GUI includes: */
    2424#include "UINetworkRequest.h"
    2525#include "UINetworkRequestWidget.h"
    … …  
    9696    m_fRunning = false;
    9797
    98     /* Get sender network-reply: */
    99     QNetworkReply *pNetworkReply = static_cast<QNetworkReply*>(sender());
     98    /* Make sure network-reply still valid: */
     99    if (!m_pReply)
     100        return;
    100101
    101102    /* If network-request was canceled: */
    102     if (pNetworkReply->error() == QNetworkReply::OperationCanceledError)
     103    if (m_pReply->error() == QNetworkReply::OperationCanceledError)
    103104    {
    104105        /* Notify network-manager: */
    … …  
    106107    }
    107108    /* If network-reply has no errors: */
    108     else if (pNetworkReply->error() == QNetworkReply::NoError)
     109    else if (m_pReply->error() == QNetworkReply::NoError)
    109110    {
    110111        /* Check if redirection required: */
    111         QUrl redirect = pNetworkReply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
     112        QUrl redirect = m_pReply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
    112113        if (redirect.isValid())
    113114        {
    … …  
    148149        {
    149150            /* Notify particular network-request listeners: */
    150             emit sigFailed(pNetworkReply->errorString());
     151            emit sigFailed(m_pReply->errorString());
    151152            /* Notify general network-requests listeners: */
    152             emit sigFailed(m_uuid, pNetworkReply->errorString());
     153            emit sigFailed(m_uuid, m_pReply->errorString());
    153154        }
    154155    }
    … …  
    201202{
    202203    /* Make network-request: */
    203     switch (m_type)
    204     {
    205         case UINetworkRequestType_HEAD:
    206         {
    207             m_pReply = gNetworkManager->head(m_request);
    208             break;
    209         }
    210         case UINetworkRequestType_GET:
    211         {
    212             m_pReply = gNetworkManager->get(m_request);
    213             break;
    214         }
    215         default:
    216             break;
    217     }
    218 
     204    m_pReply = new UINetworkReply(m_request, m_type);
     205    AssertMsg(m_pReply, ("Unable to make network-request!\n"));
    219206    /* Prepare listeners for m_pReply: */
    220     AssertMsg(m_pReply, ("Unable to make network-request!\n"));
    221207    connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(sltHandleNetworkReplyProgress(qint64, qint64)));
    222208    connect(m_pReply, SIGNAL(finished()), this, SLOT(sltHandleNetworkReplyFinish()));

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkRequest.h

    r42526 r43707  
    2020#define __UINetworkRequest_h__
    2121
    22 /* Global includes: */
     22/* Qt includes: */
    2323#include <QUuid>
    2424#include <QNetworkRequest>
    25 #include <QNetworkReply>
    2625#include <QPointer>
    2726
    28 /* Local inludes: */
     27/* GUI inludes: */
    2928#include "UINetworkDefs.h"
     29#include "UINetworkReply.h"
    3030
    3131/* Forward declarations: */
    … …  
    7171    const QString& description() const { return m_strDescription; }
    7272    UINetworkCustomer* customer() { return m_pCustomer; }
    73     QNetworkReply* reply() { return m_pReply; }
     73    UINetworkReply* reply() { return m_pReply; }
    7474
    7575private slots:
    … …  
    109109    QString m_strDescription;
    110110    UINetworkCustomer *m_pCustomer;
    111     QPointer<QNetworkReply> m_pReply;
     111    QPointer<UINetworkReply> m_pReply;
    112112    bool m_fRunning;
    113113};

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIUpdateManager.cpp

    r41689 r43707  
    1919
    2020/* Qt includes: */
    21 #include <QNetworkReply>
    2221#include <QTimer>
    2322#include <QDir>
    … …  
    3029#include "UINetworkManager.h"
    3130#include "UINetworkCustomer.h"
     31#include "UINetworkRequest.h"
    3232#include "VBoxGlobal.h"
    3333#include "UIMessageCenter.h"
    … …  
    131131    void processNetworkReplyProgress(qint64, qint64) {}
    132132    /* Network reply canceled handler dummy: */
    133     void processNetworkReplyCanceled(QNetworkReply*) {}
     133    void processNetworkReplyCanceled(UINetworkReply*) {}
    134134    /* Network reply canceled handler dummy: */
    135     void processNetworkReplyFinished(QNetworkReply*) {}
     135    void processNetworkReplyFinished(UINetworkReply*) {}
    136136};
    137137
    … …  
    196196        request.setUrl(url);
    197197        request.setRawHeader("User-Agent", strUserAgent.toAscii());
     198#ifdef Q_WS_X11
     199        createNetworkRequest(request, UINetworkRequestType_GET_Our, tr("Checking for a new VirtualBox version..."));
     200#else /* Q_WS_X11 */
    198201        createNetworkRequest(request, UINetworkRequestType_GET, tr("Checking for a new VirtualBox version..."));
     202#endif /* !Q_WS_X11 */
    199203    }
    200204
    201205    /* Handle network reply canceled: */
    202     void processNetworkReplyCanceled(QNetworkReply* /* pReply */)
     206    void processNetworkReplyCanceled(UINetworkReply* /* pReply */)
    203207    {
    204208        /* Notify about step completion: */
    … …  
    207211
    208212    /* Handle network reply: */
    209     void processNetworkReplyFinished(QNetworkReply *pReply)
     213    void processNetworkReplyFinished(UINetworkReply *pReply)
    210214    {
    211215        /* Deserialize incoming data: */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette