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);