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

Timestamp:

May 30, 2007 4:59:36 PM (18 years ago)

Author:

vboxsync

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

21620

Message:

Main: Preparations for async USB handling.

Location:

trunk/src/VBox/Main

Files:

• HostImpl.cpp (modified) (12 diffs)
• HostUSBDeviceImpl.cpp (modified) (29 diffs)
• include/HostUSBDeviceImpl.h (modified) (6 diffs)

trunk/src/VBox/Main/HostImpl.cpp

@@ -1228 +1228 @@
             id.toString().raw());
 
+    AutoLock devLock (device);
+
     if (device->state() == USBDeviceState_USBDeviceNotSupported)
         return setError (E_INVALIDARG,
@@ -1274 +1276 @@
 HRESULT Host::releaseUSBDevice (SessionMachine *aMachine, INPTR GUIDPARAM aId)
 {
+    LogFlowThisFunc (("aMachine=%p, aId={%Vuuid}\n", aMachine, Guid (aId).raw()));
+
     AutoLock lock (this);
     CHECK_READY();
@@ -1287 +1291 @@
 
     ComAssertRet (!!device, E_FAIL);
+    
+    AutoLock devLock (device);
+
     ComAssertRet (device->machine() == aMachine, E_FAIL);
 
-    // reset the device and apply filters
+    /* reset the device and apply filters */
     int vrc = device->reset();
     ComAssertRCRet (vrc, E_FAIL);
@@ -1324 +1331 @@
     {
         ComObjPtr <HostUSBDevice> device = *it;
+
+        AutoLock devLock (device);
+
+/// @todo remove
+#if 0
         if (device->isIgnored())
             continue;
+#endif
 
         if (device->state() == USBDeviceState_USBDeviceBusy ||
@@ -1373 +1386 @@
     {
         ComObjPtr <HostUSBDevice> device = *it;
+
+        AutoLock devLock (device);
+
         if (device->machine() == aMachine)
         {
@@ -1649 +1665 @@
                                   SessionMachine *aMachine /* = NULL  */)
 {
-    LogFlowMember (("Host::applyAllUSBFilters: \n"));
+    LogFlowThisFunc (("\n"));
+
+    AssertReturn (isLockedOnCurrentThread(), E_FAIL);
+
+    AutoLock devLock (aDevice);
 
     /* ignore unsupported devices */
@@ -1687 +1707 @@
         if (aDevice->state() == USBDeviceState_USBDeviceCaptured)
         {
-            // inform the machine's process about the auto-capture
+            /* inform the VM process about the auto-capture */
             ComPtr <IUSBDevice> d;
             aDevice.queryInterfaceTo (d.asOutParam());
+            
+            /* the VM process will query the object, so leave the lock */
+            devLock.leave();
+
             HRESULT rc = machines [i]->onUSBDeviceAttach (d);
             if (SUCCEEDED(rc))
                 return rc;
 
-            // the machine rejected it, continue applying filters.
+            devLock.enter();
+
+            /* the machine rejected it, continue applying filters. */
             aDevice->reset();
         }
@@ -1731 +1757 @@
     LogFlowThisFunc (("\n"));
 
-    AssertReturn (aMachine, (void) 0);
-    AssertReturn (aDevice->state() != USBDeviceState_USBDeviceUnavailable, (void) 0);
+    AssertReturnVoid (isLockedOnCurrentThread());
+    AssertReturnVoid (aDevice->isLockedOnCurrentThread());
+
+    AssertReturnVoid (aMachine);
+    AssertReturnVoid (aDevice->state() != USBDeviceState_USBDeviceUnavailable);
 
     /* We're going to use aMachine which is not our child/parent, add a caller */
@@ -1767 +1796 @@
 void Host::onUSBDeviceAttached (HostUSBDevice *aDevice)
 {
-    LogFlowMember (("Host::onUSBDeviceAttached: aDevice=%p\n", aDevice));
+    LogFlowThisFunc (("aDevice=%p\n", aDevice));
+
+    AssertReturnVoid (aDevice);
+
     /// @todo (dmik) check locks
     AutoLock alock (this);
 
-    // add to the collecion
+    AutoLock devLock (aDevice);
+
+    /* add to the collecion */
     mUSBDevices.push_back (aDevice);
 
-    // apply all filters (no need to lock the device, nobody can access it yet)
-    ComObjPtr <HostUSBDevice> DevPtr(aDevice);
-    HRESULT rc = applyAllUSBFilters (DevPtr);
+    /* apply all filters */
+    ComObjPtr <HostUSBDevice> device (aDevice);
+    HRESULT rc = applyAllUSBFilters (device);
     AssertComRC (rc);
 }
@@ -1788 +1822 @@
 void Host::onUSBDeviceDetached (HostUSBDevice *aDevice)
 {
-    LogFlowMember (("Host::onUSBDeviceDetached: aDevice=%p\n", aDevice));
+    LogFlowThisFunc (("aDevice=%p\n", aDevice));
+
+    AssertReturnVoid (aDevice);
+
     /// @todo (dmik) check locks
     AutoLock alock (this);
+
+    AutoLock devLock (aDevice);
 
     Guid id = aDevice->id();
@@ -1806 +1845 @@
     }
 
-    AssertReturn (!!device, (void) 0);
-
-    // remove from the collecion
+    AssertReturnVoid (!!device);
+
+    /* remove from the collecion */
     mUSBDevices.erase (it);
 
     if (device->machine())
     {
-        // the device is captured by a machine, instruct it to release
-        alock.unlock();
+        /* the device is captured by a machine, instruct it to release */
+
+        devLock.leave();
+        alock.leave();
+
         HRESULT rc = device->machine()->onUSBDeviceDetach (device->id());
         AssertComRC (rc);
@@ -1828 +1870 @@
 void Host::onUSBDeviceStateChanged (HostUSBDevice *aDevice)
 {
-    LogFlowMember (("Host::onUSBDeviceStateChanged: \n"));
+    LogFlowThisFunc (("aDevice=%p\n", aDevice));
+
     /// @todo (dmik) check locks
     AutoLock alock (this);

trunk/src/VBox/Main/HostUSBDeviceImpl.cpp

@@ -26 +26 @@
 #include <VBox/err.h>
 
-
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
 
-HostUSBDevice::HostUSBDevice()
-    : mUSBProxyService (NULL), m_pUsb (NULL)
-{
-}
-
-HostUSBDevice::~HostUSBDevice()
-{
-    if (m_pUsb)
-    {
-        USBProxyService::freeDevice (m_pUsb);
-        m_pUsb = NULL;
-    }
+DEFINE_EMPTY_CTOR_DTOR (HostUSBDevice)
+
+HRESULT HostUSBDevice::FinalConstruct()
+{
+    mUSBProxyService = NULL;
+    mUsb = NULL;
+
+    return S_OK;
+}
+
+void HostUSBDevice::FinalRelease()
+{
+    uninit();
 }
 
@@ -60 +60 @@
     ComAssertRet (aUsb, E_INVALIDARG);
 
-    AutoLock alock (this);
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan (this);
+    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
 
     /*
@@ -66 +68 @@
      * The UUID isn't stored anywhere.
      */
-    mId.create();
+    unconst (mId).create();
 
     /*
@@ -98 +100 @@
     }
 
-    /*
-     * Other data members.
-     */
+    mPendingState = mState;
+
+    /* Other data members */
+    mIsStatePending = false;
+/// @todo remove
+#if 0
     mIgnored = false;
+#endif
     mUSBProxyService = aUSBProxyService;
-    m_pUsb = aUsb;
-
-    setReady (true);
-    return S_OK;
+    mUsb = aUsb;
+
+    /* Confirm the successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+/**
+ *  Uninitializes the instance and sets the ready flag to FALSE.
+ *  Called either from FinalRelease() or by the parent when it gets destroyed.
+ */
+void HostUSBDevice::uninit()
+{
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan (this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    if (mUsb != NULL)
+    {
+        USBProxyService::freeDevice (mUsb);
+        mUsb = NULL;
+    }
+
+    mUSBProxyService = NULL;
 }
 
@@ -112 +140 @@
 /////////////////////////////////////////////////////////////////////////////
 
-/**
- * Returns the GUID.
- *
- * @returns COM status code
- * @param   aId     Address of result variable.
- */
 STDMETHODIMP HostUSBDevice::COMGETTER(Id)(GUIDPARAMOUT aId)
 {
@@ -123 +145 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    /* mId is constant during life time, no need to lock */
     mId.cloneTo (aId);
-    return S_OK;
-}
-
-
-/**
- * Returns the vendor Id.
- *
- * @returns COM status code
- * @param   aVendorId   Where to store the vendor id.
- */
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(VendorId)(USHORT *aVendorId)
 {
@@ -142 +159 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    *aVendorId = m_pUsb->idVendor;
-    return S_OK;
-}
-
-
-/**
- * Returns the product Id.
- *
- * @returns COM status code
- * @param   aProductId      Where to store the product id.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    *aVendorId = mUsb->idVendor;
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(ProductId)(USHORT *aProductId)
 {
@@ -161 +174 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    *aProductId = m_pUsb->idProduct;
-    return S_OK;
-}
-
-
-/**
- * Returns the revision BCD.
- *
- * @returns COM status code
- * @param   aRevision       Where to store the revision BCD.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    *aProductId = mUsb->idProduct;
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(Revision)(USHORT *aRevision)
 {
@@ -180 +189 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    *aRevision = m_pUsb->bcdDevice;
-    return S_OK;
-}
-
-/**
- * Returns the manufacturer string.
- *
- * @returns COM status code
- * @param   aManufacturer       Where to put the return string.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    *aRevision = mUsb->bcdDevice;
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(Manufacturer)(BSTR *aManufacturer)
 {
@@ -198 +204 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    Bstr (m_pUsb->pszManufacturer).cloneTo (aManufacturer);
-    return S_OK;
-}
-
-
-/**
- * Returns the product string.
- *
- * @returns COM status code
- * @param   aProduct            Where to put the return string.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Bstr (mUsb->pszManufacturer).cloneTo (aManufacturer);
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(Product)(BSTR *aProduct)
 {
@@ -217 +219 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    Bstr (m_pUsb->pszProduct).cloneTo (aProduct);
-    return S_OK;
-}
-
-
-/**
- * Returns the serial number string.
- *
- * @returns COM status code
- * @param   aSerialNumber     Where to put the return string.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Bstr (mUsb->pszProduct).cloneTo (aProduct);
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
 {
@@ -236 +234 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    Bstr (m_pUsb->pszSerialNumber).cloneTo (aSerialNumber);
-    return S_OK;
-}
-
-/**
- * Returns the device address string.
- *
- * @returns COM status code
- * @param   aAddress            Where to put the returned string.
- */
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Bstr (mUsb->pszSerialNumber).cloneTo (aSerialNumber);
+
+    return S_OK;
+}
+
 STDMETHODIMP HostUSBDevice::COMGETTER(Address)(BSTR *aAddress)
 {
@@ -254 +249 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
-
-    Bstr (m_pUsb->pszAddress).cloneTo (aAddress);
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Bstr (mUsb->pszAddress).cloneTo (aAddress);
+
     return S_OK;
 }
@@ -266 +264 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
 
     ///@todo implement
     aPort = 0;
+
     return S_OK;
 }
@@ -279 +280 @@
         return E_INVALIDARG;
 
-    AutoLock alock (this);
-    CHECK_READY();
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
 
     *aRemote = FALSE;
+
     return S_OK;
 }
@@ -294 +298 @@
         return E_POINTER;
 
-    AutoLock lock (this);
-    CHECK_READY();
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
 
     *aState = mState;
+
     return S_OK;
 }
@@ -305 +312 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+/** 
+ * @note Locks this object for reading.
+ */
 Utf8Str HostUSBDevice::name()
 {
     Utf8Str name;
 
-    AutoLock alock (this);
-    AssertReturn (isReady(), name);
-
-    bool haveManufacturer = m_pUsb->pszManufacturer && *m_pUsb->pszManufacturer;
-    bool haveProduct = m_pUsb->pszProduct && *m_pUsb->pszProduct;
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), name);
+
+    AutoReaderLock alock (this);
+
+    bool haveManufacturer = mUsb->pszManufacturer && *mUsb->pszManufacturer;
+    bool haveProduct = mUsb->pszProduct && *mUsb->pszProduct;
     if (haveManufacturer && haveProduct)
-        name = Utf8StrFmt ("%s %s", m_pUsb->pszManufacturer,
-                                     m_pUsb->pszProduct);
+        name = Utf8StrFmt ("%s %s", mUsb->pszManufacturer,
+                                     mUsb->pszProduct);
     else if(haveManufacturer)
-        name = Utf8StrFmt ("%s", m_pUsb->pszManufacturer);
+        name = Utf8StrFmt ("%s", mUsb->pszManufacturer);
     else if(haveProduct)
-        name = Utf8StrFmt ("%s", m_pUsb->pszManufacturer);
+        name = Utf8StrFmt ("%s", mUsb->pszManufacturer);
     else
         name = "<unknown>";
@@ -327 +339 @@
 }
 
-/** Sets the ignored flag and returns the device to the host */
+/// @todo remove
+#if 0
+/** 
+ * Sets the ignored flag and returns the device to the host.
+ *
+ * @note Locks this object for writing.
+ */
 void HostUSBDevice::setIgnored()
 {
+    AutoCaller autoCaller (this);
+    AssertComRCReturnVoid (autoCaller.rc());
+
     AutoLock alock (this);
-    AssertReturn (isReady(), (void) 0);
-
-    AssertReturn (!mIgnored, (void) 0);
-
-    mIgnored = false;
+
+    AssertReturnVoid (!mIgnored);
+
+    mIgnored = true;
+
     setHostDriven();
 }
-
-/** Requests the capture */
+#endif
+
+/** 
+ * @note Locks this object for writing.
+ */
 bool HostUSBDevice::setCaptured (SessionMachine *aMachine)
 {
     AssertReturn (aMachine, false);
 
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), false);
+
     AutoLock alock (this);
-    AssertReturn (isReady(), false);
 
     AssertReturn (
@@ -353 +379 @@
         false);
 
-    mUSBProxyService->captureDevice (this);
-
     mState = USBDeviceState_USBDeviceCaptured;
     mMachine = aMachine;
 
+    mUSBProxyService->captureDevice (this);
+
     return true;
 }
@@ -365 +391 @@
  *
  * @returns VBox status code.
+ *
+ * @note Locks this object for writing.
  */
 int HostUSBDevice::setHostDriven()
 {
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), VERR_INVALID_PARAMETER);
+
     AutoLock alock (this);
-    AssertReturn (isReady(), VERR_INVALID_PARAMETER);
 
     AssertReturn (mState == USBDeviceState_USBDeviceHeld, VERR_INVALID_PARAMETER);
@@ -382 +412 @@
  *
  * @returns VBox status code.
+ *
+ * @note Locks this object for writing.
  */
 int HostUSBDevice::reset()
 {
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), VERR_INVALID_PARAMETER);
+
     AutoLock alock (this);
