Index: /trunk/include/VBox/com/Guid.h =================================================================== --- /trunk/include/VBox/com/Guid.h (revision 51686) +++ /trunk/include/VBox/com/Guid.h (revision 51687) @@ -5,5 +5,5 @@ /* - * Copyright (C) 2006-2012 Oracle Corporation + * Copyright (C) 2006-2014 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -36,8 +36,4 @@ #endif -#if defined(VBOX_WITH_XPCOM) -# include -#endif - #include "VBox/com/string.h" @@ -48,10 +44,10 @@ { -typedef enum - { - ZERO_GUID, - NORMAL_GUID, - INVALID_GUID - }GuidState_t; +typedef enum GuidState_t +{ + GUID_ZERO, + GUID_NORMAL, + GUID_INVALID +} GuidState_t; /** @@ -66,6 +62,6 @@ { ::RTUuidClear(&mUuid); - refresh(); - mGuidState = ZERO_GUID; + mGuidState = GUID_ZERO; + dbg_refresh(); } @@ -73,19 +69,15 @@ { mUuid = that.mUuid; - refresh(); - if (isEmpty()) - mGuidState = ZERO_GUID; - else - mGuidState = NORMAL_GUID; + mGuidState = that.mGuidState; + dbg_refresh(); } Guid(const RTUUID &that) { + mGuidState = GUID_NORMAL; mUuid = that; - refresh(); - if (isEmpty()) - mGuidState = ZERO_GUID; - else - mGuidState = NORMAL_GUID; + if (isZero()) + mGuidState = GUID_ZERO; + dbg_refresh(); } @@ -94,126 +86,213 @@ AssertCompileSize(GUID, sizeof(RTUUID)); ::memcpy(&mUuid, &that, sizeof(GUID)); - refresh(); - if (isEmpty()) - mGuidState = ZERO_GUID; + mGuidState = GUID_NORMAL; + if (isZero()) + mGuidState = GUID_ZERO; + dbg_refresh(); + } + + /** + * Construct a GUID from a string. + * + * @param that The UUID string. Can be with or without the curly + * brackets. Empty strings are translated to a zero + * GUID, and strings which are not confirming to + * valid GUID string representations are marked as + * invalid. + */ + Guid(const char *that) + { + if (!that || !*that) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_ZERO; + } else - mGuidState = NORMAL_GUID; - } - - /** - * Construct a GUID from a string. - * - * Should the string be invalid, the object will be set to the null GUID - * (isEmpty() == true). - * - * @param that The UUID string. We feed this to RTUuidFromStr(), - * so check it out for the exact format. - */ - Guid(const char *that) - { - mGuidState = NORMAL_GUID; - - int rc = ::RTUuidFromStr(&mUuid, that); - - if (RT_FAILURE(rc)) - { - ::RTUuidClear(&mUuid); - mGuidState = INVALID_GUID; - } - else if(isEmpty()) - mGuidState = ZERO_GUID; - refresh(); - } - - /** - * Construct a GUID from a BSTR. - * - * Should the string be empty or invalid, the object will be set to the - * null GUID (isEmpty() == true). - * - * @param that The UUID BSTR. We feed this to RTUuidFromUtf16(), - * so check it out for the exact format. - */ - Guid(const Bstr &that) - { - mGuidState = NORMAL_GUID; - - if (that.isEmpty()) - { - ::RTUuidClear(&mUuid); - mGuidState = ZERO_GUID; - } - else - { - int rc = ::RTUuidFromUtf16(&mUuid, that.raw()); + { + mGuidState = GUID_NORMAL; + int rc = ::RTUuidFromStr(&mUuid, that); if (RT_FAILURE(rc)) { ::RTUuidClear(&mUuid); - mGuidState = INVALID_GUID; + mGuidState = GUID_INVALID; } - } - - refresh(); + else if (isZero()) + mGuidState = GUID_ZERO; + } + dbg_refresh(); + } + + /** + * Construct a GUID from a BSTR. + * + * @param that The UUID BSTR. Can be with or without the curly + * brackets. Empty strings are translated to a zero + * GUID, and strings which are not confirming to + * valid GUID string representations are marked as + * invalid. + */ + Guid(CBSTR that) + { + if (!that || !*that) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_ZERO; + } + else + { + mGuidState = GUID_NORMAL; + int rc = ::RTUuidFromUtf16(&mUuid, that); + if (RT_FAILURE(rc)) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_INVALID; + } + else if (isZero()) + mGuidState = GUID_ZERO; + } + dbg_refresh(); + } + + /** + * Construct a GUID from a Utf8Str. + * + * @param that The UUID Utf8Str. Can be with or without the curly + * brackets. Empty strings are translated to a zero + * GUID, and strings which are not confirming to + * valid GUID string representations are marked as + */ + Guid(const Utf8Str &that) + { + Guid(that.c_str()); + } + + /** + * Construct a GUID from a RTCString. + * + * @param that The UUID RTCString. Can be with or without the curly + * brackets. Empty strings are translated to a zero + * GUID, and strings which are not confirming to + * valid GUID string representations are marked as + */ + Guid(const RTCString &that) + { + Guid(that.c_str()); + } + + /** + * Construct a GUID from a Bstr. + * + * @param that The UUID Bstr. Can be with or without the curly + * brackets. Empty strings are translated to a zero + * GUID, and strings which are not confirming to + * valid GUID string representations are marked as + */ + Guid(const Bstr &that) + { + Guid(that.raw()); } Guid& operator=(const Guid &that) { - mGuidState = NORMAL_GUID; - ::memcpy(&mUuid, &that.mUuid, sizeof (RTUUID)); - if (isEmpty()) - mGuidState = ZERO_GUID; - refresh(); + mUuid = that.mUuid; + mGuidState = that.mGuidState; + dbg_refresh(); return *this; } + + Guid& operator=(const RTUUID &guid) + { + mUuid = guid; + mGuidState = GUID_NORMAL; + if (isZero()) + mGuidState = GUID_ZERO; + dbg_refresh(); + return *this; + } + Guid& operator=(const GUID &guid) { - mGuidState = NORMAL_GUID; - ::memcpy(&mUuid, &guid, sizeof (GUID)); - if (isEmpty()) - mGuidState = ZERO_GUID; - refresh(); + AssertCompileSize(GUID, sizeof(RTUUID)); + ::memcpy(&mUuid, &guid, sizeof(GUID)); + mGuidState = GUID_NORMAL; + if (isZero()) + mGuidState = GUID_ZERO; + dbg_refresh(); return *this; } - Guid& operator=(const RTUUID &guid) - { - mGuidState = NORMAL_GUID; - ::memcpy(&mUuid, &guid, sizeof (RTUUID)); - if (isEmpty()) - mGuidState = ZERO_GUID; - refresh(); + + Guid& operator=(const char *str) + { + if (!str || !*str) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_ZERO; + } + else + { + mGuidState = GUID_NORMAL; + int rc = ::RTUuidFromStr(&mUuid, str); + if (RT_FAILURE(rc)) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_INVALID; + } + else if (isZero()) + mGuidState = GUID_ZERO; + } + dbg_refresh(); return *this; } - Guid& operator=(const char *str) - { - mGuidState = NORMAL_GUID; - int rc = ::RTUuidFromStr(&mUuid, str); - - if (RT_FAILURE(rc)) + + Guid& operator=(CBSTR str) + { + if (!str || !*str) { ::RTUuidClear(&mUuid); - mGuidState = INVALID_GUID; + mGuidState = GUID_ZERO; } else { - if (isEmpty()) - mGuidState = ZERO_GUID; - } - - refresh(); - + mGuidState = GUID_NORMAL; + int rc = ::RTUuidFromUtf16(&mUuid, str); + if (RT_FAILURE(rc)) + { + ::RTUuidClear(&mUuid); + mGuidState = GUID_INVALID; + } + else if (isZero()) + mGuidState = GUID_ZERO; + } + dbg_refresh(); return *this; } + Guid& operator=(const Utf8Str &str) + { + return operator=(str.c_str()); + } + + Guid& operator=(const RTCString &str) + { + return operator=(str.c_str()); + } + + Guid& operator=(const Bstr &str) + { + return operator=(str.raw()); + } + void create() { ::RTUuidCreate(&mUuid); - mGuidState = NORMAL_GUID; - refresh(); - } + mGuidState = GUID_NORMAL; + dbg_refresh(); + } + void clear() { ::RTUuidClear(&mUuid); - mGuidState = ZERO_GUID; - refresh(); + mGuidState = GUID_ZERO; + dbg_refresh(); } @@ -226,9 +305,5 @@ Utf8Str toString() const { - char buf[RTUUID_STR_LENGTH]; - - ::memset(buf,0,RTUUID_STR_LENGTH); - - if (mGuidState == INVALID_GUID) + if (mGuidState == GUID_INVALID) { /* What to return in case of wrong Guid */ @@ -236,6 +311,7 @@ } - ::RTUuidToStr(&mUuid, buf, RTUUID_STR_LENGTH); - + char buf[RTUUID_STR_LENGTH]; + ::memset(buf, '\0', sizeof(buf)); + ::RTUuidToStr(&mUuid, buf, sizeof(buf)); return Utf8Str(buf); @@ -250,6 +326,5 @@ Utf8Str toStringCurly() const { - - if (mGuidState == INVALID_GUID) + if (mGuidState == GUID_INVALID) { /* What to return in case of wrong Guid */ @@ -257,9 +332,9 @@ } - char buf[RTUUID_STR_LENGTH + 2] = "{"; - - ::RTUuidToStr(&mUuid, buf + 1, RTUUID_STR_LENGTH); + char buf[RTUUID_STR_LENGTH + 2]; + ::memset(buf, '\0', sizeof(buf)); + ::RTUuidToStr(&mUuid, buf + 1, sizeof(buf) - 2); + buf[0] = '{'; buf[sizeof(buf) - 2] = '}'; - buf[sizeof(buf) - 1] = '\0'; return Utf8Str(buf); @@ -274,9 +349,14 @@ Bstr toUtf16() const { - if (mGuidState == INVALID_GUID) + if (mGuidState == GUID_INVALID) + { + /* What to return in case of wrong Guid */ return Bstr("00000000-0000-0000-0000-00000000000"); + } RTUTF16 buf[RTUUID_STR_LENGTH]; - ::RTUuidToUtf16(&mUuid, buf, RTUUID_STR_LENGTH); + ::memset(buf, '\0', sizeof(buf)); + ::RTUuidToUtf16(&mUuid, buf, RT_ELEMENTS(buf)); + return Bstr(buf); } @@ -284,22 +364,21 @@ bool isValid() const { - bool res = true; - if (mGuidState == INVALID_GUID) - res = false; - - return res; + return mGuidState != GUID_INVALID; } bool isZero() const { - return (::RTUuidIsNull(&mUuid) && mGuidState == ZERO_GUID); + return mGuidState == GUID_ZERO; } bool operator==(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid) == 0; } + bool operator==(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) == 0; } bool operator==(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) == 0; } bool operator!=(const Guid &that) const { return !operator==(that); } bool operator!=(const GUID &guid) const { return !operator==(guid); } - bool operator<( const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid) < 0; } - bool operator<( const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; } + bool operator!=(const RTUUID &guid) const { return !operator==(guid); } + bool operator<(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid) < 0; } + bool operator<(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; } + bool operator<(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) < 0; } /** @@ -319,93 +398,8 @@ } -#if !defined(VBOX_WITH_XPCOM) - - /** To assign instances to OUT_GUID parameters from within the interface - * method. */ - const Guid &cloneTo(GUID *pguid) const - { - if (pguid) - ::memcpy(pguid, &mUuid, sizeof(GUID)); - return *this; - } - - /** To pass instances as OUT_GUID parameters to interface methods. */ - GUID *asOutParam() - { - return (GUID *)&mUuid; - } - -#else - - /** To assign instances to OUT_GUID parameters from within the - * interface method */ - const Guid &cloneTo(nsID **ppGuid) const - { - if (ppGuid) - *ppGuid = (nsID *)nsMemory::Clone(&mUuid, sizeof(nsID)); - - return *this; - } - - /** - * Internal helper class for asOutParam(). - * - * This takes a GUID refrence in the constructor and copies the mUuid from - * the method to that instance in its destructor. - */ - class GuidOutParam - { - GuidOutParam(Guid &guid) - : ptr(0), - outer(guid) - { - outer.clear(); - } - - nsID *ptr; - Guid &outer; - GuidOutParam(const GuidOutParam &that); // disabled - GuidOutParam &operator=(const GuidOutParam &that); // disabled - public: - operator nsID**() { return &ptr; } - ~GuidOutParam() - { - if (ptr && outer.isEmpty()) - { - outer = *ptr; - outer.refresh(); - nsMemory::Free(ptr); - } - } - friend class Guid; - }; - - /** to pass instances as OUT_GUID parameters to interface methods */ - GuidOutParam asOutParam() { return GuidOutParam(*this); } - -#endif - - /* to directly test IN_GUID interface method's parameters */ - static bool isEmpty(const GUID &guid) - { - return ::RTUuidIsNull((PRTUUID)&guid); - } - - /** - * Static immutable empty object. May be used for comparison purposes. + /** + * Static immutable empty (zero) object. May be used for comparison purposes. */ static const Guid Empty; - -protected: - - bool isEmpty() const - { - return ::RTUuidIsNull(&mUuid); - } - - bool isNotEmpty() const - { - return !::RTUuidIsNull(&mUuid); - } private: @@ -417,9 +411,19 @@ * in release code. */ - inline void refresh() + inline void dbg_refresh() { #ifdef DEBUG -// ::RTUuidToStr(&mUuid, mszUuid, RTUUID_STR_LENGTH); -// m_pcszUUID = mszUuid; + switch (mGuidState) + { + case GUID_ZERO: + case GUID_NORMAL: + ::RTUuidToStr(&mUuid, mszUuid, RTUUID_STR_LENGTH); + break; + default: + ::memset(mszUuid, '\0', sizeof(mszUuid)); + ::RTStrCopy(mszUuid, sizeof(mszUuid), "INVALID"); + break; + } + m_pcszUUID = mszUuid; #endif } @@ -437,17 +441,4 @@ #endif }; -/* -inline Bstr asGuidStr(const Bstr& str) -{ - Guid guid(str); - return guid.isEmpty() ? Bstr() : guid.toUtf16(); -} -*/ -//inline bool isValidGuid(const Bstr& str) -//{ -// Guid guid(str); -// return guid.isValid(); -//// return !guid.isEmpty(); -//} } /* namespace com */ Index: /trunk/src/VBox/Main/include/ProgressImpl.h =================================================================== --- /trunk/src/VBox/Main/include/ProgressImpl.h (revision 51686) +++ /trunk/src/VBox/Main/include/ProgressImpl.h (revision 51687) @@ -6,5 +6,5 @@ /* - * Copyright (C) 2006-2013 Oracle Corporation + * Copyright (C) 2006-2014 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -91,5 +91,4 @@ * @param aDescription * @param aCancelable - * @param aId * @return */ @@ -100,6 +99,5 @@ IUnknown *aInitiator, Utf8Str aDescription, - BOOL aCancelable, - OUT_GUID aId = NULL) + BOOL aCancelable) { return init( @@ -113,6 +111,5 @@ 1, // ulTotalOperationsWeight aDescription, // aFirstOperationDescription - 1, // ulFirstOperationWeight - aId); + 1); // ulFirstOperationWeight } @@ -126,5 +123,4 @@ * @param cOperations * @param bstrFirstOperationDescription - * @param aId * @return */ @@ -136,6 +132,5 @@ Utf8Str aDescription, BOOL aCancelable, ULONG cOperations, - Utf8Str aFirstOperationDescription, - OUT_GUID aId = NULL) + Utf8Str aFirstOperationDescription) { return init( @@ -149,6 +144,5 @@ cOperations, // ulTotalOperationsWeight = cOperations aFirstOperationDescription, // aFirstOperationDescription - 1, // ulFirstOperationWeight: weigh them all the same - aId); + 1); // ulFirstOperationWeight: weigh them all the same } @@ -163,6 +157,5 @@ ULONG ulTotalOperationsWeight, Utf8Str aFirstOperationDescription, - ULONG ulFirstOperationWeight, - OUT_GUID aId = NULL); + ULONG ulFirstOperationWeight); HRESULT init(BOOL aCancelable, @@ -170,15 +163,5 @@ Utf8Str aOperationDescription); -// initializer/uninitializer for internal purposes only - HRESULT init(AutoInitSpan &aAutoInitSpan, -#if !defined (VBOX_COM_INPROC) - VirtualBox *aParent, -#endif - IUnknown *aInitiator, - Utf8Str aDescription, OUT_GUID aId = NULL); - HRESULT init(AutoInitSpan &aAutoInitSpan); - void init(AutoUninitSpan &aAutoUninitSpan); void uninit(); - void uninit(AutoUninitSpan &aAutoUninitSpan); Index: /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp (revision 51686) +++ /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp (revision 51687) @@ -610,6 +610,5 @@ static_cast(this), bstrDescription.raw(), - FALSE /*aCancelable*/, - NULL /*aId*/); + FALSE /*aCancelable*/); } if (SUCCEEDED(hrc)) @@ -1989,6 +1988,5 @@ static_cast(this), bstrDescription.raw(), - FALSE /*aCancelable*/, - NULL /*aId*/); + FALSE /*aCancelable*/); } if (SUCCEEDED(hrc)) Index: /trunk/src/VBox/Main/src-all/ProgressImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-all/ProgressImpl.cpp (revision 51686) +++ /trunk/src/VBox/Main/src-all/ProgressImpl.cpp (revision 51687) @@ -6,5 +6,5 @@ /* - * Copyright (C) 2006-2013 Oracle Corporation + * Copyright (C) 2006-2014 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -419,14 +419,15 @@ * ulTotalOperationsWeight = ulFirstOperationWeight = 1. * - * @param aParent See Progress::init(). - * @param aInitiator See Progress::init(). - * @param aDescription See Progress::init(). - * @param aCancelable Flag whether the task maybe canceled. - * @param cOperations Number of operations within this task (at least 1). + * @param aParent Parent object (only for server-side Progress objects). + * @param aInitiator Initiator of the task (for server-side objects. Can be + * NULL which means initiator = parent, otherwise must not + * be NULL). + * @param aDescription Overall task description. + * @param aCancelable Flag whether the task maybe canceled. + * @param cOperations Number of operations within this task (at least 1). * @param ulTotalOperationsWeight Total weight of operations; must be the sum of ulFirstOperationWeight and * what is later passed with each subsequent setNextOperation() call. * @param bstrFirstOperationDescription Description of the first operation. * @param ulFirstOperationWeight Weight of first sub-operation. - * @param aId See Progress::init(). */ HRESULT Progress::init( @@ -440,6 +441,5 @@ ULONG ulTotalOperationsWeight, Utf8Str aFirstOperationDescription, - ULONG ulFirstOperationWeight, - OUT_GUID aId /* = NULL */) + ULONG ulFirstOperationWeight) { LogFlowThisFunc(("aDescription=\"%s\", cOperations=%d, ulTotalOperationsWeight=%d, aFirstOperationDescription=\"%s\", ulFirstOperationWeight=%d\n", @@ -477,6 +477,6 @@ #if !defined(VBOX_COM_INPROC) /* assign (and therefore addref) initiator only if it is not VirtualBox - * * (to avoid cycling); otherwise mInitiator will remain null which means - * * that it is the same as the parent */ + * (to avoid cycling); otherwise mInitiator will remain null which means + * that it is the same as the parent */ if (aInitiator) { @@ -490,10 +490,8 @@ unconst(mId).create(); - if (aId) - mId.cloneTo(aId); #if !defined(VBOX_COM_INPROC) /* add to the global collection of progress operations (note: after - * * creating mId) */ + * creating mId) */ mParent->i_addProgress(this); #endif Index: /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 51686) +++ /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 51687) @@ -6924,6 +6924,5 @@ ulTotalOperationsWeight, Bstr(tr("Starting Hard Disk operations")).raw(), - 1, - NULL); + 1); AssertComRCReturnRC(rc); } @@ -6943,6 +6942,5 @@ 10 /* ulTotalOperationsWeight */, Bstr(tr("Teleporting virtual machine")).raw(), - 1 /* ulFirstOperationWeight */, - NULL); + 1 /* ulFirstOperationWeight */); } else if (fFaultToleranceSyncEnabled) @@ -6954,6 +6952,5 @@ 10 /* ulTotalOperationsWeight */, Bstr(tr("Fault Tolerance syncing of remote virtual machine")).raw(), - 1 /* ulFirstOperationWeight */, - NULL); + 1 /* ulFirstOperationWeight */); } Index: /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp (revision 51686) +++ /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp (revision 51687) @@ -5,5 +5,5 @@ /* - * Copyright (C) 2010-2011 Oracle Corporation + * Copyright (C) 2010-2014 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -83,6 +83,5 @@ 1 /* ulTotalOperationsWeight */, bstrDescription /* bstrFirstOperationDescription */, - 1 /* ulFirstOperationWeight */, - NULL /* pId */); + 1 /* ulFirstOperationWeight */); } @@ -124,6 +123,5 @@ uTotalOperationsWeight, bstrFirstOperationDescription, - uFirstOperationWeight, - NULL); + uFirstOperationWeight); }