diff --git a/update_manager/chromeos_policy.cc b/update_manager/chromeos_policy.cc
index c2026b2..0284c22 100644
--- a/update_manager/chromeos_policy.cc
+++ b/update_manager/chromeos_policy.cc
@@ -275,9 +275,11 @@
   // that preemptive returns, such as the case where an update check is due,
   // should not clear off the said values; rather, it is the deliberate
   // inference of new values that should cause them to be reset.
-  result->update_can_start = true;
+  result->update_can_start = false;
   result->cannot_start_reason = UpdateCannotStartReason::kUndefined;
   result->download_url_idx = -1;
+  result->download_url_allowed = true;
+  result->download_url_num_errors = 0;
   result->p2p_downloading_allowed = false;
   result->p2p_sharing_allowed = false;
   result->do_increment_failures = false;
@@ -290,12 +292,8 @@
   EvalStatus check_status = UpdateCheckAllowed(ec, state, error, &check_result);
   if (check_status == EvalStatus::kFailed)
     return EvalStatus::kFailed;
-  if (check_status == EvalStatus::kSucceeded &&
-      check_result.updates_enabled == true) {
-    result->update_can_start = false;
-    result->cannot_start_reason = UpdateCannotStartReason::kCheckDue;
-    return EvalStatus::kSucceeded;
-  }
+  bool is_check_due = (check_status == EvalStatus::kSucceeded &&
+                       check_result.updates_enabled == true);
 
   // Check whether backoff applies, and if not then which URL can be used for
   // downloading. These require scanning the download error log, and so they are
@@ -303,22 +301,19 @@
   UpdateBackoffAndDownloadUrlResult backoff_url_result;
   EvalStatus backoff_url_status = UpdateBackoffAndDownloadUrl(
       ec, state, error, &backoff_url_result, update_state);
-  if (backoff_url_status != EvalStatus::kFailed) {
-    result->download_url_idx = backoff_url_result.url_idx;
-    result->download_url_num_errors = backoff_url_result.url_num_errors;
-    result->do_increment_failures = backoff_url_result.do_increment_failures;
-    result->backoff_expiry = backoff_url_result.backoff_expiry;
-  }
-  if (backoff_url_status != EvalStatus::kSucceeded ||
-      !backoff_url_result.backoff_expiry.is_null()) {
-    if (backoff_url_status != EvalStatus::kFailed) {
-      result->update_can_start = false;
-      result->cannot_start_reason = UpdateCannotStartReason::kBackoff;
-    }
-    return backoff_url_status;
-  }
+  if (backoff_url_status == EvalStatus::kFailed)
+    return EvalStatus::kFailed;
+  result->download_url_idx = backoff_url_result.url_idx;
+  result->download_url_num_errors = backoff_url_result.url_num_errors;
+  result->do_increment_failures = backoff_url_result.do_increment_failures;
+  result->backoff_expiry = backoff_url_result.backoff_expiry;
+  bool is_backoff_active =
+      (backoff_url_status == EvalStatus::kAskMeAgainLater) ||
+      !backoff_url_result.backoff_expiry.is_null();
 
   DevicePolicyProvider* const dp_provider = state->device_policy_provider();
+  bool is_scattering_active = false;
+  EvalStatus scattering_status = EvalStatus::kSucceeded;
 
   const bool* device_policy_is_loaded_p = ec->GetValue(
       dp_provider->var_device_policy_is_loaded());
@@ -331,35 +326,34 @@
     // attribute is found in the Omaha response. However, it appears that the
     // presence of this attribute is merely indicative of an OOBE update, during
     // which we suppress scattering anyway.
-    bool scattering_applies = false;
+    bool is_scattering_applicable = false;
     result->scatter_wait_period = kZeroInterval;
     result->scatter_check_threshold = 0;
     if (!update_state.is_interactive) {
       const bool* is_oobe_enabled_p = ec->GetValue(
           state->config_provider()->var_is_oobe_enabled());
       if (is_oobe_enabled_p && !(*is_oobe_enabled_p)) {
-        scattering_applies = true;
+        is_scattering_applicable = true;
       } else {
         const bool* is_oobe_complete_p = ec->GetValue(
             state->system_provider()->var_is_oobe_complete());
-        scattering_applies = (is_oobe_complete_p && *is_oobe_complete_p);
+        is_scattering_applicable = (is_oobe_complete_p && *is_oobe_complete_p);
       }
     }
 
     // Compute scattering values.
