Let BA override the package's cache type during Plan.

Rename cache types to REMOVE, KEEP, FORCE.
Change implementation of FORCE to not be through CACHED request state.
Create package condition enum so BA can tell when InstallCondition wasn't specified.
Tell BA when package is cached.
Tell BA when package is planned to be cached and uncached.

1 files changed, 52 insertions, 45 deletions

diff --git a/src/engine/plan.cpp b/src/engine/plan.cpp
index e5c1ee36..9a4aa5f1 100644
--- a/src/engine/plan.cpp
+++ b/src/engine/plan.cpp
@@ -137,6 +137,10 @@ static BOOL NeedsCache(
     __in BURN_PACKAGE* pPackage,
     __in BOOL fExecute
     );
+static BOOL ForceCache(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    );
 
 // function definitions
 
@@ -312,28 +316,20 @@ extern "C" HRESULT PlanDefaultPackageRequestState(
     __in BURN_PACKAGE_TYPE packageType,
     __in BOOTSTRAPPER_PACKAGE_STATE currentState,
     __in BOOL fPermanent,
-    __in BURN_CACHE_TYPE cacheType,
     __in BOOTSTRAPPER_ACTION action,
-    __in BOOL fInstallCondition,
+    __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition,
     __in BOOTSTRAPPER_RELATION_TYPE relationType,
     __out BOOTSTRAPPER_REQUEST_STATE* pRequestState
     )
 {
     HRESULT hr = S_OK;
     BOOTSTRAPPER_REQUEST_STATE defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
-    BOOL fFallbackToCache = BURN_CACHE_TYPE_ALWAYS == cacheType && BOOTSTRAPPER_ACTION_UNINSTALL != action && BOOTSTRAPPER_PACKAGE_STATE_CACHED > currentState;
 
-    // If doing layout, then always default to requesting the file be cached.
+    // If doing layout, then always default to requesting the package be cached.
     if (BOOTSTRAPPER_ACTION_LAYOUT == action)
     {
         *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
     }
-    else if (BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED == currentState && BOOTSTRAPPER_ACTION_UNINSTALL != action)
-    {
-        // Superseded means the package is on the machine but not active, so only uninstall operations are allowed.
-        // Requesting present makes sure always-cached packages are cached.
-        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
-    }
     else if (BOOTSTRAPPER_RELATION_PATCH == relationType && BURN_PACKAGE_TYPE_MSP == packageType)
     {
         // For patch related bundles, only install a patch if currently absent during install, modify, or repair.
@@ -341,20 +337,22 @@ extern "C" HRESULT PlanDefaultPackageRequestState(
         {
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
         }
-        else if (fFallbackToCache)
-        {
-            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
-        }
         else
         {
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
         }
     }
+    else if (BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED == currentState && BOOTSTRAPPER_ACTION_UNINSTALL != action)
+    {
+        // Superseded means the package is on the machine but not active, so only uninstall operations are allowed.
+        // All other operations do nothing.
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
+    }
     else if (BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE == currentState && !(BOOTSTRAPPER_ACTION_UNINSTALL == action && BURN_PACKAGE_TYPE_MSP == packageType))
     {
         // Obsolete means the package is not on the machine and should not be installed, *except* patches can be obsolete
         // and present so allow them to be removed during uninstall. Everyone else, gets nothing.
-        *pRequestState = fFallbackToCache ? BOOTSTRAPPER_REQUEST_STATE_CACHE : BOOTSTRAPPER_REQUEST_STATE_NONE;
+        *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
     }
     else // pick the best option for the action state and install condition.
     {
@@ -363,7 +361,7 @@ extern "C" HRESULT PlanDefaultPackageRequestState(
 
         // If we're doing an install, use the install condition
         // to determine whether to use the default request state or make the package absent.
-        if (BOOTSTRAPPER_ACTION_UNINSTALL != action && !fInstallCondition)
+        if (BOOTSTRAPPER_ACTION_UNINSTALL != action && BOOTSTRAPPER_PACKAGE_CONDITION_FALSE == installCondition)
         {
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
         }
@@ -371,11 +369,6 @@ extern "C" HRESULT PlanDefaultPackageRequestState(
         {
             *pRequestState = defaultRequestState;
         }
-
-        if (fFallbackToCache && BOOTSTRAPPER_REQUEST_STATE_CACHE > *pRequestState)
-        {
-            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
-        }
     }
 
 LExit:
@@ -844,8 +837,8 @@ static HRESULT PlanPackagesHelper(
     {
         DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? cPackages - 1 - i : i;
         BURN_PACKAGE* pPackage = rgPackages + iPackage;
-        
-        UserExperienceOnPlannedPackage(pUX, pPackage->sczId, pPackage->execute, pPackage->rollback);
+
+        UserExperienceOnPlannedPackage(pUX, pPackage->sczId, pPackage->execute, pPackage->rollback, pPackage->fPlannedCache, pPackage->fPlannedUncache);
     }
 
 LExit:
@@ -861,6 +854,7 @@ static HRESULT InitializePackage(
     )
 {
     HRESULT hr = S_OK;
+    BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition = BOOTSTRAPPER_PACKAGE_CONDITION_DEFAULT;
     BOOL fInstallCondition = FALSE;
     BOOL fBeginCalled = FALSE;
 
@@ -874,20 +868,18 @@ static HRESULT InitializePackage(
     {
         hr = ConditionEvaluate(pVariables, pPackage->sczInstallCondition, &fInstallCondition);
         ExitOnFailure(hr, "Failed to evaluate install condition.");
-    }
-    else
-    {
-        fInstallCondition = TRUE;
+
+        installCondition = fInstallCondition ? BOOTSTRAPPER_PACKAGE_CONDITION_TRUE : BOOTSTRAPPER_PACKAGE_CONDITION_FALSE;
     }
 
     // Remember the default requested state so the engine doesn't get blamed for planning the wrong thing if the BA changes it.
-    hr = PlanDefaultPackageRequestState(pPackage->type, pPackage->currentState, !pPackage->fUninstallable, pPackage->cacheType, pPlan->action, fInstallCondition, relationType, &pPackage->defaultRequested);
+    hr = PlanDefaultPackageRequestState(pPackage->type, pPackage->currentState, !pPackage->fUninstallable, pPlan->action, installCondition, relationType, &pPackage->defaultRequested);
     ExitOnFailure(hr, "Failed to set default package state.");
 
     pPackage->requested = pPackage->defaultRequested;
     fBeginCalled = TRUE;
 
-    hr = UserExperienceOnPlanPackageBegin(pUX, pPackage->sczId, pPackage->currentState, fInstallCondition, &pPackage->requested);
+    hr = UserExperienceOnPlanPackageBegin(pUX, pPackage->sczId, pPackage->currentState, pPackage->fCached, installCondition, &pPackage->requested, &pPackage->cacheType);
     ExitOnRootFailure(hr, "BA aborted plan package begin.");
 
     if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
@@ -926,8 +918,11 @@ static HRESULT ProcessPackage(
 
     if (BOOTSTRAPPER_ACTION_LAYOUT == pPlan->action)
     {
-        hr = PlanLayoutPackage(pPlan, pPackage);
-        ExitOnFailure(hr, "Failed to plan layout package.");
+        if (BOOTSTRAPPER_REQUEST_STATE_NONE != pPackage->requested)
+        {
+            hr = PlanLayoutPackage(pPlan, pPackage);
+            ExitOnFailure(hr, "Failed to plan layout package.");
+        }
     }
     else
     {
@@ -939,6 +934,17 @@ static HRESULT ProcessPackage(
         }
         else
         {
+            if (ForceCache(pPlan, pPackage))
+            {
+                hr = AddCachePackage(pPlan, pPackage, phSyncpointEvent);
+                ExitOnFailure(hr, "Failed to plan cache package.");
+
+                if (pPackage->fPerMachine)
+                {
+                    pPlan->fPerMachine = TRUE;
+                }
+            }
+
             // Make sure the package is properly ref-counted even if no plan is requested.
             hr = PlanDependencyActions(fBundlePerMachine, pPlan, pPackage);
             ExitOnFailure(hr, "Failed to plan dependency actions for package: %ls", pPackage->sczId);
@@ -1072,8 +1078,7 @@ extern "C" HRESULT PlanExecutePackage(
     )
 {
     HRESULT hr = S_OK;
-    BOOL fRequestedCache = BOOTSTRAPPER_REQUEST_STATE_CACHE == pPackage->requested ||
-                           BOOTSTRAPPER_REQUEST_STATE_ABSENT < pPackage->requested && BURN_CACHE_TYPE_ALWAYS == pPackage->cacheType;
+    BOOL fRequestedCache = BOOTSTRAPPER_REQUEST_STATE_CACHE == pPackage->requested || ForceCache(pPlan, pPackage);
 
     hr = CalculateExecuteActions(pPackage, pPlan->pActiveRollbackBoundary);
     ExitOnFailure(hr, "Failed to calculate plan actions for package: %ls", pPackage->sczId);
@@ -1097,12 +1102,12 @@ extern "C" HRESULT PlanExecutePackage(
 
     // Add the cache and install size to estimated size if it will be on the machine at the end of the install
     if (BOOTSTRAPPER_REQUEST_STATE_PRESENT == pPackage->requested ||
-        BOOTSTRAPPER_REQUEST_STATE_CACHE == pPackage->requested ||
+        fRequestedCache ||
         (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == pPackage->currentState && BOOTSTRAPPER_REQUEST_STATE_ABSENT < pPackage->requested)
        )
     {
         // If the package will remain in the cache, add the package size to the estimated size
-        if (BURN_CACHE_TYPE_NO < pPackage->cacheType)
+        if (BOOTSTRAPPER_CACHE_TYPE_REMOVE < pPackage->cacheType)
         {
             pPlan->qwEstimatedSize += pPackage->qwSize;
         }
@@ -1522,12 +1527,12 @@ extern "C" HRESULT PlanCleanPackage(
     BURN_CLEAN_ACTION* pCleanAction = NULL;
 
     // The following is a complex set of logic that determines when a package should be cleaned from the cache.
-    if (BURN_CACHE_TYPE_ALWAYS > pPackage->cacheType || BOOTSTRAPPER_ACTION_CACHE > pPlan->action)
+    if (BOOTSTRAPPER_CACHE_TYPE_FORCE > pPackage->cacheType || BOOTSTRAPPER_ACTION_CACHE > pPlan->action)
     {
         // The following are all different reasons why the package should be cleaned from the cache.
         // The else-ifs are used to make the conditions easier to see (rather than have them combined
         // in one huge condition).
-        if (BURN_CACHE_TYPE_YES > pPackage->cacheType)  // easy, package is not supposed to stay cached.
+        if (BOOTSTRAPPER_CACHE_TYPE_KEEP > pPackage->cacheType)  // easy, package is not supposed to stay cached.
         {
             fPlanCleanPackage = TRUE;
         }
@@ -1867,6 +1872,7 @@ static void ResetPlannedPackageState(
     )
 {
     // Reset package state that is a result of planning.
+    pPackage->cacheType = pPackage->authoredCacheType;
     pPackage->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
     pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
     pPackage->fPlannedCache = FALSE;
@@ -1948,10 +1954,6 @@ static HRESULT GetActionDefaultRequestState(
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
             break;
 
-        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
-            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
-            break;
-
         default:
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
             break;
@@ -1979,10 +1981,6 @@ static HRESULT GetActionDefaultRequestState(
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
             break;
 
-        case BOOTSTRAPPER_PACKAGE_STATE_CACHED:
-            *pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
-            break;
-
         case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
             *pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
             break;
@@ -2524,6 +2522,15 @@ static BOOL NeedsCache(
     }
 }
 
+static BOOL ForceCache(
+    __in BURN_PLAN* pPlan,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    // All packages that have cacheType set to force should be cached if the bundle is going to be present.
+    return BOOTSTRAPPER_CACHE_TYPE_FORCE == pPackage->cacheType && BOOTSTRAPPER_ACTION_UNINSTALL < pPlan->action;
+}
+
 static void CacheActionLog(
     __in DWORD iAction,
     __in BURN_CACHE_ACTION* pAction,