DownloadManager : Create transient downloads

content/browser/download/download_request_core.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.
 
 #include "content/browser/download/download_request_core.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 44 matching lines @@
   static void Attach(net::URLRequest* request,
                      DownloadUrlParameters* download_parameters,
                      uint32_t download_id);
   static DownloadRequestData* Get(net::URLRequest* request);
   static void Detach(net::URLRequest* request);
 
   std::unique_ptr<DownloadSaveInfo> TakeSaveInfo() {
     return std::move(save_info_);
   }
   uint32_t download_id() const { return download_id_; }
+  bool is_transient() const { return transient_; }
   const DownloadUrlParameters::OnStartedCallback& callback() const {
     return on_started_callback_;
   }
 
  private:
   static const int kKey;
 
   std::unique_ptr<DownloadSaveInfo> save_info_;
   uint32_t download_id_ = DownloadItem::kInvalidId;
+  bool transient_ = false;
   DownloadUrlParameters::OnStartedCallback on_started_callback_;
 };
 
 // static
 const int DownloadRequestData::kKey = 0;
 
 // static
 void DownloadRequestData::Attach(net::URLRequest* request,
                                  DownloadUrlParameters* parameters,
                                  uint32_t download_id) {
   DownloadRequestData* request_data = new DownloadRequestData;
   request_data->save_info_.reset(
       new DownloadSaveInfo(parameters->GetSaveInfo()));
   request_data->download_id_ = download_id;
+  request_data->transient_ = parameters->is_transient();
   request_data->on_started_callback_ = parameters->callback();
   request->SetUserData(&kKey, request_data);
 }
 
 // static
 DownloadRequestData* DownloadRequestData::Get(net::URLRequest* request) {
   return static_cast<DownloadRequestData*>(request->GetUserData(&kKey));
 }
 
 // static
@@ skipping 94 matching lines @@
   RecordDownloadCount(UNTHROTTLED_COUNT);
   power_save_blocker_.reset(new device::PowerSaveBlocker(
       device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
       device::PowerSaveBlocker::kReasonOther, "Download in progress",
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
   DownloadRequestData* request_data = DownloadRequestData::Get(request_);
   if (request_data) {
     save_info_ = request_data->TakeSaveInfo();
     download_id_ = request_data->download_id();
+    transient_ = request_data->is_transient();
     on_started_callback_ = request_data->callback();
     DownloadRequestData::Detach(request_);
     is_partial_request_ = save_info_->offset > 0;
   } else {
     save_info_.reset(new DownloadSaveInfo);
   }
 }
 
 DownloadRequestCore::~DownloadRequestCore() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Remove output stream callback if a stream exists.
   if (stream_writer_)
     stream_writer_->RegisterCallback(base::Closure());
 }
 
 std::unique_ptr<DownloadCreateInfo>
 DownloadRequestCore::CreateDownloadCreateInfo(DownloadInterruptReason result) {
   DCHECK(!started_);
   started_ = true;
   std::unique_ptr<DownloadCreateInfo> create_info(new DownloadCreateInfo(
       base::Time::Now(), request()->net_log(), std::move(save_info_)));
 
   if (result == DOWNLOAD_INTERRUPT_REASON_NONE)
     create_info->remote_address = request()->GetSocketAddress().host();
   create_info->connection_info = request()->response_info().connection_info;
   create_info->url_chain = request()->url_chain();
   create_info->referrer_url = GURL(request()->referrer());
   create_info->result = result;
   create_info->download_id = download_id_;
+  create_info->transient = transient_;
   create_info->offset = create_info->save_info->offset;
   create_info->length = create_info->save_info->length;
   return create_info;
 }
 
 bool DownloadRequestCore::OnResponseStarted(
     const std::string& override_mime_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(20) << __func__ << "() " << DebugString();
   download_start_time_ = base::TimeTicks::Now();
@@ skipping 429 matching lines @@
   // old servers that didn't implement "If-Match" and must be ignored when
   // "If-Match" presents.
   if (has_last_modified) {
     request->SetExtraRequestHeaderByName(
         net::HttpRequestHeaders::kIfUnmodifiedSince, params->last_modified(),
         true);
   }
 }
 
 }  // namespace content