-    if (scattering_applies) {
+    if (is_scattering_applicable) {
       UpdateScatteringResult scatter_result;
-      EvalStatus scattering_status = UpdateScattering(
-          ec, state, error, &scatter_result, update_state);
-      if (scattering_status != EvalStatus::kSucceeded ||
-          scatter_result.is_scattering) {
-        if (scattering_status != EvalStatus::kFailed) {
-          result->update_can_start = false;
-          result->cannot_start_reason = UpdateCannotStartReason::kScattering;
-          result->scatter_wait_period = scatter_result.wait_period;
-          result->scatter_check_threshold = scatter_result.check_threshold;
-        }
-        return scattering_status;
+      scattering_status = UpdateScattering(ec, state, error, &scatter_result,
+                                           update_state);
+      if (scattering_status == EvalStatus::kFailed) {
+        return EvalStatus::kFailed;
+      } else {
+        result->scatter_wait_period = scatter_result.wait_period;
+        result->scatter_check_threshold = scatter_result.check_threshold;
+        if (scattering_status == EvalStatus::kAskMeAgainLater ||
+            scatter_result.is_scattering)
+          is_scattering_active = true;
       }
     }
 
@@ -399,18 +393,36 @@
                    TimeDelta::FromSeconds(kMaxP2PAttemptsPeriodInSeconds))) {
       LOG(INFO) << "Blocked P2P download as its usage timespan exceeds limit.";
     } else {
+      // P2P download is allowed; if backoff or scattering are active, be sure
+      // to suppress them, yet prevent any download URL from being used.
       result->p2p_downloading_allowed = true;
+      if (is_backoff_active || is_scattering_active) {
+        is_backoff_active = is_scattering_active = false;
+        result->download_url_allowed = false;
+      }
     }
   }
 
-  // Store the download URL and failure increment flag. Note that no URL will
-  // only terminate evaluation if no other means of download (such as P2P) are
-  // enabled.
+  // Check for various deterrents.
+  if (is_check_due) {
+    result->cannot_start_reason = UpdateCannotStartReason::kCheckDue;
+    return EvalStatus::kSucceeded;
+  }
+  if (is_backoff_active) {
+    result->cannot_start_reason = UpdateCannotStartReason::kBackoff;
+    return backoff_url_status;
+  }
+  if (is_scattering_active) {
+    result->cannot_start_reason = UpdateCannotStartReason::kScattering;
+    return scattering_status;
+  }
   if (result->download_url_idx < 0 && !result->p2p_downloading_allowed) {
-    result->update_can_start = false;
     result->cannot_start_reason = UpdateCannotStartReason::kCannotDownload;
+    return EvalStatus::kSucceeded;
   }
 
+  // Update is good to go.
+  result->update_can_start = true;
   return EvalStatus::kSucceeded;
 }
 
diff --git a/update_manager/chromeos_policy_unittest.cc b/update_manager/chromeos_policy_unittest.cc
index 443a298..e5d6749 100644
--- a/update_manager/chromeos_policy_unittest.cc
+++ b/update_manager/chromeos_policy_unittest.cc
@@ -468,7 +468,7 @@
 
 TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
   // The UpdateCanStart policy returns false because we are due for another
-  // update check.
+  // update check. Ensure that download related values are still returned.
 
   SetUpdateCheckAllowed(true);
 
@@ -479,6 +479,8 @@
                      &Policy::UpdateCanStart, &result, update_state);
   EXPECT_FALSE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
+  EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_EQ(0, result.download_url_num_errors);
 }
 
 TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
@@ -497,6 +499,7 @@
   EXPECT_FALSE(result.p2p_downloading_allowed);
   EXPECT_FALSE(result.p2p_sharing_allowed);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -516,6 +519,7 @@
   EXPECT_FALSE(result.p2p_downloading_allowed);
   EXPECT_FALSE(result.p2p_sharing_allowed);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -604,6 +608,7 @@
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
   EXPECT_EQ(Time(), result.backoff_expiry);
@@ -634,6 +639,7 @@
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_TRUE(result.do_increment_failures);
   EXPECT_EQ(Time(), result.backoff_expiry);
@@ -664,6 +670,7 @@
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_TRUE(result.do_increment_failures);
   EXPECT_EQ(Time(), result.backoff_expiry);
@@ -694,6 +701,7 @@
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_TRUE(result.do_increment_failures);
   EXPECT_EQ(Time(), result.backoff_expiry);
@@ -726,6 +734,7 @@
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_TRUE(result.do_increment_failures);
   EXPECT_EQ(Time(), result.backoff_expiry);
