Adding a DownloadRestrictions group policy.

content/browser/download/download_item_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 614 matching lines @@
 std::string DownloadItemImpl::GetOriginalMimeType() const {
   return original_mime_type_;
 }
 
 std::string DownloadItemImpl::GetRemoteAddress() const {
   return remote_address_;
 }
 
 bool DownloadItemImpl::HasUserGesture() const {
   return has_user_gesture_;
-};
+}
 
 ui::PageTransition DownloadItemImpl::GetTransitionType() const {
   return transition_type_;
-};
+}
 
 const std::string& DownloadItemImpl::GetLastModifiedTime() const {
   return last_modified_time_;
 }
 
 const std::string& DownloadItemImpl::GetETag() const {
   return etag_;
 }
 
 bool DownloadItemImpl::IsSavePackageDownload() const {
@@ skipping 169 matching lines @@
 WebContents* DownloadItemImpl::GetWebContents() const {
   // TODO(rdsmith): Remove null check after removing GetWebContents() from
   // paths that might be used by DownloadItems created from history import.
   // Currently such items have null request_handle_s, where other items
   // (regular and SavePackage downloads) have actual objects off the pointer.
   if (job_)
     return job_->GetWebContents();
   return nullptr;
 }
 
-void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type) {
+void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type,
+                                               DownloadInterruptReason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(AllDataSaved());
 
   // Danger type is only allowed to be set on an active download after all data
   // has been saved. This excludes all other states. In particular,
   // OnContentCheckCompleted() isn't allowed on an INTERRUPTED download since
   // such an interruption would need to happen between OnAllDataSaved() and
   // OnContentCheckCompleted() during which no disk or network activity
   // should've taken place.
   DCHECK_EQ(state_, IN_PROGRESS_INTERNAL);
   DVLOG(20) << __func__ << "() danger_type=" << danger_type
             << " download=" << DebugString(true);
   SetDangerType(danger_type);
+  if (reason != DOWNLOAD_INTERRUPT_REASON_NONE)
+    InterruptAndDiscardPartialState(reason);

[asanka, 2017/06/06 03:00:36]

The only interrupt reasons that make sense here are those that result in a
ResumeMode of INVALID. Otherwise the download may resume automatically or wiggle
out of its interrupted state. The INVALID resume mode is also important because
it causes the partial state to be discarded.

Perhaps consider restricting the interrupt reason at this point to BLOCKED or
maybe just have a boolean or enum parameter indicating that the download should
be blocked.

[MAD, 2017/06/06 18:00:28]

Héhé... Interestingly, I initially had a bool and you suggested changing it to
specify the reason... :-D

I could also change the if to only interrupt the download when the value is
blocked, and keep it open for other interruptions in the future?

Though I don't mind bringing back the bool. :-)

[asanka, 2017/06/06 18:34:18]

LOL. Apologies for the runaround :). I'll defer to the current owners in that
case. The API probably looked too custom made for this use case. I'm tempted to
say we should fold the "BLOCKED" state into a danger type, but that'll make it
difficult to note *why* the download was blocked later.

[MAD, 2017/06/12 17:38:15]

OK, thanks, I'll wait to see if the OWNERs prefer to change it to a boolean, or
restrict the interrupt reasons that can cause an interruption here.

[David Trainor- moved to gerrit, 2017/06/12 19:09:04]

I'm ok leaving the interrupt reason here.  Could we just DCHECK the expected
ResumeMode() after this call?

[MAD, 2017/06/12 19:45:13]

Done.

   UpdateObservers();
 }
 
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
 
 void DownloadItemImpl::SetOpened(bool opened) {
   opened_ = opened;
 }
@@ skipping 75 matching lines @@
   // We also can't continue if we don't have some verifier to make sure
   // we're getting the same file.
   bool restart_required =
       (current_path_.empty() || (etag_.empty() && last_modified_time_.empty()));
 
   // We won't auto-restart if we've used up our attempts or the
   // download has been paused by user action.
   bool user_action_required =
       (auto_resume_count_ >= kMaxAutoResumeAttempts || IsPaused());
 
-  switch(last_reason_) {
+  switch (last_reason_) {
     case DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_CONTENT_LENGTH_MISMATCH:
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE:
     // The server disagreed with the file offset that we sent.
 
     case DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH:
     // The file on disk was found to not match the expected hash. Discard and
@@ skipping 1337 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content