Changeset 4040 in vbox for trunk/src/VBox/Main

Timestamp:

Aug 6, 2007 12:40:31 PM (18 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

23475

Message:

Main: Converted SharedFolder class to the new locking scheme.

Location:

trunk/src/VBox/Main

Files:

• SharedFolderImpl.cpp (modified) (12 diffs)
• include/SharedFolderImpl.h (modified) (5 diffs)

trunk/src/VBox/Main/SharedFolderImpl.cpp

@@ -34 +34 @@
 /////////////////////////////////////////////////////////////////////////////
 
+SharedFolder::SharedFolder()
+    : mParent (NULL)
+{
+}
+
+SharedFolder::~SharedFolder()
+{
+}
+
 HRESULT SharedFolder::FinalConstruct()
 {
@@ -59 +68 @@
                             const BSTR aName, const BSTR aHostPath)
 {
-    AutoLock alock (this);
-    ComAssertRet (!isReady(), E_UNEXPECTED);
-
-    mMachine = aMachine;
-    return protectedInit (aMachine, aName, aHostPath);
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan (this);
+    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
+
+    unconst (mMachine) = aMachine;
+
+    HRESULT rc = protectedInit (aMachine, aName, aHostPath);
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED (rc))
+        autoInitSpan.setSucceeded();
+
+    return rc;
 }
 
@@ -80 +97 @@
     ComAssertRet (aThat, E_INVALIDARG);
 
-    AutoLock alock (this);
-    ComAssertRet (!isReady(), E_UNEXPECTED);
-
-    mMachine = aMachine;
-    return protectedInit (aMachine, aThat->mName, aThat->mHostPath);
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan (this);
+    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
+
+    unconst (mMachine) = aMachine;
+
+    HRESULT rc = protectedInit (aMachine, aThat->mData.mName,
+                                aThat->mData.mHostPath);
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED (rc))
+        autoInitSpan.setSucceeded();
+
+    return rc;
 }
 
@@ -99 +125 @@
                             const BSTR aName, const BSTR aHostPath)
 {
-    AutoLock alock (this);
-    ComAssertRet (!isReady(), E_UNEXPECTED);
-
-    mConsole = aConsole;
-    return protectedInit (aConsole, aName, aHostPath);
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan (this);
+    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
+
+    unconst (mConsole) = aConsole;
+
+    HRESULT rc = protectedInit (aConsole, aName, aHostPath);
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED (rc))
+        autoInitSpan.setSucceeded();
+
+    return rc;
 }
 
@@ -118 +152 @@
                             const BSTR aName, const BSTR aHostPath)
 {
-    AutoLock alock (this);
-    ComAssertRet (!isReady(), E_UNEXPECTED);
-
-    mVirtualBox = aVirtualBox;
-    return protectedInit (aVirtualBox, aName, aHostPath);
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan (this);
+    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
+
+    unconst (mVirtualBox) = aVirtualBox;
+
+    HRESULT rc = protectedInit (aVirtualBox, aName, aHostPath);
+
+    /* Confirm a successful initialization when it's the case */
+    if (SUCCEEDED (rc))
+        autoInitSpan.setSucceeded();
+
+    return rc;
 }
 
@@ -131 +173 @@
  *      Must be called from under the object's lock!
  */
-HRESULT SharedFolder::protectedInit (VirtualBoxBaseWithChildren *aParent,
+HRESULT SharedFolder::protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
                                      const BSTR aName, const BSTR aHostPath)
 {
@@ -171 +213 @@
             tr ("Shared folder path '%s' is not absolute"), hostPath.raw());
 
-    mParent = aParent;
-    unconst (mName) = aName;
-    unconst (mHostPath) = hostPath;
-
+    unconst (mParent) = aParent;
+
+    /* register with parent */
     mParent->addDependentChild (this);
 
-    setReady (true);
+    unconst (mData.mName) = aName;
+    unconst (mData.mHostPath) = hostPath;
+
     return S_OK;
 }
@@ -187 +230 @@
 void SharedFolder::uninit()
 {
-    LogFlowMember (("SharedFolder::uninit()\n"));
-
-    AutoLock alock (this);
-
-    LogFlowMember (("SharedFolder::uninit(): isReady=%d\n", isReady()));
-    if (!isReady())
+    LogFlowThisFunc (("\n"));
+
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan (this);
+    if (autoUninitSpan.uninitDone())
         return;
 
-    setReady (false);
-
-    alock.leave();
-    mParent->removeDependentChild (this);
+    if (mParent)
+        mParent->removeDependentChild (this);
+
+    unconst (mParent) = NULL;
+
+    unconst (mMachine).setNull();
+    unconst (mConsole).setNull();
+    unconst (mVirtualBox).setNull();
 }
 
