Changeset 35755 in vbox

Timestamp:

Jan 28, 2011 11:36:42 AM (14 years ago)

Author:

vboxsync

Message:

Main: convert SharedFolder to utf-8

Location:

trunk/src/VBox/Main

Files:

• include/ConsoleImpl.h (modified) (3 diffs)
• include/MachineImpl.h (modified) (1 diff)
• include/SharedFolderImpl.h (modified) (4 diffs)
• src-all/SharedFolderImpl.cpp (modified) (19 diffs)
• src-client/ConsoleImpl.cpp (modified) (37 diffs)
• src-server/MachineImpl.cpp (modified) (2 diffs)

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -406 +406 @@
     {
     public:
-        SharedFolderData() {}
-        SharedFolderData(Bstr aHostPath, BOOL aWritable, BOOL aAutoMount)
-           : mHostPath(aHostPath)
-           , mWritable(aWritable)
-           , mAutoMount(aAutoMount) {}
+        SharedFolderData()
+        { }
+
+        SharedFolderData(const Utf8Str &aHostPath,
+                         bool aWritable,
+                         bool aAutoMount)
+           : m_strHostPath(aHostPath),
+             m_fWritable(aWritable),
+             m_fAutoMount(aAutoMount)
+        { }
+
+        // copy constructor
         SharedFolderData(const SharedFolderData& aThat)
-           : mHostPath(aThat.mHostPath)
-           , mWritable(aThat.mWritable)
-           , mAutoMount(aThat.mAutoMount) {}
-        Bstr mHostPath;
-        BOOL mWritable;
-        BOOL mAutoMount;
+           : m_strHostPath(aThat.m_strHostPath),
+             m_fWritable(aThat.m_fWritable),
+             m_fAutoMount(aThat.m_fAutoMount)
+        { }
+
+        Utf8Str m_strHostPath;
+        bool m_fWritable;
+        bool m_fAutoMount;
     };
-    typedef std::map <Bstr, ComObjPtr<SharedFolder> > SharedFolderMap;
-    typedef std::map <Bstr, SharedFolderData> SharedFolderDataMap;
+
+    typedef std::map<Utf8Str, ComObjPtr<SharedFolder> > SharedFolderMap;
+    typedef std::map<Utf8Str, SharedFolderData> SharedFolderDataMap;
 
 private:
@@ -449 +459 @@
     }
 