@@ -872,6 +881,7 @@
   EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
   EXPECT_EQ(0, result.scatter_check_threshold);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -900,6 +910,7 @@
   EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
   EXPECT_EQ(0, result.scatter_check_threshold);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -929,6 +940,7 @@
   EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
   EXPECT_EQ(0, result.scatter_check_threshold);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -954,6 +966,7 @@
   EXPECT_TRUE(result.p2p_downloading_allowed);
   EXPECT_TRUE(result.p2p_sharing_allowed);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -977,6 +990,7 @@
   EXPECT_TRUE(result.p2p_downloading_allowed);
   EXPECT_TRUE(result.p2p_sharing_allowed);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1056,6 +1070,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1080,6 +1095,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(1, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1109,6 +1125,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(5, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1137,6 +1154,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(1, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1162,6 +1180,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(1, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1189,6 +1208,7 @@
                      update_state);
   EXPECT_TRUE(result.update_can_start);
   EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_TRUE(result.do_increment_failures);
 }
@@ -1244,6 +1264,7 @@
   EXPECT_TRUE(result.p2p_downloading_allowed);
   EXPECT_TRUE(result.p2p_sharing_allowed);
   EXPECT_GT(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1275,6 +1296,7 @@
   EXPECT_TRUE(result.p2p_downloading_allowed);
   EXPECT_TRUE(result.p2p_sharing_allowed);
   EXPECT_GT(0, result.download_url_idx);
+  EXPECT_TRUE(result.download_url_allowed);
   EXPECT_EQ(0, result.download_url_num_errors);
   EXPECT_FALSE(result.do_increment_failures);
 }
@@ -1425,4 +1447,64 @@
   EXPECT_TRUE(result);
 }
 
+TEST_F(UmChromeOSPolicyTest,
+       UpdateCanStartAllowedScatteringSupressedDueToP2P) {
+  // The UpdateCanStart policy returns true; scattering should have applied, but
+  // P2P download is allowed. Scattering values are nonetheless returned, and so
+  // are download URL values, albeit the latter are not allowed to be used.
+
+  SetUpdateCheckAllowed(false);
+  fake_state_.device_policy_provider()->var_scatter_factor()->reset(
+      new TimeDelta(TimeDelta::FromMinutes(2)));
+  fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
+
+  UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
+  update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
+
+  UpdateDownloadParams result;
+  ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
+                     &result, update_state);
+  EXPECT_TRUE(result.update_can_start);
+  EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_FALSE(result.download_url_allowed);
+  EXPECT_EQ(0, result.download_url_num_errors);
+  EXPECT_TRUE(result.p2p_downloading_allowed);
+  EXPECT_TRUE(result.p2p_sharing_allowed);
+  EXPECT_FALSE(result.do_increment_failures);
+  EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
+  EXPECT_EQ(0, result.scatter_check_threshold);
+}
+
+TEST_F(UmChromeOSPolicyTest,
+       UpdateCanStartAllowedBackoffSupressedDueToP2P) {
+  // The UpdateCanStart policy returns true; backoff should have applied, but
+  // P2P download is allowed. Backoff values are nonetheless returned, and so
+  // are download URL values, albeit the latter are not allowed to be used.
+
+  SetUpdateCheckAllowed(false);
+
+  const Time curr_time = fake_clock_.GetWallclockTime();
+  UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
+  update_state.download_errors_max = 1;
+  update_state.download_errors.emplace_back(
+      0, ErrorCode::kDownloadTransferError,
+      curr_time - TimeDelta::FromSeconds(8));
+  update_state.download_errors.emplace_back(
+      0, ErrorCode::kDownloadTransferError,
+      curr_time - TimeDelta::FromSeconds(2));
+  fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
+
+  UpdateDownloadParams result;
+  ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
+                     update_state);
+  EXPECT_TRUE(result.update_can_start);
+  EXPECT_EQ(0, result.download_url_idx);
+  EXPECT_FALSE(result.download_url_allowed);
+  EXPECT_EQ(0, result.download_url_num_errors);
+  EXPECT_TRUE(result.p2p_downloading_allowed);
+  EXPECT_TRUE(result.p2p_sharing_allowed);
+  EXPECT_TRUE(result.do_increment_failures);
+  EXPECT_LT(curr_time, result.backoff_expiry);
+}
+
 }  // namespace chromeos_update_manager
diff --git a/update_manager/default_policy.cc b/update_manager/default_policy.cc
index 3de9755..1300e14 100644
--- a/update_manager/default_policy.cc
+++ b/update_manager/default_policy.cc
@@ -50,6 +50,7 @@
   result->update_can_start = true;
   result->cannot_start_reason = UpdateCannotStartReason::kUndefined;
   result->download_url_idx = 0;
+  result->download_url_allowed = true;
   result->download_url_num_errors = 0;
   result->p2p_downloading_allowed = false;
   result->p2p_sharing_allowed = false;
diff --git a/update_manager/policy.h b/update_manager/policy.h
index b801d91..42f4e15 100644
--- a/update_manager/policy.h
+++ b/update_manager/policy.h
@@ -132,15 +132,16 @@
   // If update cannot proceed, a reason code for why it cannot do so.
   UpdateCannotStartReason cannot_start_reason;
 
-  // Attributes pertaining to the case where update is allowed. The update
-  // engine uses them to choose the means for downloading and applying an
-  // update.
+  // Download related attributes. The update engine uses them to choose the
+  // means for downloading and applying an update.
   //
-  // The index of the download URL to use, or -1 if no suitable URL was found;
-  // in the latter case, there may still be other means for download (like P2P).
-  // This value needs to be persisted and handed back to the policy on the next
-  // time it is called.
+  // The index of the download URL to use (-1 means no suitable URL was found)
+  // and whether it can be used. Even if there's no URL or its use is not
+  // allowed (backoff, scattering) there may still be other means for download
+  // (like P2P).  The URL index needs to be persisted and handed back to the
+  // policy on the next time it is called.
   int download_url_idx;
+  bool download_url_allowed;
   // The number of download errors associated with this download URL. This value
   // needs to be persisted and handed back to the policy on the next time it is
   // called.