Rename "bundle id" concept to "bundle code"

The "bundle id" always had more in common with the PackageCode from the Windows
Installer. With the introduction of an actual Id attribute on the Bundle
element, there is potential for confusion, so there is finally real motivation
to rename "bundle id" to "bundle code".

1 files changed, 29 insertions, 29 deletions

diff --git a/src/burn/engine/relatedbundle.cpp b/src/burn/engine/relatedbundle.cpp
index 23e0f352..938b24d7 100644
--- a/src/burn/engine/relatedbundle.cpp
+++ b/src/burn/engine/relatedbundle.cpp
@@ -30,8 +30,8 @@ static HRESULT LoadIfRelatedBundle(
     __in BURN_RELATED_BUNDLES* pRelatedBundles
     );
 static HRESULT LoadRelatedBundleFromKey(
-    __in_z LPCWSTR wzRelatedBundleId,
-    __in HKEY hkBundleId,
+    __in_z LPCWSTR wzRelatedBundleCode,
+    __in HKEY hkBundleCode,
     __in BOOL fPerMachine,
     __in BOOTSTRAPPER_RELATION_TYPE relationType,
     __in BURN_RELATED_BUNDLE *pRelatedBundle
@@ -108,7 +108,7 @@ extern "C" HRESULT RelatedBundleFindById(
     HRESULT hr = S_OK;
     BURN_RELATED_BUNDLE* pRelatedBundle = NULL;
     BURN_PACKAGE* pPackage = NULL;
-    
+
     *ppRelatedBundle = NULL;
 
     for (DWORD i = 0; i < pRelatedBundles->cRelatedBundles; ++i)
@@ -180,7 +180,7 @@ static __callback int __cdecl CompareRelatedBundlesDetect(
     const BURN_RELATED_BUNDLE* pBundleLeft = static_cast<const BURN_RELATED_BUNDLE*>(pvLeft);
     const BURN_RELATED_BUNDLE* pBundleRight = static_cast<const BURN_RELATED_BUNDLE*>(pvRight);
 
-    // Sort by relation type, then version, then bundle id.
+    // Sort by relation type, then version, then bundle code.
     if (pBundleLeft->detectRelationType != pBundleRight->detectRelationType)
     {
         // Upgrade bundles last, everything else according to the enum.
@@ -223,7 +223,7 @@ static __callback int __cdecl CompareRelatedBundlesPlan(
     const BURN_RELATED_BUNDLE* pBundleLeft = *reinterpret_cast<BURN_RELATED_BUNDLE**>(const_cast<void*>(pvLeft));
     const BURN_RELATED_BUNDLE* pBundleRight = *reinterpret_cast<BURN_RELATED_BUNDLE**>(const_cast<void*>(pvRight));
 
-    // Sort by relation type, then version, then bundle id.
+    // Sort by relation type, then version, then bundle code.
     if (pBundleLeft->planRelationType != pBundleRight->planRelationType)
     {
         // Upgrade bundles last, everything else according to the enum.
@@ -266,7 +266,7 @@ static BUNDLE_QUERY_CALLBACK_RESULT CALLBACK QueryRelatedBundlesCallback(
     BUNDLE_QUERY_CONTEXT* pContext = reinterpret_cast<BUNDLE_QUERY_CONTEXT*>(pvContext);
 
     hr = LoadIfRelatedBundle(pBundle, pContext->pRegistration, pContext->pRelatedBundles);
-    ExitOnFailure(hr, "Failed to load related bundle: %ls", pBundle->wzBundleId);
+    ExitOnFailure(hr, "Failed to load related bundle: %ls", pBundle->wzBundleCode);
 
 LExit:
     return result;
@@ -283,8 +283,8 @@ static HRESULT LoadIfRelatedBundle(
     BOOTSTRAPPER_RELATION_TYPE relationType = RelatedBundleConvertRelationType(pBundle->relationType);
     BURN_RELATED_BUNDLE* pRelatedBundle = NULL;
 
-    // If we found our bundle id, it's not a related bundle.
-    if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pBundle->wzBundleId, -1, pRegistration->sczId, -1))
+    // If we found our bundle code, it's not a related bundle.
+    if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, pBundle->wzBundleCode, -1, pRegistration->sczCode, -1))
     {
         ExitFunction1(hr = S_FALSE);
     }
@@ -294,8 +294,8 @@ static HRESULT LoadIfRelatedBundle(
 
     pRelatedBundle = pRelatedBundles->rgRelatedBundles + pRelatedBundles->cRelatedBundles;
 
-    hr = LoadRelatedBundleFromKey(pBundle->wzBundleId, pBundle->hkBundle, fPerMachine, relationType, pRelatedBundle);
-    ExitOnFailure(hr, "Failed to initialize package from related bundle id: %ls", pBundle->wzBundleId);
+    hr = LoadRelatedBundleFromKey(pBundle->wzBundleCode, pBundle->hkBundle, fPerMachine, relationType, pRelatedBundle);
+    ExitOnFailure(hr, "Failed to initialize package from related bundle code: %ls", pBundle->wzBundleCode);
 
     hr = DependencyDetectRelatedBundle(pRelatedBundle, pRegistration);
     ExitOnFailure(hr, "Failed to detect dependencies for related bundle.");
@@ -307,8 +307,8 @@ LExit:
 }
 
 static HRESULT LoadRelatedBundleFromKey(
-    __in_z LPCWSTR wzRelatedBundleId,
-    __in HKEY hkBundleId,
+    __in_z LPCWSTR wzRelatedBundleCode,
+    __in HKEY hkBundleCode,
     __in BOOL fPerMachine,
     __in BOOTSTRAPPER_RELATION_TYPE relationType,
     __in BURN_RELATED_BUNDLE* pRelatedBundle
@@ -327,7 +327,7 @@ static HRESULT LoadRelatedBundleFromKey(
     BURN_DEPENDENCY_PROVIDER* pBundleDependencyProvider = NULL;
 
     // Only support progress from engines that are compatible.
-    hr = RegReadNumber(hkBundleId, BURN_REGISTRATION_REGISTRY_ENGINE_PROTOCOL_VERSION, &dwEngineProtocolVersion);
+    hr = RegReadNumber(hkBundleCode, BURN_REGISTRATION_REGISTRY_ENGINE_PROTOCOL_VERSION, &dwEngineProtocolVersion);
     if (SUCCEEDED(hr))
     {
         fSupportsBurnProtocol = BURN_PROTOCOL_VERSION == dwEngineProtocolVersion;
@@ -335,7 +335,7 @@ static HRESULT LoadRelatedBundleFromKey(
     else
     {
         // Rely on version checking (aka: version greater than or equal to last protocol breaking change *and* versions that are older or the same as this engine)
-        hr = RegReadVersion(hkBundleId, BURN_REGISTRATION_REGISTRY_ENGINE_VERSION, &qwEngineVersion);
+        hr = RegReadVersion(hkBundleCode, BURN_REGISTRATION_REGISTRY_ENGINE_VERSION, &qwEngineVersion);
         if (SUCCEEDED(hr))
         {
             fSupportsBurnProtocol = (FILEMAKEVERSION(3, 6, 2221, 0) <= qwEngineVersion && qwEngineVersion <= FILEMAKEVERSION(rmj, rmm, rup, rpr));
@@ -344,19 +344,19 @@ static HRESULT LoadRelatedBundleFromKey(
         hr = S_OK;
     }
 
-    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION, &sczBundleVersion);
-    ExitOnFailure(hr, "Failed to read version from registry for bundle: %ls", wzRelatedBundleId);
+    hr = RegReadString(hkBundleCode, BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION, &sczBundleVersion);
+    ExitOnFailure(hr, "Failed to read version from registry for bundle: %ls", wzRelatedBundleCode);
 
     hr = VerParseVersion(sczBundleVersion, 0, FALSE, &pRelatedBundle->pVersion);
     ExitOnFailure(hr, "Failed to parse pseudo bundle version: %ls", sczBundleVersion);
 
     if (pRelatedBundle->pVersion->fInvalid)
     {
-        LogId(REPORT_WARNING, MSG_RELATED_PACKAGE_INVALID_VERSION, wzRelatedBundleId, sczBundleVersion);
+        LogId(REPORT_WARNING, MSG_RELATED_PACKAGE_INVALID_VERSION, wzRelatedBundleCode, sczBundleVersion);
     }
 
-    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, &sczCachePath);
-    ExitOnFailure(hr, "Failed to read cache path from registry for bundle: %ls", wzRelatedBundleId);
+    hr = RegReadString(hkBundleCode, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, &sczCachePath);
+    ExitOnFailure(hr, "Failed to read cache path from registry for bundle: %ls", wzRelatedBundleCode);
 
     if (FileExistsEx(sczCachePath, NULL))
     {
@@ -364,13 +364,13 @@ static HRESULT LoadRelatedBundleFromKey(
     }
     else
     {
-        LogId(REPORT_STANDARD, MSG_DETECT_RELATED_BUNDLE_NOT_CACHED, wzRelatedBundleId, sczCachePath);
+        LogId(REPORT_STANDARD, MSG_DETECT_RELATED_BUNDLE_NOT_CACHED, wzRelatedBundleCode, sczCachePath);
     }
 
     pRelatedBundle->fPlannable = fCached;
 
-    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, &dependencyProvider.sczKey);
-    ExitOnPathFailure(hr, fExists, "Failed to read provider key from registry for bundle: %ls", wzRelatedBundleId);
+    hr = RegReadString(hkBundleCode, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, &dependencyProvider.sczKey);
+    ExitOnPathFailure(hr, fExists, "Failed to read provider key from registry for bundle: %ls", wzRelatedBundleCode);
 
     if (dependencyProvider.sczKey && *dependencyProvider.sczKey)
     {
@@ -379,23 +379,23 @@ static HRESULT LoadRelatedBundleFromKey(
         dependencyProvider.fImported = TRUE;
 
         hr = StrAllocString(&dependencyProvider.sczVersion, pRelatedBundle->pVersion->sczVersion, 0);
-        ExitOnFailure(hr, "Failed to copy version for bundle: %ls", wzRelatedBundleId);
+        ExitOnFailure(hr, "Failed to copy version for bundle: %ls", wzRelatedBundleCode);
 
-        hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME, &dependencyProvider.sczDisplayName);
-        ExitOnPathFailure(hr, fExists, "Failed to copy display name for bundle: %ls", wzRelatedBundleId);
+        hr = RegReadString(hkBundleCode, BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME, &dependencyProvider.sczDisplayName);
+        ExitOnPathFailure(hr, fExists, "Failed to copy display name for bundle: %ls", wzRelatedBundleCode);
     }
 
-    hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_TAG, &pRelatedBundle->sczTag);
-    ExitOnPathFailure(hr, fExists, "Failed to read tag from registry for bundle: %ls", wzRelatedBundleId);
+    hr = RegReadString(hkBundleCode, BURN_REGISTRATION_REGISTRY_BUNDLE_TAG, &pRelatedBundle->sczTag);
+    ExitOnPathFailure(hr, fExists, "Failed to read tag from registry for bundle: %ls", wzRelatedBundleCode);
 
     pRelatedBundle->detectRelationType = relationType;
 
-    hr = PseudoBundleInitializeRelated(&pRelatedBundle->package, fSupportsBurnProtocol, fPerMachine, wzRelatedBundleId,
+    hr = PseudoBundleInitializeRelated(&pRelatedBundle->package, fSupportsBurnProtocol, fPerMachine, wzRelatedBundleCode,
 #ifdef DEBUG
                                        pRelatedBundle->detectRelationType,
 #endif
                                        fCached, sczCachePath, qwFileSize, pBundleDependencyProvider);
-    ExitOnFailure(hr, "Failed to initialize related bundle to represent bundle: %ls", wzRelatedBundleId);
+    ExitOnFailure(hr, "Failed to initialize related bundle to represent bundle: %ls", wzRelatedBundleCode);
 
 LExit:
     DependencyUninitializeProvider(&dependencyProvider);