-    HRESULT findSharedFolder(CBSTR aName,
+    HRESULT findSharedFolder(const Utf8Str &strName,
                              ComObjPtr<SharedFolder> &aSharedFolder,
                              bool aSetError = false);
 
     HRESULT fetchSharedFolders(BOOL aGlobal);
-    bool findOtherSharedFolder(IN_BSTR aName,
+    bool findOtherSharedFolder(const Utf8Str &straName,
                                SharedFolderDataMap::const_iterator &aIt);
 
-    HRESULT createSharedFolder(CBSTR aName, SharedFolderData aData);
-    HRESULT removeSharedFolder(CBSTR aName);
+    HRESULT createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
+    HRESULT removeSharedFolder(const Utf8Str &strName);
 
     static DECLCALLBACK(int) configConstructor(PVM pVM, void *pvConsole);
@@ -631 +641 @@
     RemoteUSBDeviceList mRemoteUSBDevices;
 
-    SharedFolderMap mSharedFolders;
-    SharedFolderDataMap mMachineSharedFolders;
-    SharedFolderDataMap mGlobalSharedFolders;
+    SharedFolderDataMap m_mapGlobalSharedFolders;
+    SharedFolderDataMap m_mapMachineSharedFolders;
+    SharedFolderMap m_mapSharedFolders;             // the console instances
 
     /** The VM instance handle. */

trunk/src/VBox/Main/include/MachineImpl.h

@@ -726 +726 @@
     virtual HRESULT setMachineState(MachineState_T aMachineState);
 
-    HRESULT findSharedFolder(CBSTR aName,
+    HRESULT findSharedFolder(const Utf8Str &aName,
                              ComObjPtr<SharedFolder> &aSharedFolder,
                              bool aSetError = false);

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

@@ -30 +30 @@
 public:
 
-    struct Data
-    {
-        Data() {}
-
-        const Bstr name;
-        const Bstr hostPath;
-        BOOL       writable;
-        BOOL       autoMount;
-        Bstr       lastAccessError;
-    };
-
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SharedFolder, ISharedFolder)
 
@@ -57 +46 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init(Machine *aMachine, CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
+    HRESULT init(Machine *aMachine, const Utf8Str &aName, const Utf8Str &aHostPath, bool aWritable, bool aAutoMount);
     HRESULT initCopy(Machine *aMachine, SharedFolder *aThat);
-    HRESULT init(Console *aConsole, CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
-    HRESULT init(VirtualBox *aVirtualBox, CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
+    HRESULT init(Console *aConsole, const Utf8Str &aName, const Utf8Str &aHostPath, bool aWritable, bool aAutoMount);
+    HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath, bool aWritable, bool aAutoMount);
     void uninit();
 
@@ -74 +63 @@
     // (ensure there is a caller and a read lock before calling them!)
 
-    // public methods that don't need a lock (because access constant data)
-    // (ensure there is a caller added before calling them!)
+    /**
+     * Public internal method. Returns the shared folder's name. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str& getName() const;
 
-    const Bstr& getName() const { return m.name; }
-    const Bstr& getHostPath() const { return m.hostPath; }
-    BOOL isWritable() const { return m.writable; }
-    BOOL isAutoMounted() const { return m.autoMount; }
+    /**
+     * Public internal method. Returns the shared folder's host path. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str& getHostPath() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is writable. Needs caller and locking!
+     * @return
+     */
+    bool isWritable() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is auto-mounted. Needs caller and locking!
+     * @return
+     */
+    bool isAutoMounted() const;
 
 protected:
 
-    HRESULT protectedInit(VirtualBoxBase *aParent,
-                          CBSTR aName, CBSTR aHostPath,
-                          BOOL aWritable, BOOL aAutoMount);
+    HRESULT protectedInit(VirtualBoxBase *aParent, const Utf8Str &aName, const Utf8Str &aHostPath, bool aWritable, bool aAutoMount);
 private:
 
@@ -96 +99 @@
     VirtualBox * const      mVirtualBox;
 
-    Data m;
+    struct Data;            // opaque data struct, defined in SharedFolderImpl.cpp
+    Data *m;
 };
 

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

@@ -28 +28 @@
 #include <iprt/path.h>
 
+/////////////////////////////////////////////////////////////////////////////
+// SharedFolder::Data structure
+/////////////////////////////////////////////////////////////////////////////
+
+struct SharedFolder::Data
+{
+    Data()
+    : fWritable(false),
+      fAutoMount(false)
+    { }
+
+    const Utf8Str   strName;
+    const Utf8Str   strHostPath;
+    bool            fWritable;
+    bool            fAutoMount;
+    Utf8Str         strLastAccessError;
+};
+
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
@@ -37 +55 @@
       mVirtualBox(NULL)
 {
+    m = new Data;
 }
 
 SharedFolder::~SharedFolder()
 {
+    delete m;
+    m = NULL;
 }
 
@@ -68 +89 @@
  *  @return          COM result indicator
  */
-HRESULT SharedFolder::init (Machine *aMachine,
-                            CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
+HRESULT SharedFolder::init(Machine *aMachine,
+                           const Utf8Str &aName,
+                           const Utf8Str &aHostPath,
+                           bool aWritable,
+                           bool aAutoMount)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -96 +120 @@
  *  @return          COM result indicator
  */
-HRESULT SharedFolder::initCopy (Machine *aMachine, SharedFolder *aThat)
+HRESULT SharedFolder::initCopy(Machine *aMachine, SharedFolder *aThat)
 {
     ComAssertRet(aThat, E_INVALIDARG);
@@ -106 +130 @@
     unconst(mMachine) = aMachine;
 
-    HRESULT rc = protectedInit(aMachine, aThat->m.name.raw(),
-                               aThat->m.hostPath.raw(), aThat->m.writable,
-                               aThat->m.autoMount);
+    HRESULT rc = protectedInit(aMachine,
+                               aThat->m->strName,
+                               aThat->m->strHostPath,
+                               aThat->m->fWritable,
+                               aThat->m->fAutoMount);
 
     /* Confirm a successful initialization when it's the case */
@@ -118 +144 @@
 
 /**
- *  Initializes the shared folder object.
+ *  Initializes the shared folder object. This variant gets called when
+ *  the shared folder lives in the Console address space.
  *
  *  @param aConsole     Console parent object
@@ -128 +155 @@
  */
 HRESULT SharedFolder::init(Console *aConsole,
-                            CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
+                           const Utf8Str &aName,
+                           const Utf8Str &aHostPath,
+                           bool aWritable,
+                           bool aAutoMount)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -146 +176 @@
 
 /**
- *  Initializes the shared folder object.
+ *  Initializes the shared folder object. This variant gets called when
+ *  the shared folder lives in the VirtualBox (server) address space.
  *
  *  @param aVirtualBox  VirtualBox parent object
@@ -155 +186 @@
  *  @return          COM result indicator
  */
-HRESULT SharedFolder::init (VirtualBox *aVirtualBox,
-                            CBSTR aName, CBSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
+HRESULT SharedFolder::init(VirtualBox *aVirtualBox,
+                           const Utf8Str &aName,
+                           const Utf8Str &aHostPath,
+                           bool aWritable,
+                           bool aAutoMount)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -174 +208 @@
 
 /**
- *  Helper for init() methods.
+ *  Shared initialization code. Called from the other constructors.
  *
  *  @note
@@ -180 +214 @@
  */
 HRESULT SharedFolder::protectedInit(VirtualBoxBase *aParent,
-                                    CBSTR           aName,
-                                    CBSTR           aHostPath,
-                                    BOOL            aWritable,
-                                    BOOL            aAutoMount)
-{
-    LogFlowThisFunc(("aName={%ls}, aHostPath={%ls}, aWritable={%d}, aAutoMount={%d}\n",
-                      aName, aHostPath, aWritable, aAutoMount));
-
-    ComAssertRet(aParent && aName && aHostPath, E_INVALIDARG);
-
-    Utf8Str hostPath = Utf8Str (aHostPath);
+                                    const Utf8Str &aName,
+                                    const Utf8Str &aHostPath,
+                                    bool aWritable,
+                                    bool aAutoMount)
+{
+    LogFlowThisFunc(("aName={%s}, aHostPath={%s}, aWritable={%d}, aAutoMount={%d}\n",
+                      aName.c_str(), aHostPath.c_str(), aWritable, aAutoMount));
+
+    ComAssertRet(aParent && aName.isNotEmpty() && aHostPath.isNotEmpty(), E_INVALIDARG);
+
+    Utf8Str hostPath = aHostPath;
     size_t hostPathLen = hostPath.length();
 
@@ -229 +263 @@
     unconst(mParent) = aParent;
 
-    unconst(m.name) = aName;
-    unconst(m.hostPath) = hostPath;
-    m.writable = aWritable;
-    m.autoMount = aAutoMount;
+    unconst(m->strName) = aName;
+    unconst(m->strHostPath) = hostPath;
+    m->fWritable = aWritable;
+    m->fAutoMount = aAutoMount;
 
     return S_OK;
@@ -268 +302 @@
 
     /* mName is constant during life time, no need to lock */
-    m.name.cloneTo(aName);
+    m->strName.cloneTo(aName);
 
     return S_OK;
@@ -281 +315 @@
 
     /* mHostPath is constant during life time, no need to lock */
-    m.hostPath.cloneTo(aHostPath);
+    m->strHostPath.cloneTo(aHostPath);
 
     return S_OK;
@@ -296 +330 @@
 
     /* check whether the host path exists */
-    Utf8Str hostPath = Utf8Str(m.hostPath);
+    Utf8Str hostPath = m->strHostPath;
     char hostPathFull[RTPATH_MAX];
     int vrc = RTPathExists(hostPath.c_str()) ? RTPathReal(hostPath.c_str(),
@@ -310 +344 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m.lastAccessError = BstrFmt (
-        tr ("'%s' is not accessible (%Rrc)"), hostPath.c_str(), vrc);
-
-    LogWarningThisFunc(("m.lastAccessError=\"%ls\"\n", m.lastAccessError.raw()));
+    m->strLastAccessError = Utf8StrFmt(tr("'%s' is not accessible (%Rrc)"),
+                                       m->strHostPath.c_str(),
+                                       vrc);
+
+    LogWarningThisFunc(("m.lastAccessError=\"%s\"\n", m->strLastAccessError.c_str()));
 
     *aAccessible = FALSE;
@@ -328 +363 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aWritable = m.writable;
+    *aWritable = !!m->fWritable;
 
     return S_OK;
@@ -342 +377 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aAutoMount = m.autoMount;
+    *aAutoMount = !!m->fAutoMount;
 
     return S_OK;
@@ -356 +391 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m.lastAccessError.cloneTo(aLastAccessError);
-
-    return S_OK;
+    m->strLastAccessError.cloneTo(aLastAccessError);
+
+    return S_OK;
+}
+
+const Utf8Str& SharedFolder::getName() const
+{
+    return m->strName;
+}
+
+const Utf8Str& SharedFolder::getHostPath() const
+{
+    return m->strHostPath;
+}
+
+bool SharedFolder::isWritable() const
+{
+    return m->fWritable;
+}
+
+bool SharedFolder::isAutoMounted() const
+{
+    return m->fAutoMount;
 }
 

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

@@ -604 +604 @@
     }
 
-    mGlobalSharedFolders.clear();
-    mMachineSharedFolders.clear();
-
-    mSharedFolders.clear();
+    m_mapGlobalSharedFolders.clear();
+    m_mapMachineSharedFolders.clear();
+    m_mapSharedFolders.clear();             // console instances
+
     mRemoteUSBDevices.clear();
     mUSBDevices.clear();
@@ -1261 +1261 @@
     AutoReadLock alock(that COMMA_LOCKVAL_SRC_POS);
 
-    int vrc = SSMR3PutU32(pSSM, (uint32_t)that->mSharedFolders.size());
+    int vrc = SSMR3PutU32(pSSM, (uint32_t)that->m_mapSharedFolders.size());
     AssertRC(vrc);
 
-    for (SharedFolderMap::const_iterator it = that->mSharedFolders.begin();
-         it != that->mSharedFolders.end();
+    for (SharedFolderMap::const_iterator it = that->m_mapSharedFolders.begin();
+         it != that->m_mapSharedFolders.end();
          ++ it)
     {
-        ComObjPtr<SharedFolder> pSharedFolder = (*it).second;
-        // don't lock the folder because methods we access are const
-
-        Utf8Str name = pSharedFolder->getName();
+        SharedFolder *pSF = (*it).second;
+        AutoCaller sfCaller(pSF);
+        AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
+
+        Utf8Str name = pSF->getName();
         vrc = SSMR3PutU32(pSSM, (uint32_t)name.length() + 1 /* term. 0 */);
         AssertRC(vrc);
@@ -1277 +1278 @@
         AssertRC(vrc);
 
-        Utf8Str hostPath = pSharedFolder->getHostPath();
+        Utf8Str hostPath = pSF->getHostPath();
         vrc = SSMR3PutU32(pSSM, (uint32_t)hostPath.length() + 1 /* term. 0 */);
         AssertRC(vrc);
@@ -1283 +1284 @@
         AssertRC(vrc);
 
-        vrc = SSMR3PutBool(pSSM, !!pSharedFolder->isWritable());
+        vrc = SSMR3PutBool(pSSM, !!pSF->isWritable());
         AssertRC(vrc);
 
-        vrc = SSMR3PutBool(pSSM, !!pSharedFolder->isAutoMounted());
+        vrc = SSMR3PutBool(pSSM, !!pSF->isAutoMounted());
         AssertRC(vrc);
     }
@@ -1339 +1340 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    AssertReturn(mSharedFolders.size() == 0, VERR_INTERNAL_ERROR);
+    AssertReturn(m_mapSharedFolders.size() == 0, VERR_INTERNAL_ERROR);
 
     uint32_t size = 0;
@@ -1347 +1348 @@
     for (uint32_t i = 0; i < size; ++ i)
     {
-        Bstr name;
-        Bstr hostPath;
+        Utf8Str strName;
+        Utf8Str strHostPath;
         bool writable = true;
         bool autoMount = false;
@@ -1360 +1361 @@
         vrc = SSMR3GetStrZ(pSSM, buf, szBuf);
         AssertRC(vrc);
-        name = buf;
+        strName = buf;
         delete[] buf;
 
@@ -1368 +1369 @@
         vrc = SSMR3GetStrZ(pSSM, buf, szBuf);
         AssertRC(vrc);
-        hostPath = buf;
+        strHostPath = buf;
         delete[] buf;
 
@@ -1379 +1380 @@
         ComObjPtr<SharedFolder> pSharedFolder;
         pSharedFolder.createObject();
-        HRESULT rc = pSharedFolder->init(this, name.raw(), hostPath.raw(),
-                                         writable, autoMount);
+        HRESULT rc = pSharedFolder->init(this,
+                                         strName,
+                                         strHostPath,
+                                         writable,
+                                         autoMount);
         AssertComRCReturn(rc, VERR_INTERNAL_ERROR);
 
-        mSharedFolders.insert(std::make_pair(name, pSharedFolder));
+        m_mapSharedFolders.insert(std::make_pair(strName, pSharedFolder));
     }
 
@@ -1700 +1704 @@
     if (FAILED(rc)) return rc;
 
-    SafeIfaceArray<ISharedFolder> sf(mSharedFolders);
+    SafeIfaceArray<ISharedFolder> sf(m_mapSharedFolders);
     sf.detachTo(ComSafeArrayOutArg(aSharedFolders));
 
@@ -2850 +2854 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
+    Utf8Str strName(aName);
+    Utf8Str strHostPath(aHostPath);
+
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2867 +2874 @@
 
     ComObjPtr<SharedFolder> pSharedFolder;
-    HRESULT rc = findSharedFolder(aName, pSharedFolder, false /* aSetError */);
+    HRESULT rc = findSharedFolder(strName, pSharedFolder, false /* aSetError */);
     if (SUCCEEDED(rc))
         return setError(VBOX_E_FILE_ERROR,
-            tr("Shared folder named '%ls' already exists"),
-            aName);
+            tr("Shared folder named '%s' already exists"),
+            strName.c_str());
 
     pSharedFolder.createObject();
-    rc = pSharedFolder->init(this, aName, aHostPath, aWritable, aAutoMount);
+    rc = pSharedFolder->init(this, strName, strHostPath, aWritable, aAutoMount);
     if (FAILED(rc)) return rc;
 
@@ -2902 +2909 @@
     }
 
-    mSharedFolders.insert(std::make_pair(aName, pSharedFolder));
+    m_mapSharedFolders.insert(std::make_pair(aName, pSharedFolder));
 
     /* notify console callbacks after the folder is added to the list */
@@ -2916 +2923 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    Utf8Str strName(aName);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2950 +2959 @@
 
         /* first, remove the given folder */
-        rc = removeSharedFolder(aName);
+        rc = removeSharedFolder(strName);
         if (FAILED(rc)) return rc;
 
         /* first, remove the machine or the global folder if there is any */
         SharedFolderDataMap::const_iterator it;
-        if (findOtherSharedFolder(aName, it))
-        {
-            rc = createSharedFolder(aName, it->second);
+        if (findOtherSharedFolder(strName, it))
+        {
+            rc = createSharedFolder(strName, it->second);
             /* don't check rc here because we need to remove the console
              * folder from the collection even on failure */
@@ -2963 +2972 @@
     }
 
-    mSharedFolders.erase(aName);
+    m_mapSharedFolders.erase(strName);
 
     /* notify console callbacks after the folder is removed to the list */
@@ -5527 +5536 @@
         SharedFolderDataMap sharedFolders;
         {
+            // @todo umoeller
+
             /* first, insert global folders */
-            for (SharedFolderDataMap::const_iterator it = mGlobalSharedFolders.begin();
-                 it != mGlobalSharedFolders.end(); ++ it)
-                sharedFolders[it->first] = it->second;
+            for (SharedFolderDataMap::const_iterator it = m_mapGlobalSharedFolders.begin();
+                 it != m_mapGlobalSharedFolders.end();
+                 ++it)
+            {
+                const SharedFolderData &d = it->second;
+                sharedFolders[it->first] = d;
+            }
 
             /* second, insert machine folders */
-            for (SharedFolderDataMap::const_iterator it = mMachineSharedFolders.begin();
-                 it != mMachineSharedFolders.end(); ++ it)
-                sharedFolders[it->first] = it->second;
+            for (SharedFolderDataMap::const_iterator it = m_mapMachineSharedFolders.begin();
+                 it != m_mapMachineSharedFolders.end();
+                 ++it)
+            {
+                const SharedFolderData &d = it->second;
+                sharedFolders[it->first] = d;
+            }
 
             /* third, insert console folders */
-            for (SharedFolderMap::const_iterator it = mSharedFolders.begin();
-                 it != mSharedFolders.end(); ++ it)
-                sharedFolders[it->first] = SharedFolderData(it->second->getHostPath(),
-                                                            it->second->isWritable(),
-                                                            it->second->isAutoMounted());
+            for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin();
+                 it != m_mapSharedFolders.end();
+                 ++it)
+            {
+                SharedFolder *pSF = it->second;
+                AutoCaller sfCaller(pSF);
+                AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
+                sharedFolders[it->first] = SharedFolderData(pSF->getHostPath(),
+                                                            pSF->isWritable(),
+                                                            pSF->isAutoMounted());
+            }
         }
 
@@ -6135 +6160 @@
  * @note The caller must lock this object for writing.
  */
-HRESULT Console::findSharedFolder(CBSTR aName,
+HRESULT Console::findSharedFolder(const Utf8Str &strName,
                                   ComObjPtr<SharedFolder> &aSharedFolder,
                                   bool aSetError /* = false */)
@@ -6142 +6167 @@
     AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
 
-    SharedFolderMap::const_iterator it = mSharedFolders.find(aName);
-    if (it != mSharedFolders.end())
+    SharedFolderMap::const_iterator it = m_mapSharedFolders.find(strName);
+    if (it != m_mapSharedFolders.end())
     {
         aSharedFolder = it->second;
@@ -6151 +6176 @@
     if (aSetError)
         setError(VBOX_E_FILE_ERROR,
-            tr("Could not find a shared folder named '%ls'."),
-            aName);
+            tr("Could not find a shared folder named '%s'."),
+            strName.c_str());
 
     return VBOX_E_FILE_ERROR;
@@ -6188 +6213 @@
         SharedFolderDataMap oldFolders;
         if (online)
-            oldFolders = mMachineSharedFolders;
-
-        mMachineSharedFolders.clear();
+            oldFolders = m_mapMachineSharedFolders;
+
+        m_mapMachineSharedFolders.clear();
 
         SafeIfaceArray<ISharedFolder> folders;
@@ -6200 +6225 @@
             ComPtr<ISharedFolder> pSharedFolder = folders[i];
 
-            Bstr name;
-            Bstr hostPath;
+            Bstr bstrName;
+            Bstr bstrHostPath;
             BOOL writable;
             BOOL autoMount;
 
-            rc = pSharedFolder->COMGETTER(Name)(name.asOutParam());
+            rc = pSharedFolder->COMGETTER(Name)(bstrName.asOutParam());
             if (FAILED(rc)) break;
-            rc = pSharedFolder->COMGETTER(HostPath)(hostPath.asOutParam());
+            Utf8Str strName(bstrName);
+
+            rc = pSharedFolder->COMGETTER(HostPath)(bstrHostPath.asOutParam());
             if (FAILED(rc)) break;
+            Utf8Str strHostPath(bstrHostPath);
+
             rc = pSharedFolder->COMGETTER(Writable)(&writable);
             if (FAILED(rc)) break;
+
             rc = pSharedFolder->COMGETTER(AutoMount)(&autoMount);
             if (FAILED(rc)) break;
 
-            mMachineSharedFolders.insert(std::make_pair(name, SharedFolderData(hostPath, writable, autoMount)));
+            m_mapMachineSharedFolders.insert(std::make_pair(strName,
+                                                            SharedFolderData(strHostPath, writable, autoMount)));
 
             /* send changes to HGCM if the VM is running */
-            /// @todo report errors as runtime warnings through VMSetError
+            /// @todo umoeller report errors as runtime warnings through VMSetError
             if (online)
             {
-                SharedFolderDataMap::iterator it = oldFolders.find(name);
-                if (it == oldFolders.end() || it->second.mHostPath != hostPath)
+                SharedFolderDataMap::iterator it = oldFolders.find(strName);
+                if (    it == oldFolders.end()
+                     || it->second.m_strHostPath != strHostPath)
                 {
                     /* a new machine folder is added or
                      * the existing machine folder is changed */
-                    if (mSharedFolders.find(name) != mSharedFolders.end())
+                    if (m_mapSharedFolders.find(strName) != m_mapSharedFolders.end())
                         ; /* the console folder exists, nothing to do */
                     else
@@ -6231 +6263 @@
                         /* remove the old machine folder (when changed)
                          * or the global folder if any (when new) */
-                        if (it != oldFolders.end() ||
-                            mGlobalSharedFolders.find(name) !=
-                                mGlobalSharedFolders.end())
-                            rc = removeSharedFolder(name.raw());
+                        if (    it != oldFolders.end()
+                             || m_mapGlobalSharedFolders.find(strName) != m_mapGlobalSharedFolders.end()
+                           )
+                            rc = removeSharedFolder(strName);
                         /* create the new machine folder */
-                        rc = createSharedFolder(name.raw(),
-                                                SharedFolderData(hostPath,
+                        rc = createSharedFolder(strName,
+                                                SharedFolderData(strHostPath,
                                                                  writable,
                                                                  autoMount));
@@ -6259 +6291 @@
                  it != oldFolders.end(); ++ it)
             {
-                if (mSharedFolders.find(it->first) != mSharedFolders.end())
+                if (m_mapSharedFolders.find(it->first) != m_mapSharedFolders.end())
                     ; /* the console folder exists, nothing to do */
                 else
                 {
                     /* remove the outdated machine folder */
-                    rc = removeSharedFolder(it->first.raw());
+                    rc = removeSharedFolder(it->first);
                     /* create the global folder if there is any */
                     SharedFolderDataMap::const_iterator git =
-                        mGlobalSharedFolders.find(it->first);
-                    if (git != mGlobalSharedFolders.end())
-                        rc = createSharedFolder(git->first.raw(), git->second);
+                        m_mapGlobalSharedFolders.find(it->first);
+                    if (git != m_mapGlobalSharedFolders.end())
+                        rc = createSharedFolder(git->first, git->second);
                 }
             }
@@ -6290 +6322 @@
  * @note The caller must lock this object for reading.
  */
-bool Console::findOtherSharedFolder(IN_BSTR aName,
+bool Console::findOtherSharedFolder(const Utf8Str &strName,
                                     SharedFolderDataMap::const_iterator &aIt)
 {
@@ -6297 +6329 @@
 
     /* first, search machine folders */
-    aIt = mMachineSharedFolders.find(aName);
-    if (aIt != mMachineSharedFolders.end())
+    aIt = m_mapMachineSharedFolders.find(strName);
+    if (aIt != m_mapMachineSharedFolders.end())
         return true;
 
     /* second, search machine folders */
-    aIt = mGlobalSharedFolders.find(aName);
-    if (aIt != mGlobalSharedFolders.end())
+    aIt = m_mapGlobalSharedFolders.find(strName);
+    if (aIt != m_mapGlobalSharedFolders.end())
         return true;
 
@@ -6318 +6350 @@
  * @note Doesn't lock anything.
  */
-HRESULT Console::createSharedFolder(CBSTR aName, SharedFolderData aData)
-{
-    ComAssertRet(aName && *aName, E_FAIL);
-    ComAssertRet(!aData.mHostPath.isEmpty(), E_FAIL);
+HRESULT Console::createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData)
+{
+    ComAssertRet(strName.isNotEmpty(), E_FAIL);
+    ComAssertRet(aData.m_strHostPath.isNotEmpty(), E_FAIL);
 
     /* sanity checks */
@@ -6331 +6363 @@
     size_t cbString;
 
-    Log(("Adding shared folder '%ls' -> '%ls'\n", aName, aData.mHostPath.raw()));
-
-    cbString = (RTUtf16Len(aData.mHostPath.raw()) + 1) * sizeof(RTUTF16);
+    Log(("Adding shared folder '%s' -> '%s'\n", strName.c_str(), aData.m_strHostPath.c_str()));
+
+    Bstr bstrName(strName);
+    Bstr bstrHostPath(aData.m_strHostPath);
+
+    cbString = (bstrHostPath.length() + 1) * sizeof(RTUTF16);
     if (cbString >= UINT16_MAX)
         return setError(E_INVALIDARG, tr("The name is too long"));
-    pFolderName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
+    pFolderName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
     Assert(pFolderName);
-    memcpy(pFolderName->String.ucs2, aData.mHostPath.raw(), cbString);
+    memcpy(pFolderName->String.ucs2, bstrHostPath.raw(), cbString);
 
     pFolderName->u16Size   = (uint16_t)cbString;
@@ -6347 +6382 @@
     parms[0].u.pointer.size = sizeof(SHFLSTRING) + (uint16_t)cbString;
 
-    cbString = (RTUtf16Len(aName) + 1) * sizeof(RTUTF16);
+    cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
     if (cbString >= UINT16_MAX)
     {
@@ -6353 +6388 @@
         return setError(E_INVALIDARG, tr("The host path is too long"));
     }
-    pMapName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
+    pMapName = (SHFLSTRING*)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
     Assert(pMapName);
-    memcpy(pMapName->String.ucs2, aName, cbString);
+    memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
 
     pMapName->u16Size   = (uint16_t)cbString;
@@ -6365 +6400 @@
 
     parms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
-    parms[2].u.uint32 = aData.mWritable;
+    parms[2].u.uint32 = aData.m_fWritable;
 
     /*
@@ -6374 +6409 @@
      */
     parms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
-    parms[3].u.uint32 = aData.mAutoMount;
+    parms[3].u.uint32 = aData.m_fAutoMount;
 
     int vrc = m_pVMMDev->hgcmHostCall("VBoxSharedFolders",
@@ -6384 +6419 @@
     if (RT_FAILURE(vrc))
         return setError(E_FAIL,
-            tr("Could not create a shared folder '%ls' mapped to '%ls' (%Rrc)"),
-            aName, aData.mHostPath.raw(), vrc);
+            tr("Could not create a shared folder '%s' mapped to '%s' (%Rrc)"),
+            strName.c_str(), aData.m_strHostPath.c_str(), vrc);
 
     return S_OK;
@@ -6398 +6433 @@
  * @note Doesn't lock anything.
  */
-HRESULT Console::removeSharedFolder(CBSTR aName)
-{
-    ComAssertRet(aName && *aName, E_FAIL);
+HRESULT Console::removeSharedFolder(const Utf8Str &strName)
+{
+    ComAssertRet(strName.isNotEmpty(), E_FAIL);
 
     /* sanity checks */
@@ -6410 +6445 @@
     size_t cbString;
 
-    Log(("Removing shared folder '%ls'\n", aName));
-
-    cbString = (RTUtf16Len(aName) + 1) * sizeof(RTUTF16);
+    Log(("Removing shared folder '%s'\n", strName.c_str()));
+
+    Bstr bstrName(strName);
+    cbString = (bstrName.length() + 1) * sizeof(RTUTF16);
     if (cbString >= UINT16_MAX)
         return setError(E_INVALIDARG, tr("The name is too long"));
     pMapName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
     Assert(pMapName);
-    memcpy(pMapName->String.ucs2, aName, cbString);
+    memcpy(pMapName->String.ucs2, bstrName.raw(), cbString);
 
     pMapName->u16Size   = (uint16_t)cbString;
@@ -6432 +6468 @@
     if (RT_FAILURE(vrc))
         return setError(E_FAIL,
-                        tr("Could not remove the shared folder '%ls' (%Rrc)"),
-                        aName, vrc);
+                        tr("Could not remove the shared folder '%s' (%Rrc)"),
+                        strName.c_str(), vrc);
 
     return S_OK;
@@ -7793 +7829 @@
                          ++it)
                     {
-                        rc = pConsole->createSharedFolder((*it).first.raw(),
-                                                         (*it).second);
+                        const SharedFolderData &d = it->second;
+                        rc = pConsole->createSharedFolder(it->first,
+                                                          d);
                         if (FAILED(rc)) break;
                     }

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

@@ -7032 +7032 @@
  *      must be called from under the object's lock!
  */
-HRESULT Machine::findSharedFolder(CBSTR aName,
+HRESULT Machine::findSharedFolder(const Utf8Str &aName,
                                   ComObjPtr<SharedFolder> &aSharedFolder,
                                   bool aSetError /* = false */)
 {
-    bool found = false;
+    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
     for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
-        !found && it != mHWData->mSharedFolders.end();
+        it != mHWData->mSharedFolders.end();
         ++it)
     {
-        AutoWriteLock alock(*it COMMA_LOCKVAL_SRC_POS);
-        found = (*it)->getName() == aName;
-        if (found)
-            aSharedFolder = *it;
-    }
-
-    HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
-
-    if (aSetError && !found)
-        setError(rc, tr("Could not find a shared folder named '%ls'"), aName);
+        SharedFolder *pSF = *it;
+        AutoCaller autoCaller(pSF);
+        if (pSF->getName() == aName)
+        {
+            aSharedFolder = pSF;
+            rc = S_OK;
+            break;
+        }
+    }
+
+    if (aSetError && FAILED(rc))
+        setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
 
     return rc;
@@ -8502 +8504 @@
             ++it)
         {
-            ComObjPtr<SharedFolder> pFolder = *it;
+            SharedFolder *pSF = *it;
+            AutoCaller sfCaller(pSF);
+            AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
             settings::SharedFolder sf;
-            sf.strName = pFolder->getName();
-            sf.strHostPath = pFolder->getHostPath();
-            sf.fWritable = !!pFolder->isWritable();
-            sf.fAutoMount = !!pFolder->isAutoMounted();
+            sf.strName = pSF->getName();
+            sf.strHostPath = pSF->getHostPath();
+            sf.fWritable = !!pSF->isWritable();
+            sf.fAutoMount = !!pSF->isAutoMounted();
 
             data.llSharedFolders.push_back(sf);