-    AssertReturn (isReady(), VERR_INVALID_PARAMETER);
 
     mState = USBDeviceState_USBDeviceHeld;
     mMachine.setNull();
+/// @todo remove
+#if 0
     mIgnored = false;
+#endif
 
     /** @todo this operation might fail and cause the device to the reattached with a different address and all that. */
@@ -396 +433 @@
 }
 
+/// @todo remove
+#if 0
 /**
  *  Sets the state of the device, as it was reported by the host.
@@ -401 +440 @@
  *
  *  @param  aState      new state
+ *
+ *  @note Locks this object for writing.
  */
 void HostUSBDevice::setHostState (USBDeviceState_T aState)
 {
+    AutoCaller autoCaller (this);
+    AssertComRCReturnVoid (autoCaller.rc());
+
+    AutoLock alock (this);
+
     AssertReturn (
         aState == USBDeviceState_USBDeviceUnavailable ||
@@ -422 +468 @@
     }
 }
+#endif
 
 /**
@@ -433 +480 @@
  *      USBController::hasMatchingFilter (IUSBDevice *)
  *      in the sense of the device matching logic.
+ *
+ *  @note Locks this object for reading.
  */
 bool HostUSBDevice::isMatch (const USBDeviceFilter::Data &aData)
 {
-    AutoLock alock (this);
-    AssertReturn (isReady(), false);
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), false);
+
+    AutoReaderLock alock (this);
 
     if (!aData.mActive)
         return false;
 