@@ -209 +255 @@
         return E_POINTER;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    mName.cloneTo (aName);
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    /* mName is constant during life time, no need to lock */
+    mData.mName.cloneTo (aName);
+
     return S_OK;
 }
@@ -221 +269 @@
         return E_POINTER;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    mHostPath.cloneTo (aHostPath);
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    /* mHostPath is constant during life time, no need to lock */
+    mData.mHostPath.cloneTo (aHostPath);
+
     return S_OK;
 }
@@ -233 +283 @@
         return E_POINTER;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    // check whether the host path exists
-    Utf8Str hostPath = Utf8Str (mHostPath);
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    /* mName and mHostPath are constant during life time, no need to lock */
+
+    /* check whether the host path exists */
+    Utf8Str hostPath = Utf8Str (mData.mHostPath);
     char hostPathFull [RTPATH_MAX];
-    int vrc = RTPathExists(hostPath) ? RTPathReal (hostPath, hostPathFull, sizeof (hostPathFull))
+    int vrc = RTPathExists(hostPath) ? RTPathReal (hostPath, hostPathFull,
+                                                   sizeof (hostPathFull))
                                      : VERR_PATH_NOT_FOUND;
     if (VBOX_SUCCESS (vrc))
@@ -252 +305 @@
             tr ("Invalid shared folder path: '%s' (%Vrc)"), hostPath.raw(), vrc);
 
-    Log (("SharedFolder::COMGETTER(Accessible): WARNING: '%s' "
-          "is not accessible (%Vrc)\n", hostPath.raw(), vrc));
+    LogWarningThisFunc (("'%s' is not accessible (%Vrc)\n", hostPath.raw(), vrc));
 
     *aAccessible = FALSE;

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

@@ -32 +32 @@
 
 class ATL_NO_VTABLE SharedFolder :
+    public VirtualBoxBaseNEXT,
     public VirtualBoxSupportErrorInfoImpl <SharedFolder, ISharedFolder>,
     public VirtualBoxSupportTranslation <SharedFolder>,
-    public VirtualBoxBase,
     public ISharedFolder
 {
 public:
 
-    // to satisfy the ComObjPtr template (we have const members)
-    SharedFolder() {}
+    struct Data
+    {
+        Data() {}
+
+        const Bstr mName;
+        const Bstr mHostPath;
+    };
+
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (SharedFolder)
 
     DECLARE_NOT_AGGREGATABLE(SharedFolder)
@@ -52 +59 @@
 
     NS_DECL_ISUPPORTS
+
+    DECLARE_EMPTY_CTOR_DTOR (SharedFolder)
 
     HRESULT FinalConstruct();
@@ -69 +78 @@
 
     // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
 
-    const Bstr &name() const { return mName; }
-    const Bstr &hostPath() const { return mHostPath; }
+    // public methods that don't need a lock (because access constant data)
+    // (ensure there is a caller added before calling them!)
+
+    const Bstr &name() const { return mData.mName; }
+    const Bstr &hostPath() const { return mData.mHostPath; }
 
     // for VirtualBoxSupportErrorInfoImpl
@@ -78 +91 @@
 protected:
 
-    HRESULT protectedInit (VirtualBoxBaseWithChildren *aParent,
+    HRESULT protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
                            const BSTR aName, const BSTR aHostPath);
 
 private:
 
-    VirtualBoxBaseWithChildren *mParent;
+    VirtualBoxBaseWithChildrenNEXT *const mParent;
 
     /* weak parents (only one of them is not null) */
-    ComObjPtr <Machine, ComWeakRef> mMachine;
-    ComObjPtr <Console, ComWeakRef> mConsole;
-    ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
+    const ComObjPtr <Machine, ComWeakRef> mMachine;
+    const ComObjPtr <Console, ComWeakRef> mConsole;
+    const ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
 
-    const Bstr mName;
-    const Bstr mHostPath;
+    Data mData;
 };
 
@@ -117 +129 @@
         if (!found)
             return setError (E_INVALIDARG, SharedFolderCollection::tr (
-                "Shared folder named '%ls' could not be found"), aName);
+                "Could not find the shared folder '%ls'"), aName);
 
         return found.queryInterfaceTo (aSharedFolder);