Add token field to ClientSafeBrowsingReportReqeust

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 88 matching lines @@
   return base::FeatureList::IsEnabled(features::kDownloadResumption);
 }
 
 }  // namespace
 
 const uint32_t DownloadItem::kInvalidId = 0;
 
 // The maximum number of attempts we will make to resume automatically.
 const int DownloadItemImpl::kMaxAutoResumeAttempts = 5;
 
+// The default token string for downloads with dangerous URLs.
+const char kDangerousDownloadUrlToken[] = "DANGEROUS_URL";
+
 // Constructor for reading from the history service.
 DownloadItemImpl::DownloadItemImpl(DownloadItemImplDelegate* delegate,
                                    const std::string& guid,
                                    uint32_t download_id,
                                    const base::FilePath& current_path,
                                    const base::FilePath& target_path,
                                    const std::vector<GURL>& url_chain,
                                    const GURL& referrer_url,
                                    const GURL& site_url,
                                    const GURL& tab_url,
@@ skipping 625 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 (request_handle_)
     return request_handle_->GetWebContents();
   return NULL;
 }
 
-void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type) {
+void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type,
+                                               const std::string& token) {
   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) << __FUNCTION__ << " danger_type=" << danger_type
             << " download=" << DebugString(true);
   SetDangerType(danger_type);
+  token_.assign(token);
   UpdateObservers();
 }
 
 void DownloadItemImpl::SetOpenWhenComplete(bool open) {
   open_when_complete_ = open;
 }
 
 void DownloadItemImpl::SetIsTemporary(bool temporary) {
   is_temporary_ = temporary;
 }
 
 void DownloadItemImpl::SetOpened(bool opened) {
   opened_ = opened;
 }
 
 void DownloadItemImpl::SetDisplayName(const base::FilePath& name) {
   display_name_ = name;
 }
 
+std::string DownloadItemImpl::GetDownloadPingToken() const {
+  return token_;
+}
+
 std::string DownloadItemImpl::DebugString(bool verbose) const {
   std::string description =
       base::StringPrintf("{ id = %d"
                          " state = %s",
                          download_id_,
                          DebugDownloadStateString(state_));
 
   // Construct a string of the URL chain.
   std::string url_list("<none>");
   if (!url_chain_.empty()) {
@@ skipping 474 matching lines @@
     return;
   }
 
   DVLOG(20) << __FUNCTION__ << "() target_path:" << target_path.value()
             << " disposition:" << disposition << " danger_type:" << danger_type
             << " this:" << DebugString(true);
 
   target_path_ = target_path;
   target_disposition_ = disposition;
   SetDangerType(danger_type);
+  if (danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_URL)
+    token_.assign(kDangerousDownloadUrlToken);
 
   // This was an interrupted download that was looking for a filename. Now that
   // it has one, transition to interrupted.
   if (state_ == INTERRUPTED_TARGET_PENDING_INTERNAL) {
     InterruptWithPartialState(
         received_bytes_, std::move(hash_state_), destination_error_);
     destination_error_ = DOWNLOAD_INTERRUPT_REASON_NONE;
     UpdateObservers();
     return;
   }
@@ skipping 818 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