VirtualBox

Changeset 52719 in vbox for trunk


Ignore:
Timestamp:
Sep 12, 2014 12:33:41 PM (10 years ago)
Author:
vboxsync
Message:

Main/Event: wrapper conversion, not covering the automatically generated event implementations

Location:
trunk/src/VBox/Main
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/idl/comimpl.xsl

    r50857 r52719  
    1414        Further extension to other interfaces is possible and anticipated.
    1515
    16     Copyright (C) 2010-2013 Oracle Corporation
     16    Copyright (C) 2010-2014 Oracle Corporation
    1717
    1818    This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4747
    4848/*
    49  * Copyright (C) 2010-2013 Oracle Corporation
     49 * Copyright (C) 2010-2014 Oracle Corporation
    5050 *
    5151 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    496496        BaseFinalRelease();
    497497    }
    498     STDMETHOD(COMGETTER(Type)) (VBoxEventType_T *aType)
    499     {
    500         return ((VBoxEvent*)mEvent)->COMGETTER(Type) (aType);
    501     }
    502     STDMETHOD(COMGETTER(Source)) (IEventSource * *aSource)
    503     {
    504         return ((VBoxEvent*)mEvent)->COMGETTER(Source) (aSource);
    505     }
    506     STDMETHOD(COMGETTER(Waitable)) (BOOL *aWaitable)
    507     {
    508         return ((VBoxEvent*)mEvent)->COMGETTER(Waitable) (aWaitable);
     498    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType)
     499    {
     500        return mEvent->COMGETTER(Type)(aType);
     501    }
     502    STDMETHOD(COMGETTER(Source))(IEventSource * *aSource)
     503    {
     504        return mEvent->COMGETTER(Source)(aSource);
     505    }
     506    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable)
     507    {
     508        return mEvent->COMGETTER(Waitable)(aWaitable);
    509509    }
    510510    STDMETHOD(SetProcessed)()
    511511    {
    512        return ((VBoxEvent*)mEvent)->SetProcessed();
     512       return mEvent->SetProcessed();
    513513    }
    514514    STDMETHOD(WaitProcessed)(LONG aTimeout, BOOL *aResult)
    515515    {
    516         return ((VBoxEvent*)mEvent)->WaitProcessed(aTimeout, aResult);
     516        return mEvent->WaitProcessed(aTimeout, aResult);
    517517    }
    518518    void uninit()
    … …  
    557557        return mEvent->init(aSource, aType, aWaitable);
    558558    }
    559     STDMETHOD(COMGETTER(Generation)) (ULONG *aGeneration)
     559    STDMETHOD(COMGETTER(Generation))(ULONG *aGeneration)
    560560    {
    561561      *aGeneration = mGeneration;
    562562      return S_OK;
    563563    }
    564     STDMETHOD(Reuse) ()
     564    STDMETHOD(Reuse)()
    565565    {
    566566       ASMAtomicIncU32((volatile uint32_t*)&mGeneration);

  • trunk/src/VBox/Main/include/EventImpl.h

    r50544 r52719  
    55
    66/*
    7  * Copyright (C) 2010-2012 Oracle Corporation
     7 * Copyright (C) 2010-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919#define ____H_EVENTIMPL
    2020
    21 #include "VirtualBoxBase.h"
     21#include "EventWrap.h"
     22#include "EventSourceWrap.h"
     23#include "VetoEventWrap.h"
    2224
    2325
    2426class ATL_NO_VTABLE VBoxEvent :
    25     public VirtualBoxBase,
    26     VBOX_SCRIPTABLE_IMPL(IEvent)
     27    public EventWrap
    2728{
    2829public:
    29     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxEvent, IEvent)
    30 
    31     DECLARE_NOT_AGGREGATABLE(VBoxEvent)
    32 
    33     DECLARE_PROTECT_FINAL_CONSTRUCT()
    34 
    35     BEGIN_COM_MAP(VBoxEvent)
    36         VBOX_DEFAULT_INTERFACE_ENTRIES(IEvent)
    37     END_COM_MAP()
    38 
    39     VBoxEvent() {}
    40     virtual ~VBoxEvent() {}
     30    DECLARE_EMPTY_CTOR_DTOR(VBoxEvent)
    4131
    4232    HRESULT FinalConstruct();
    … …  
    4737    void uninit();
    4838
    49     // IEvent properties
    50     STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    51     STDMETHOD(COMGETTER(Source))(IEventSource * *aSource);
    52     STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
     39private:
     40    // wrapped IEvent properties
     41    HRESULT getType(VBoxEventType_T *aType);
     42    HRESULT getSource(ComPtr<IEventSource> &aSource);
     43    HRESULT getWaitable(BOOL *aWaitable);
    5344
    54     // IEvent methods
    55     STDMETHOD(SetProcessed)();
    56     STDMETHOD(WaitProcessed)(LONG aTimeout, BOOL *aResult);
     45    // wrapped IEvent methods
     46    HRESULT setProcessed();
     47    HRESULT waitProcessed(LONG aTimeout, BOOL *aResult);
    5748
    58 private:
    5949    struct Data;
    60 
    6150    Data* m;
    6251};
    6352
     53
    6454class ATL_NO_VTABLE VBoxVetoEvent :
    65     public VBoxEvent,
    66     VBOX_SCRIPTABLE_IMPL(IVetoEvent)
     55    public virtual VetoEventWrap
    6756{
    6857public:
    69     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxVetoEvent, IVetoEvent)
    70 
    71     DECLARE_NOT_AGGREGATABLE(VBoxVetoEvent)
    72 
    73     DECLARE_PROTECT_FINAL_CONSTRUCT()
    74 
    75     BEGIN_COM_MAP(VBoxVetoEvent)
    76         COM_INTERFACE_ENTRY2(IEvent, IVetoEvent)
    77         VBOX_DEFAULT_INTERFACE_ENTRIES(IVetoEvent)
    78     END_COM_MAP()
    79 
    80     VBoxVetoEvent() {}
    81     virtual ~VBoxVetoEvent() {}
     58    DECLARE_EMPTY_CTOR_DTOR(VBoxVetoEvent)
    8259
    8360    HRESULT FinalConstruct();
    … …  
    8865    void uninit();
    8966
    90     // IEvent properties
    91     STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType)
    92     {
    93         return VBoxEvent::COMGETTER(Type)(aType);
    94     }
    95     STDMETHOD(COMGETTER(Source))(IEventSource * *aSource)
    96     {
    97         return VBoxEvent::COMGETTER(Source)(aSource);
    98     }
    99     STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable)
    100     {
    101         return VBoxEvent::COMGETTER(Waitable)(aWaitable);
    102     }
     67private:
     68    // wrapped IEvent properties
     69    HRESULT getType(VBoxEventType_T *aType);
     70    HRESULT getSource(ComPtr<IEventSource> &aSource);
     71    HRESULT getWaitable(BOOL *aWaitable);
    10372
    104     // IEvent methods
    105     STDMETHOD(SetProcessed)()
    106     {
    107         return VBoxEvent::SetProcessed();
    108     }
    109     STDMETHOD(WaitProcessed)(LONG aTimeout, BOOL *aResult)
    110     {
    111         return VBoxEvent::WaitProcessed(aTimeout, aResult);
    112     }
     73    // wrapped IEvent methods
     74    HRESULT setProcessed();
     75    HRESULT waitProcessed(LONG aTimeout, BOOL *aResult);
    11376
    114      // IVetoEvent methods
    115     STDMETHOD(AddVeto)(IN_BSTR aVeto);
    116     STDMETHOD(IsVetoed)(BOOL *aResult);
    117     STDMETHOD(GetVetos)(ComSafeArrayOut(BSTR, aVetos));
     77    // wrapped IVetoEvent methods
     78    HRESULT addVeto(const com::Utf8Str &aReason);
     79    HRESULT isVetoed(BOOL *aResult);
     80    HRESULT getVetos(std::vector<com::Utf8Str> &aResult);
    11881
    119 private:
    12082    struct Data;
    121 
    12283    Data* m;
    12384};
    12485
    12586class ATL_NO_VTABLE EventSource :
    126     public VirtualBoxBase,
    127     VBOX_SCRIPTABLE_IMPL(IEventSource)
     87    public EventSourceWrap
    12888{
    12989public:
    130 
    131     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventSource, IEventSource)
    132 
    133     DECLARE_NOT_AGGREGATABLE(EventSource)
    134 
    135     DECLARE_PROTECT_FINAL_CONSTRUCT()
    136 
    137     BEGIN_COM_MAP(EventSource)
    138         VBOX_DEFAULT_INTERFACE_ENTRIES(IEventSource)
    139     END_COM_MAP()
    140 
    14190    DECLARE_EMPTY_CTOR_DTOR(EventSource)
    14291
    … …  
    14897    void uninit();
    14998
    150     // IEventSource methods
    151     STDMETHOD(CreateListener)(IEventListener **aListener);
    152     STDMETHOD(CreateAggregator)(ComSafeArrayIn(IEventSource *, aSubordinates),
    153                                 IEventSource **aAggregator);
    154     STDMETHOD(RegisterListener)(IEventListener *aListener,
    155                                 ComSafeArrayIn(VBoxEventType_T, aInterested),
    156                                 BOOL aActive);
    157     STDMETHOD(UnregisterListener)(IEventListener *aListener);
    158     STDMETHOD(FireEvent)(IEvent *aEvent, LONG aTimeout, BOOL *aProcessed);
    159     STDMETHOD(GetEvent)(IEventListener *aListener, LONG aTimeout,
    160                         IEvent **aEvent);
    161     STDMETHOD(EventProcessed)(IEventListener *aListener, IEvent *aEvent);
     99private:
     100    // wrapped IEventSource methods
     101    HRESULT createListener(ComPtr<IEventListener> &aListener);
     102    HRESULT createAggregator(const std::vector<ComPtr<IEventSource> > &aSubordinates,
     103                             ComPtr<IEventSource> &aResult);
     104    HRESULT registerListener(const ComPtr<IEventListener> &aListener,
     105                             const std::vector<VBoxEventType_T> &aInteresting,
     106                             BOOL aActive);
     107    HRESULT unregisterListener(const ComPtr<IEventListener> &aListener);
     108    HRESULT fireEvent(const ComPtr<IEvent> &aEvent,
     109                      LONG aTimeout,
     110                      BOOL *aResult);
     111    HRESULT getEvent(const ComPtr<IEventListener> &aListener,
     112                     LONG aTimeout,
     113                     ComPtr<IEvent> &aEvent);
     114    HRESULT eventProcessed(const ComPtr<IEventListener> &aListener,
     115                           const ComPtr<IEvent> &aEvent);
    162116
    163 private:
     117
    164118    struct Data;
    165 
    166119    Data* m;
    167120
    … …  
    220173};
    221174
     175
    222176#endif // ____H_EVENTIMPL

  • trunk/src/VBox/Main/src-all/EventImpl.cpp

    r52413 r52719  
    8383};
    8484
     85DEFINE_EMPTY_CTOR_DTOR(VBoxEvent)
     86
    8587HRESULT VBoxEvent::FinalConstruct()
    8688{
    … …  
    9597        uninit();
    9698        delete m;
    97         m = 0;
    98         BaseFinalRelease();
    99     }
     99        m = NULL;
     100    }
     101    BaseFinalRelease();
    100102}
    101103
    … …  
    151153}
    152154
    153 STDMETHODIMP VBoxEvent::COMGETTER(Type)(VBoxEventType_T *aType)
    154 {
    155     CheckComArgNotNull(aType);
    156 
    157     AutoCaller autoCaller(this);
    158     if (FAILED(autoCaller.rc()))
    159         return autoCaller.rc();
    160 
     155HRESULT VBoxEvent::getType(VBoxEventType_T *aType)
     156{
    161157    // never changes while event alive, no locking
    162158    *aType = m->mType;
    … …  
    164160}
    165161
    166 STDMETHODIMP VBoxEvent::COMGETTER(Source)(IEventSource **aSource)
    167 {
    168     CheckComArgOutPointerValid(aSource);
    169 
    170     AutoCaller autoCaller(this);
    171     if (FAILED(autoCaller.rc()))
    172         return autoCaller.rc();
    173 
    174     m->mSource.queryInterfaceTo(aSource);
    175     return S_OK;
    176 }
    177 
    178 STDMETHODIMP VBoxEvent::COMGETTER(Waitable)(BOOL *aWaitable)
    179 {
    180     CheckComArgNotNull(aWaitable);
    181 
    182     AutoCaller autoCaller(this);
    183     if (FAILED(autoCaller.rc()))
    184         return autoCaller.rc();
    185 
     162HRESULT VBoxEvent::getSource(ComPtr<IEventSource> &aSource)
     163{
     164    m->mSource.queryInterfaceTo(aSource.asOutParam());
     165    return S_OK;
     166}
     167
     168HRESULT VBoxEvent::getWaitable(BOOL *aWaitable)
     169{
    186170    // never changes while event alive, no locking
    187171    *aWaitable = m->mWaitable;
    … …  
    189173}
    190174
    191 
    192 STDMETHODIMP VBoxEvent::SetProcessed()
    193 {
    194     AutoCaller autoCaller(this);
    195     if (FAILED(autoCaller.rc()))
    196         return autoCaller.rc();
    197 
     175HRESULT VBoxEvent::setProcessed()
     176{
    198177    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    199178
    … …  
    209188}
    210189
    211 STDMETHODIMP VBoxEvent::WaitProcessed(LONG aTimeout, BOOL *aResult)
    212 {
    213     CheckComArgNotNull(aResult);
    214 
    215     AutoCaller autoCaller(this);
    216     if (FAILED(autoCaller.rc()))
    217         return autoCaller.rc();
    218 
    219     {
    220         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    221 
    222         if (m->mProcessed)
    223         {
    224             *aResult = TRUE;
    225             return S_OK;
    226         }
    227 
    228         if (aTimeout == 0)
    229         {
    230             *aResult = m->mProcessed;
    231             return S_OK;
    232         }
     190HRESULT VBoxEvent::waitProcessed(LONG aTimeout, BOOL *aResult)
     191{
     192    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     193
     194    if (m->mProcessed)
     195    {
     196        *aResult = TRUE;
     197        return S_OK;
     198    }
     199
     200    if (aTimeout == 0)
     201    {
     202        *aResult = m->mProcessed;
     203        return S_OK;
    233204    }
    234205
    … …  
    252223}
    253224
    254 typedef std::list<Bstr> VetoList;
     225typedef std::list<Utf8Str> VetoList;
    255226struct VBoxVetoEvent::Data
    256227{
    … …  
    258229        mVetoed(FALSE)
    259230    {}
     231    ComObjPtr<VBoxEvent>    mEvent;
    260232    BOOL                    mVetoed;
    261233    VetoList                mVetoList;
    … …  
    264236HRESULT VBoxVetoEvent::FinalConstruct()
    265237{
    266     VBoxEvent::FinalConstruct();
    267238    m = new Data;
    268     return S_OK;
     239    HRESULT rc = m->mEvent.createObject();
     240    BaseFinalConstruct();
     241    return rc;
    269242}
    270243
    … …  
    275248        uninit();
    276249        delete m;
    277         m = 0;
    278     }
    279     VBoxEvent::FinalRelease();
    280 }
    281 
     250        m = NULL;
     251    }
     252    BaseFinalRelease();
     253}
     254
     255DEFINE_EMPTY_CTOR_DTOR(VBoxVetoEvent)
    282256
    283257HRESULT VBoxVetoEvent::init(IEventSource *aSource, VBoxEventType_T aType)
    … …  
    285259    HRESULT rc = S_OK;
    286260    // all veto events are waitable
    287     rc = VBoxEvent::init(aSource, aType, TRUE);
     261    rc = m->mEvent->init(aSource, aType, TRUE);
    288262    if (FAILED(rc))
    289263        return rc;
    … …  
    292266    m->mVetoList.clear();
    293267
    294     return rc;
     268    return S_OK;
    295269}
    296270
    297271void VBoxVetoEvent::uninit()
    298272{
    299     VBoxEvent::uninit();
    300273    if (!m)
    301274        return;
     275
    302276    m->mVetoed = FALSE;
    303 }
    304 
    305 STDMETHODIMP VBoxVetoEvent::AddVeto(IN_BSTR aVeto)
    306 {
    307     AutoCaller autoCaller(this);
    308     if (FAILED(autoCaller.rc()))
    309         return autoCaller.rc();
    310 
    311     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    312 
    313     if (aVeto)
    314         m->mVetoList.push_back(aVeto);
     277    if (!m->mEvent.isNull())
     278    {
     279        m->mEvent->uninit();
     280        m->mEvent.setNull();
     281    }
     282}
     283
     284HRESULT VBoxVetoEvent::getType(VBoxEventType_T *aType)
     285{
     286    return m->mEvent->COMGETTER(Type)(aType);
     287}
     288
     289HRESULT VBoxVetoEvent::getSource(ComPtr<IEventSource> &aSource)
     290{
     291    return m->mEvent->COMGETTER(Source)(aSource.asOutParam());
     292}
     293
     294HRESULT VBoxVetoEvent::getWaitable(BOOL *aWaitable)
     295{
     296    return m->mEvent->COMGETTER(Waitable)(aWaitable);
     297}
     298
     299HRESULT VBoxVetoEvent::setProcessed()
     300{
     301    return m->mEvent->SetProcessed();
     302}
     303
     304HRESULT VBoxVetoEvent::waitProcessed(LONG aTimeout, BOOL *aResult)
     305{
     306    return m->mEvent->WaitProcessed(aTimeout, aResult);
     307}
     308
     309HRESULT VBoxVetoEvent::addVeto(const com::Utf8Str &aReason)
     310{
     311    // AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     312    if (aReason.length())
     313        m->mVetoList.push_back(aReason);
    315314
    316315    m->mVetoed = TRUE;
    … …  
    319318}
    320319
    321 STDMETHODIMP VBoxVetoEvent::IsVetoed(BOOL *aResult)
    322 {
    323     CheckComArgOutPointerValid(aResult);
    324 
    325     AutoCaller autoCaller(this);
    326     if (FAILED(autoCaller.rc()))
    327         return autoCaller.rc();
    328 
    329     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    330 
     320HRESULT VBoxVetoEvent::isVetoed(BOOL *aResult)
     321{
     322    // AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    331323    *aResult = m->mVetoed;
    332324
    … …  
    334326}
    335327
    336 STDMETHODIMP VBoxVetoEvent::GetVetos(ComSafeArrayOut(BSTR, aVetos))
    337 {
    338     if (ComSafeArrayOutIsNull(aVetos))
    339         return E_POINTER;
    340 
    341     AutoCaller autoCaller(this);
    342     if (FAILED(autoCaller.rc()))
    343         return autoCaller.rc();
    344 
    345     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    346     com::SafeArray<BSTR> vetos(m->mVetoList.size());
    347     int i = 0;
    348     for (VetoList::const_iterator it = m->mVetoList.begin();
    349          it != m->mVetoList.end();
    350          ++it, ++i)
    351     {
    352         const Bstr &str = *it;
    353         str.cloneTo(&vetos[i]);
    354     }
    355     vetos.detachTo(ComSafeArrayOutArg(aVetos));
     328HRESULT VBoxVetoEvent::getVetos(std::vector<com::Utf8Str> &aResult)
     329{
     330    // AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     331    aResult.resize(m->mVetoList.size());
     332    size_t i = 0;
     333    for (VetoList::const_iterator it = m->mVetoList.begin(); it != m->mVetoList.end(); ++it, ++i)
     334        aResult[i] = (*it);
    356335
    357336    return S_OK;
    … …  
    1006985}
    1007986
    1008 STDMETHODIMP EventSource::RegisterListener(IEventListener *aListener,
    1009                                            ComSafeArrayIn(VBoxEventType_T, aInterested),
    1010                                            BOOL aActive)
    1011 {
    1012     CheckComArgNotNull(aListener);
    1013     CheckComArgSafeArrayNotNull(aInterested);
    1014 
    1015     AutoCaller autoCaller(this);
    1016     if (FAILED(autoCaller.rc()))
    1017         return autoCaller.rc();
    1018 
    1019     {
    1020         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1021 
    1022         if (m->fShutdown)
    1023             return setError(VBOX_E_INVALID_OBJECT_STATE,
    1024                             tr("This event source is already shut down"));
    1025 
    1026         Listeners::const_iterator it = m->mListeners.find(aListener);
    1027         if (it != m->mListeners.end())
    1028             return setError(E_INVALIDARG,
    1029                             tr("This listener already registered"));
    1030 
    1031         com::SafeArray<VBoxEventType_T> interested(ComSafeArrayInArg(aInterested));
    1032         RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
    1033         m->mListeners.insert(Listeners::value_type(aListener, lrh));
    1034     }
     987HRESULT EventSource::registerListener(const ComPtr<IEventListener> &aListener,
     988                                      const std::vector<VBoxEventType_T> &aInteresting,
     989                                      BOOL aActive)
     990{
     991    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     992
     993    if (m->fShutdown)
     994        return setError(VBOX_E_INVALID_OBJECT_STATE,
     995                        tr("This event source is already shut down"));
     996
     997    Listeners::const_iterator it = m->mListeners.find(aListener);
     998    if (it != m->mListeners.end())
     999        return setError(E_INVALIDARG,
     1000                        tr("This listener already registered"));
     1001
     1002    com::SafeArray<VBoxEventType_T> interested(aInteresting);
     1003    RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
     1004    m->mListeners.insert(Listeners::value_type((IEventListener *)aListener, lrh));
    10351005
    10361006    VBoxEventDesc evDesc;
    1037     evDesc.init(this, VBoxEventType_OnEventSourceChanged, aListener, TRUE);
     1007    evDesc.init(this, VBoxEventType_OnEventSourceChanged, (IEventListener *)aListener, TRUE);
    10381008    evDesc.fire(0);
    10391009
    … …  
    10411011}
    10421012
    1043 STDMETHODIMP EventSource::UnregisterListener(IEventListener *aListener)
    1044 {
    1045     CheckComArgNotNull(aListener);
    1046 
    1047     AutoCaller autoCaller(this);
    1048     if (FAILED(autoCaller.rc()))
    1049         return autoCaller.rc();
    1050 
    1051     HRESULT rc;
    1052     {
    1053         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1054 
    1055         Listeners::iterator it = m->mListeners.find(aListener);
    1056 
    1057         if (it != m->mListeners.end())
    1058         {
    1059             it->second.obj()->shutdown();
    1060             m->mListeners.erase(it);
    1061             // destructor removes refs from the event map
    1062             rc = S_OK;
    1063         }
    1064         else
    1065         {
    1066             rc = setError(VBOX_E_OBJECT_NOT_FOUND,
    1067                           tr("Listener was never registered"));
    1068         }
     1013HRESULT EventSource::unregisterListener(const ComPtr<IEventListener> &aListener)
     1014{
     1015    HRESULT rc = S_OK;;
     1016
     1017    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1018
     1019    Listeners::iterator it = m->mListeners.find(aListener);
     1020
     1021    if (it != m->mListeners.end())
     1022    {
     1023        it->second.obj()->shutdown();
     1024        m->mListeners.erase(it);
     1025        // destructor removes refs from the event map
     1026        rc = S_OK;
     1027    }
     1028    else
     1029    {
     1030        rc = setError(VBOX_E_OBJECT_NOT_FOUND,
     1031                      tr("Listener was never registered"));
    10691032    }
    10701033
    … …  
    10721035    {
    10731036        VBoxEventDesc evDesc;
    1074         evDesc.init(this, VBoxEventType_OnEventSourceChanged, aListener, FALSE);
     1037        evDesc.init(this, VBoxEventType_OnEventSourceChanged, (IEventListener *)aListener, FALSE);
    10751038        evDesc.fire(0);
    10761039    }
    … …  
    10791042}
    10801043
    1081 STDMETHODIMP EventSource::FireEvent(IEvent *aEvent,
    1082                                     LONG aTimeout,
    1083                                     BOOL *aProcessed)
    1084 {
    1085     CheckComArgNotNull(aEvent);
    1086     CheckComArgOutPointerValid(aProcessed);
    1087 
    1088     AutoCaller autoCaller(this);
    1089     if (FAILED(autoCaller.rc()))
    1090         return autoCaller.rc();
    1091 
    1092     HRESULT hrc;
     1044HRESULT EventSource::fireEvent(const ComPtr<IEvent> &aEvent,
     1045                               LONG aTimeout,
     1046                               BOOL *aResult)
     1047{
     1048
     1049    HRESULT hrc = S_OK;
    10931050    BOOL aWaitable = FALSE;
    10941051    aEvent->COMGETTER(Waitable)(&aWaitable);
    … …  
    11581115
    11591116    if (aWaitable)
    1160         hrc = aEvent->WaitProcessed(aTimeout, aProcessed);
     1117        hrc = aEvent->WaitProcessed(aTimeout, aResult);
    11611118    else
    1162         *aProcessed = TRUE;
     1119        *aResult = TRUE;
    11631120
    11641121    return hrc;
    11651122}
    11661123
    1167 
    1168 STDMETHODIMP EventSource::GetEvent(IEventListener *aListener,
    1169                                    LONG aTimeout,
    1170                                    IEvent **aEvent)
    1171 {
    1172 
    1173     CheckComArgNotNull(aListener);
    1174 
    1175     AutoCaller autoCaller(this);
    1176     if (FAILED(autoCaller.rc()))
    1177         return autoCaller.rc();
    1178 
     1124HRESULT EventSource::getEvent(const ComPtr<IEventListener> &aListener,
     1125                              LONG aTimeout,
     1126                              ComPtr<IEvent> &aEvent)
     1127{
    11791128    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    11801129
    … …  
    11841133
    11851134    Listeners::iterator it = m->mListeners.find(aListener);
    1186     HRESULT rc;
     1135    HRESULT rc = S_OK;
     1136
     1137    IEvent *ae = aEvent;
    11871138
    11881139    if (it != m->mListeners.end())
    1189         rc = it->second.obj()->dequeue(aEvent, aTimeout, alock);
     1140        rc = it->second.obj()->dequeue(&ae, aTimeout, alock);
    11901141    else
    11911142        rc = setError(VBOX_E_OBJECT_NOT_FOUND,
    … …  
    11981149}
    11991150
    1200 STDMETHODIMP EventSource::EventProcessed(IEventListener *aListener,
    1201                                          IEvent *aEvent)
    1202 {
    1203     CheckComArgNotNull(aListener);
    1204     CheckComArgNotNull(aEvent);
    1205 
    1206     AutoCaller autoCaller(this);
    1207     if (FAILED(autoCaller.rc()))
    1208         return autoCaller.rc();
    1209 
     1151HRESULT EventSource::eventProcessed(const ComPtr<IEventListener> &aListener,
     1152                                    const ComPtr<IEvent> &aEvent)
     1153{
    12101154    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    12111155
    … …  
    13911335
    13921336    // internal public
    1393     HRESULT init(ComSafeArrayIn(IEventSource *, aSources));
     1337    HRESULT init(const std::vector<ComPtr<IEventSource> >  aSourcesIn);
    13941338
    13951339    // IEventSource methods
    … …  
    14231367NS_DECL_CLASSINFO(PassiveEventListener)
    14241368NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PassiveEventListener, IEventListener)
    1425 NS_DECL_CLASSINFO(VBoxEvent)
    1426 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VBoxEvent, IEvent)
    1427 NS_DECL_CLASSINFO(VBoxVetoEvent)
    14281369NS_IMPL_ISUPPORTS_INHERITED1(VBoxVetoEvent, VBoxEvent, IVetoEvent)
    1429 NS_DECL_CLASSINFO(EventSource)
    1430 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventSource, IEventSource)
    14311370NS_DECL_CLASSINFO(EventSourceAggregator)
    14321371NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventSourceAggregator, IEventSource)
    … …  
    14341373
    14351374
    1436 STDMETHODIMP EventSource::CreateListener(IEventListener **aListener)
    1437 {
    1438     CheckComArgOutPointerValid(aListener);
    1439 
    1440     AutoCaller autoCaller(this);
    1441     if (FAILED(autoCaller.rc()))
    1442         return autoCaller.rc();
    1443 
     1375HRESULT EventSource::createListener(ComPtr<IEventListener> &aListener)
     1376{
    14441377    ComObjPtr<PassiveEventListener> listener;
    14451378
    … …  
    14471380    ComAssertMsgRet(SUCCEEDED(rc), ("Could not create wrapper object (%Rhrc)", rc),
    14481381                    E_FAIL);
    1449     listener.queryInterfaceTo(aListener);
    1450     return S_OK;
    1451 }
    1452 
    1453 
    1454 STDMETHODIMP EventSource::CreateAggregator(ComSafeArrayIn(IEventSource *, aSubordinates),
    1455                                            IEventSource **aResult)
    1456 {
    1457     CheckComArgOutPointerValid(aResult);
    1458 
    1459     AutoCaller autoCaller(this);
    1460     if (FAILED(autoCaller.rc()))
    1461         return autoCaller.rc();
    1462 
     1382    listener.queryInterfaceTo(aListener.asOutParam());
     1383    return S_OK;
     1384}
     1385
     1386HRESULT EventSource::createAggregator(const std::vector<ComPtr<IEventSource> > &aSubordinates,
     1387                                      ComPtr<IEventSource> &aResult)
     1388{
    14631389    ComObjPtr<EventSourceAggregator> agg;
    14641390
    … …  
    14671393                    E_FAIL);
    14681394
    1469     rc = agg->init(ComSafeArrayInArg(aSubordinates));
     1395    rc = agg->init(aSubordinates);
    14701396    if (FAILED(rc))
    14711397        return rc;
    14721398
    1473     agg.queryInterfaceTo(aResult);
    1474     return S_OK;
    1475 }
    1476 
    1477 HRESULT EventSourceAggregator::init(ComSafeArrayIn(IEventSource *, aSourcesIn))
     1399    agg.queryInterfaceTo(aResult.asOutParam());
     1400    return S_OK;
     1401}
     1402
     1403HRESULT EventSourceAggregator::init(const std::vector<ComPtr<IEventSource> >  aSourcesIn)
    14781404{
    14791405    HRESULT rc;
    … …  
    14891415                    E_FAIL);
    14901416
    1491     com::SafeIfaceArray<IEventSource> aSources(ComSafeArrayInArg (aSourcesIn));
    1492 
    1493     size_t cSize = aSources.size();
    1494 
    1495     for (size_t i = 0; i < cSize; i++)
    1496     {
    1497         if (aSources[i] != NULL)
    1498             mEventSources.push_back(aSources[i]);
     1417    for (size_t i = 0; i < aSourcesIn.size(); i++)
     1418    {
     1419        if (aSourcesIn[i] != NULL)
     1420            mEventSources.push_back(aSourcesIn[i]);
    14991421    }
    15001422
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