VirtualBox

Changeset 50919 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Mar 28, 2014 3:21:43 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
93053
Message:

6183 src-all/SharedFolderImpl.cpp

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

Legend:

Unmodified
Added
Removed

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

    r50174 r50919  
    1919#define ____H_SHAREDFOLDERIMPL
    2020
    21 #include "VirtualBoxBase.h"
     21#include "SharedFolderWrap.h"
    2222#include <VBox/shflsvc.h>
    2323
    … …  
    2525
    2626class ATL_NO_VTABLE SharedFolder :
    27     public VirtualBoxBase,
    28     VBOX_SCRIPTABLE_IMPL(ISharedFolder)
     27    public SharedFolderWrap
    2928{
    3029public:
    31 
    32     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SharedFolder, ISharedFolder)
    33 
    34     DECLARE_NOT_AGGREGATABLE(SharedFolder)
    35 
    36     DECLARE_PROTECT_FINAL_CONSTRUCT()
    37 
    38     BEGIN_COM_MAP(SharedFolder)
    39         VBOX_DEFAULT_INTERFACE_ENTRIES  (ISharedFolder)
    40     END_COM_MAP()
    4130
    4231    DECLARE_EMPTY_CTOR_DTOR (SharedFolder)
    … …  
    5241    void uninit();
    5342
    54     // ISharedFolder properties
    55     STDMETHOD(COMGETTER(Name)) (BSTR *aName);
    56     STDMETHOD(COMGETTER(HostPath)) (BSTR *aHostPath);
    57     STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
    58     STDMETHOD(COMGETTER(Writable)) (BOOL *aWritable);
    59     STDMETHOD(COMGETTER(AutoMount)) (BOOL *aAutoMount);
    60     STDMETHOD(COMGETTER(LastAccessError)) (BSTR *aLastAccessError);
    61 
    6243    // public methods for internal purposes only
    6344    // (ensure there is a caller and a read lock before calling them!)
    … …  
    6748     * @return
    6849     */
    69     const Utf8Str& getName() const;
     50    const Utf8Str& i_getName() const;
    7051
    7152    /**
    … …  
    7354     * @return
    7455     */
    75     const Utf8Str& getHostPath() const;
     56    const Utf8Str& i_getHostPath() const;
    7657
    7758    /**
    … …  
    7960     * @return
    8061     */
    81     bool isWritable() const;
     62    bool i_isWritable() const;
    8263
    8364    /**
    … …  
    8566     * @return
    8667     */
    87     bool isAutoMounted() const;
     68    bool i_isAutoMounted() const;
    8869
    8970protected:
    9071
    91     HRESULT protectedInit(VirtualBoxBase *aParent,
    92                           const Utf8Str &aName,
    93                           const Utf8Str &aHostPath,
    94                           bool aWritable,
    95                           bool aAutoMount,
    96                           bool fFailOnError);
     72    HRESULT i_protectedInit(VirtualBoxBase *aParent,
     73                            const Utf8Str &aName,
     74                            const Utf8Str &aHostPath,
     75                            bool aWritable,
     76                            bool aAutoMount,
     77                            bool fFailOnError);
    9778private:
     79
     80    // wrapped ISharedFolder properies.
     81    HRESULT getName(com::Utf8Str &aName);
     82    HRESULT getHostPath(com::Utf8Str &aHostPath);
     83    HRESULT getAccessible(BOOL *aAccessible);
     84    HRESULT getWritable(BOOL *aWritable);
     85    HRESULT getAutoMount(BOOL *aAutoMount);
     86    HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
    9887
    9988    VirtualBoxBase * const mParent;

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

    r46820 r50919  
    111111    unconst(mMachine) = aMachine;
    112112
    113     HRESULT rc = protectedInit(aMachine, aName, aHostPath, aWritable, aAutoMount, fFailOnError);
     113    HRESULT rc = i_protectedInit(aMachine, aName, aHostPath, aWritable, aAutoMount, fFailOnError);
    114114
    115115    /* Confirm a successful initialization when it's the case */
    … …  
    140140    unconst(mMachine) = aMachine;
    141141
    142     HRESULT rc = protectedInit(aMachine,
    143                                aThat->m->strName,
    144                                aThat->m->strHostPath,
    145                                aThat->m->fWritable,
    146                                aThat->m->fAutoMount,
    147                                false /* fFailOnError */ );
     142    HRESULT rc = i_protectedInit(aMachine,
     143                                 aThat->m->strName,
     144                                 aThat->m->strHostPath,
     145                                 aThat->m->fWritable,
     146                                 aThat->m->fAutoMount,
     147                                 false /* fFailOnError */ );
    148148
    149149    /* Confirm a successful initialization when it's the case */
    … …  
    221221    unconst(mConsole) = aConsole;
    222222
    223     HRESULT rc = protectedInit(aConsole, aName, aHostPath, aWritable, aAutoMount, fFailOnError);
     223    HRESULT rc = i_protectedInit(aConsole, aName, aHostPath, aWritable, aAutoMount, fFailOnError);
    224224
    225225    /* Confirm a successful initialization when it's the case */
    … …  
    237237 *      Must be called from under the object's lock!
    238238 */
    239 HRESULT SharedFolder::protectedInit(VirtualBoxBase *aParent,
    240                                     const Utf8Str &aName,
    241                                     const Utf8Str &aHostPath,
    242                                     bool aWritable,
    243                                     bool aAutoMount,
    244                                     bool fFailOnError)
     239HRESULT SharedFolder::i_protectedInit(VirtualBoxBase *aParent,
     240                                      const Utf8Str &aName,
     241                                      const Utf8Str &aHostPath,
     242                                      bool aWritable,
     243                                      bool aAutoMount,
     244                                      bool fFailOnError)
    245245{
    246246    LogFlowThisFunc(("aName={%s}, aHostPath={%s}, aWritable={%d}, aAutoMount={%d}\n",
    … …  
    322322}
    323323
    324 // ISharedFolder properties
     324// wrapped ISharedFolder properties
    325325/////////////////////////////////////////////////////////////////////////////
    326 
    327 STDMETHODIMP SharedFolder::COMGETTER(Name) (BSTR *aName)
    328 {
    329     CheckComArgOutPointerValid(aName);
    330 
    331     AutoCaller autoCaller(this);
    332     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    333 
     326HRESULT SharedFolder::getName(com::Utf8Str &aName)
     327{
    334328    /* mName is constant during life time, no need to lock */
    335     m->strName.cloneTo(aName);
    336 
    337     return S_OK;
    338 }
    339 
    340 STDMETHODIMP SharedFolder::COMGETTER(HostPath) (BSTR *aHostPath)
    341 {
    342     CheckComArgOutPointerValid(aHostPath);
    343 
    344     AutoCaller autoCaller(this);
    345     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    346 
     329    aName = m->strName;
     330
     331    return S_OK;
     332}
     333
     334HRESULT SharedFolder::getHostPath(com::Utf8Str &aHostPath)
     335{
    347336    /* mHostPath is constant during life time, no need to lock */
    348     m->strHostPath.cloneTo(aHostPath);
    349 
    350     return S_OK;
    351 }
    352 
    353 STDMETHODIMP SharedFolder::COMGETTER(Accessible) (BOOL *aAccessible)
    354 {
    355     CheckComArgOutPointerValid(aAccessible);
    356 
    357     AutoCaller autoCaller(this);
    358     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    359 
     337    aHostPath = m->strHostPath;
     338
     339    return S_OK;
     340}
     341
     342HRESULT SharedFolder::getAccessible(BOOL *aAccessible)
     343{
    360344    /* mName and mHostPath are constant during life time, no need to lock */
    361345
    … …  
    382366
    383367    *aAccessible = FALSE;
    384     return S_OK;
    385 }
    386 
    387 STDMETHODIMP SharedFolder::COMGETTER(Writable) (BOOL *aWritable)
    388 {
    389     CheckComArgOutPointerValid(aWritable);
    390 
    391     AutoCaller autoCaller(this);
    392     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    393 
     368
     369    return S_OK;
     370}
     371
     372HRESULT SharedFolder::getWritable(BOOL *aWritable)
     373{
    394374    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    395375
    … …  
    399379}
    400380
    401 STDMETHODIMP SharedFolder::COMGETTER(AutoMount) (BOOL *aAutoMount)
    402 {
    403     CheckComArgOutPointerValid(aAutoMount);
    404 
    405     AutoCaller autoCaller(this);
    406     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    407 
     381HRESULT SharedFolder::getAutoMount(BOOL *aAutoMount)
     382{
    408383    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    409384
    … …  
    413388}
    414389
    415 STDMETHODIMP SharedFolder::COMGETTER(LastAccessError) (BSTR *aLastAccessError)
    416 {
    417     CheckComArgOutPointerValid(aLastAccessError);
    418 
    419     AutoCaller autoCaller(this);
    420     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    421 
     390HRESULT SharedFolder::getLastAccessError(com::Utf8Str &aLastAccessError)
     391{
    422392    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    423393
    424     m->strLastAccessError.cloneTo(aLastAccessError);
    425 
    426     return S_OK;
    427 }
    428 
    429 const Utf8Str& SharedFolder::getName() const
     394    aLastAccessError = m->strLastAccessError;
     395
     396    return S_OK;
     397}
     398
     399
     400const Utf8Str& SharedFolder::i_getName() const
    430401{
    431402    return m->strName;
    432403}
    433404
    434 const Utf8Str& SharedFolder::getHostPath() const
     405const Utf8Str& SharedFolder::i_getHostPath() const
    435406{
    436407    return m->strHostPath;
    437408}
    438409
    439 bool SharedFolder::isWritable() const
     410bool SharedFolder::i_isWritable() const
    440411{
    441412    return m->fWritable;
    442413}
    443414
    444 bool SharedFolder::isAutoMounted() const
     415bool SharedFolder::i_isAutoMounted() const
    445416{
    446417    return m->fAutoMount;

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r50914 r50919  
    16121612        AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
    16131613
    1614         Utf8Str name = pSF->getName();
     1614        Utf8Str name = pSF->i_getName();
    16151615        vrc = SSMR3PutU32(pSSM, (uint32_t)name.length() + 1 /* term. 0 */);
    16161616        AssertRC(vrc);
    … …  
    16181618        AssertRC(vrc);
    16191619
    1620         Utf8Str hostPath = pSF->getHostPath();
     1620        Utf8Str hostPath = pSF->i_getHostPath();
    16211621        vrc = SSMR3PutU32(pSSM, (uint32_t)hostPath.length() + 1 /* term. 0 */);
    16221622        AssertRC(vrc);
    … …  
    16241624        AssertRC(vrc);
    16251625
    1626         vrc = SSMR3PutBool(pSSM, !!pSF->isWritable());
     1626        vrc = SSMR3PutBool(pSSM, !!pSF->i_isWritable());
    16271627        AssertRC(vrc);
    16281628
    1629         vrc = SSMR3PutBool(pSSM, !!pSF->isAutoMounted());
     1629        vrc = SSMR3PutBool(pSSM, !!pSF->i_isAutoMounted());
    16301630        AssertRC(vrc);
    16311631    }
    … …  
    66046604                AutoCaller sfCaller(pSF);
    66056605                AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
    6606                 sharedFolders[it->first] = SharedFolderData(pSF->getHostPath(),
    6607                                                             pSF->isWritable(),
    6608                                                             pSF->isAutoMounted());
     6606                sharedFolders[it->first] = SharedFolderData(pSF->i_getHostPath(),
     6607                                                            pSF->i_isWritable(),
     6608                                                            pSF->i_isAutoMounted());
    66096609            }
    66106610        }

  • trunk/src/VBox/Main/src-client/xpcom/module.cpp

    r50914 r50919  
    7676NS_DECL_CLASSINFO(RemoteUSBDevice)
    7777NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RemoteUSBDevice, IHostUSBDevice, IUSBDevice)
    78 NS_DECL_CLASSINFO(SharedFolder)
    79 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolder, ISharedFolder)
    8078NS_DECL_CLASSINFO(VRDEServerInfo)
    8179NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VRDEServerInfo, IVRDEServerInfo)

  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r50874 r50919  
    89888988        SharedFolder *pSF = *it;
    89898989        AutoCaller autoCaller(pSF);
    8990         if (pSF->getName() == aName)
     8990        if (pSF->i_getName() == aName)
    89918991        {
    89928992            aSharedFolder = pSF;
    … …  
    1075810758            AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
    1075910759            settings::SharedFolder sf;
    10760             sf.strName = pSF->getName();
    10761             sf.strHostPath = pSF->getHostPath();
    10762             sf.fWritable = !!pSF->isWritable();
    10763             sf.fAutoMount = !!pSF->isAutoMounted();
     10760            sf.strName = pSF->i_getName();
     10761            sf.strHostPath = pSF->i_getHostPath();
     10762            sf.fWritable = !!pSF->i_isWritable();
     10763            sf.fAutoMount = !!pSF->i_isAutoMounted();
    1076410764
    1076510765            data.llSharedFolders.push_back(sf);

  • trunk/src/VBox/Main/src-server/xpcom/server.cpp

    r50914 r50919  
    117117NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ProgressProxy, IProgress)
    118118
    119 NS_DECL_CLASSINFO(SharedFolder)
    120 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolder, ISharedFolder)
    121 
    122119#ifdef VBOX_WITH_USB
    123120
Note: See TracChangeset for help on using the changeset viewer.

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