-    if (!aData.mVendorId.isMatch (m_pUsb->idVendor))
+    if (!aData.mVendorId.isMatch (mUsb->idVendor))
     {
         LogFlowMember (("HostUSBDevice::isMatch: vendor not match %04X\n",
-                        m_pUsb->idVendor));
+                        mUsb->idVendor));
         return false;
     }
-    if (!aData.mProductId.isMatch (m_pUsb->idProduct))
+    if (!aData.mProductId.isMatch (mUsb->idProduct))
     {
         LogFlowMember (("HostUSBDevice::isMatch: product id not match %04X\n",
-                        m_pUsb->idProduct));
+                        mUsb->idProduct));
         return false;
     }
-    if (!aData.mRevision.isMatch (m_pUsb->bcdDevice))
+    if (!aData.mRevision.isMatch (mUsb->bcdDevice))
     {
         LogFlowMember (("HostUSBDevice::isMatch: rev not match %04X\n",
-                        m_pUsb->bcdDevice));
+                        mUsb->bcdDevice));
         return false;
     }
@@ -463 +514 @@
 #if !defined (__WIN__)
     // these filters are temporarily ignored on Win32
-    if (!aData.mManufacturer.isMatch (Bstr (m_pUsb->pszManufacturer)))
-        return false;
-    if (!aData.mProduct.isMatch (Bstr (m_pUsb->pszProduct)))
-        return false;
-    if (!aData.mSerialNumber.isMatch (Bstr (m_pUsb->pszSerialNumber)))
+    if (!aData.mManufacturer.isMatch (Bstr (mUsb->pszManufacturer)))
+        return false;
+    if (!aData.mProduct.isMatch (Bstr (mUsb->pszProduct)))
+        return false;
+    if (!aData.mSerialNumber.isMatch (Bstr (mUsb->pszSerialNumber)))
         return false;
     /// @todo (dmik) pusPort is yet absent
-//    if (!aData.mPort.isMatch (Bstr (m_pUsb->pusPort)))
+//    if (!aData.mPort.isMatch (Bstr (mUsb->pusPort)))
 //        return false;
 #endif
@@ -504 +555 @@
      * If all the criteria is empty, devices which are used by the host will not match.
      */
-    if (   m_pUsb->enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE
+    if (   mUsb->enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE
         && aData.mVendorId.string().isEmpty()
         && aData.mProductId.string().isEmpty()
@@ -529 +580 @@
 int HostUSBDevice::compare (PCUSBDEVICE pDev2)
 {
-    return compare (m_pUsb, pDev2);
+    return compare (mUsb, pDev2);
 }
 
@@ -564 +615 @@
  *
  * @param   aDev    The current device state as seen by the proxy backend.
+ *
+ * @note Locks this object for writing.
  */
 bool HostUSBDevice::updateState (PCUSBDEVICE aDev)
 {
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), false);
+
     AutoLock alock (this);
 

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

@@ -25 +25 @@
 #include "VirtualBoxBase.h"
 #include "USBDeviceFilterImpl.h"
-/* #include "USBProxyService.h" circular on Host/HostUSBDevice, the includer must include this. */
+/* #include "USBProxyService.h" circular on Host/HostUSBDevice, the includer
+ * must include this. */
 #include "Collection.h"
 
@@ -34 +35 @@
 
 /**
- * Object class used for the Host USBDevices property.
+ * Object class used to hold Host USB Device properties.
  */
 class ATL_NO_VTABLE HostUSBDevice :
+    public VirtualBoxBaseNEXT,
     public VirtualBoxSupportErrorInfoImpl <HostUSBDevice, IHostUSBDevice>,
     public VirtualBoxSupportTranslation <HostUSBDevice>,
-    public VirtualBoxBase,
     public IHostUSBDevice
 {
 public:
 
-    HostUSBDevice();
-    virtual ~HostUSBDevice();
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (HostUSBDevice)
 
     DECLARE_NOT_AGGREGATABLE(HostUSBDevice)
@@ -59 +59 @@
     NS_DECL_ISUPPORTS
 
+    DECLARE_EMPTY_CTOR_DTOR (HostUSBDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
     // public initializer/uninitializer for internal purposes only
     HRESULT init(PUSBDEVICE aUsb, USBProxyService *aUSBProxyService);
+    void uninit();
 
     // IUSBDevice properties
@@ -79 +85 @@
     // public methods only for internal purposes
 
-    const Guid &id() { return mId; }
-    USBDeviceState_T state() { return mState; }
+    /* @note Must be called from under the object read lock. */
+    const Guid &id() const { return mId; }
+
+    /* @note Must be called from under the object read lock. */
+    USBDeviceState_T state() const { return mState; }
+
+    /* @note Must be called from under the object read lock. */
+    USBDeviceState_T pendingState() const { return mPendingState; }
+
+    /* @note Must be called from under the object read lock. */
     ComObjPtr <SessionMachine, ComWeakRef> &machine() { return mMachine; }
+
+/// @todo remove
+#if 0
+    /* @note Must be called from under the object read lock. */
     bool isIgnored() { return mIgnored; }
+#endif
+
+    /* @note Must be called from under the object read lock. */
+    bool isStatePending() const { return mIsStatePending; }
+
+    /* @note Must be called from under the object read lock. */
+    PCUSBDEVICE usbData() const { return mUsb; }
 
     Utf8Str name();
 
+/// @todo remove
+#if 0
     void setIgnored();
+#endif
+
     bool setCaptured (SessionMachine *aMachine);
     int  setHostDriven();
     int  reset();
 
+/// @todo remove
+#if 0
     void setHostState (USBDeviceState_T aState);
+#endif
 
     bool isMatch (const USBDeviceFilter::Data &aData);
@@ -105 +137 @@
 private:
 
-    Guid mId;
+    const Guid mId;
     USBDeviceState_T mState;
+    USBDeviceState_T mPendingState;
     ComObjPtr <SessionMachine, ComWeakRef> mMachine;
-    bool mIgnored;
+    bool mIsStatePending : 1;
+/// @todo remove
+#if 0
+    bool mIgnored : 1;
+#endif
+
     /** Pointer to the USB Proxy Service instance. */
     USBProxyService *mUSBProxyService;
@@ -114 +152 @@
     /** Pointer to the USB Device structure owned by this device.
      * Only used for host devices. */
-    PUSBDEVICE m_pUsb;
+    PUSBDEVICE mUsb;
 };