content/browser/download/download_file_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/download/download_file_impl.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/file_util.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/time/time.h"
  14 #include "content/browser/byte_stream.h"
  15 #include "content/browser/download/download_create_info.h"
  16 #include "content/browser/download/download_interrupt_reasons_impl.h"
  17 #include "content/browser/download/download_net_log_parameters.h"
  18 #include "content/browser/download/download_stats.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "content/public/browser/download_destination_observer.h"
  21 #include "net/base/io_buffer.h"
  22
  23 namespace content {
  24
  25 const int kUpdatePeriodMs = 500;
  26 const int kMaxTimeBlockingFileThreadMs = 1000;
  27
  28 int DownloadFile::number_active_objects_ = 0;
  29
  30 DownloadFileImpl::DownloadFileImpl(
  31     scoped_ptr<DownloadSaveInfo> save_info,
  32     const base::FilePath& default_download_directory,
  33     const GURL& url,
  34     const GURL& referrer_url,
  35     bool calculate_hash,
  36     scoped_ptr<ByteStreamReader> stream,
  37     const net::BoundNetLog& bound_net_log,
  38     base::WeakPtr<DownloadDestinationObserver> observer)
  39         : file_(save_info->file_path,
  40                 url,
  41                 referrer_url,
  42                 save_info->offset,
  43                 calculate_hash,
  44                 save_info->hash_state,
  45                 save_info->file.Pass(),
  46                 bound_net_log),
  47           default_download_directory_(default_download_directory),
  48           stream_reader_(stream.Pass()),
  49           bytes_seen_(0),
  50           bound_net_log_(bound_net_log),
  51           observer_(observer),
  52           weak_factory_(this) {
  53 }
  54
  55 DownloadFileImpl::~DownloadFileImpl() {
  56   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
  57   --number_active_objects_;
  58 }
  59
  60 void DownloadFileImpl::Initialize(const InitializeCallback& callback) {
  61   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
  62
  63   update_timer_.reset(new base::RepeatingTimer<DownloadFileImpl>());
  64   DownloadInterruptReason result =
  65       file_.Initialize(default_download_directory_);
  66   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
  67     BrowserThread::PostTask(
  68         BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
  69     return;
  70   }
  71
  72   stream_reader_->RegisterCallback(
  73       base::Bind(&DownloadFileImpl::StreamActive, weak_factory_.GetWeakPtr()));
  74
  75   download_start_ = base::TimeTicks::Now();
  76
  77   // Primarily to make reset to zero in restart visible to owner.
  78   SendUpdate();
  79
  80   // Initial pull from the straw.
  81   StreamActive();
  82
  83   BrowserThread::PostTask(
  84       BrowserThread::UI, FROM_HERE, base::Bind(
  85           callback, DOWNLOAD_INTERRUPT_REASON_NONE));
  86
  87   ++number_active_objects_;
  88 }
  89
  90 DownloadInterruptReason DownloadFileImpl::AppendDataToFile(
  91     const char* data, size_t data_len) {
  92   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
  93
  94   if (!update_timer_->IsRunning()) {
  95     update_timer_->Start(FROM_HERE,
  96                          base::TimeDelta::FromMilliseconds(kUpdatePeriodMs),
  97                          this, &DownloadFileImpl::SendUpdate);
  98   }
  99   rate_estimator_.Increment(data_len);
 100   return file_.AppendDataToFile(data, data_len);
 101 }
 102
 103 void DownloadFileImpl::RenameAndUniquify(
 104     const base::FilePath& full_path,
 105     const RenameCompletionCallback& callback) {
 106   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 107
 108   base::FilePath new_path(full_path);
 109
 110   int uniquifier = base::GetUniquePathNumber(
 111       new_path, base::FilePath::StringType());
 112   if (uniquifier > 0) {
 113     new_path = new_path.InsertBeforeExtensionASCII(
 114         base::StringPrintf(" (%d)", uniquifier));
 115   }
 116
 117   DownloadInterruptReason reason = file_.Rename(new_path);
 118   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
 119     // Make sure our information is updated, since we're about to
 120     // error out.
 121     SendUpdate();
 122
 123     // Null out callback so that we don't do any more stream processing.
 124     stream_reader_->RegisterCallback(base::Closure());
 125
 126     new_path.clear();
 127   }
 128
 129   BrowserThread::PostTask(
 130       BrowserThread::UI, FROM_HERE,
 131       base::Bind(callback, reason, new_path));
 132 }
 133
 134 void DownloadFileImpl::RenameAndAnnotate(
 135     const base::FilePath& full_path,
 136     const RenameCompletionCallback& callback) {
 137   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 138
 139   base::FilePath new_path(full_path);
 140
 141   DownloadInterruptReason reason = DOWNLOAD_INTERRUPT_REASON_NONE;
 142   // Short circuit null rename.
 143   if (full_path != file_.full_path())
 144     reason = file_.Rename(new_path);
 145
 146   if (reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
 147     // Doing the annotation after the rename rather than before leaves
 148     // a very small window during which the file has the final name but
 149     // hasn't been marked with the Mark Of The Web.  However, it allows
 150     // anti-virus scanners on Windows to actually see the data
 151     // (http://crbug.com/127999) under the correct name (which is information
 152     // it uses).
 153     reason = file_.AnnotateWithSourceInformation();
 154   }
 155
 156   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
 157     // Make sure our information is updated, since we're about to
 158     // error out.
 159     SendUpdate();
 160
 161     // Null out callback so that we don't do any more stream processing.
 162     stream_reader_->RegisterCallback(base::Closure());
 163
 164     new_path.clear();
 165   }
 166
 167   BrowserThread::PostTask(
 168       BrowserThread::UI, FROM_HERE,
 169       base::Bind(callback, reason, new_path));
 170 }
 171
 172 void DownloadFileImpl::Detach() {
 173   file_.Detach();
 174 }
 175
 176 void DownloadFileImpl::Cancel() {
 177   file_.Cancel();
 178 }
 179
 180 base::FilePath DownloadFileImpl::FullPath() const {
 181   return file_.full_path();
 182 }
 183
 184 bool DownloadFileImpl::InProgress() const {
 185   return file_.in_progress();
 186 }
 187
 188 int64 DownloadFileImpl::CurrentSpeed() const {
 189   return rate_estimator_.GetCountPerSecond();
 190 }
 191
 192 bool DownloadFileImpl::GetHash(std::string* hash) {
 193   return file_.GetHash(hash);
 194 }
 195
 196 std::string DownloadFileImpl::GetHashState() {
 197   return file_.GetHashState();
 198 }
 199
 200 void DownloadFileImpl::SetClientGuid(const std::string& guid) {
 201   file_.SetClientGuid(guid);
 202 }
 203
 204 void DownloadFileImpl::StreamActive() {
 205   base::TimeTicks start(base::TimeTicks::Now());
 206   base::TimeTicks now;
 207   scoped_refptr<net::IOBuffer> incoming_data;
 208   size_t incoming_data_size = 0;
 209   size_t total_incoming_data_size = 0;
 210   size_t num_buffers = 0;
 211   ByteStreamReader::StreamState state(ByteStreamReader::STREAM_EMPTY);
 212   DownloadInterruptReason reason = DOWNLOAD_INTERRUPT_REASON_NONE;
 213   base::TimeDelta delta(
 214       base::TimeDelta::FromMilliseconds(kMaxTimeBlockingFileThreadMs));
 215
 216   // Take care of any file local activity required.
 217   do {
 218     state = stream_reader_->Read(&incoming_data, &incoming_data_size);
 219
 220     switch (state) {
 221       case ByteStreamReader::STREAM_EMPTY:
 222         break;
 223       case ByteStreamReader::STREAM_HAS_DATA:
 224         {
 225           ++num_buffers;
 226           base::TimeTicks write_start(base::TimeTicks::Now());
 227           reason = AppendDataToFile(
 228               incoming_data.get()->data(), incoming_data_size);
 229           disk_writes_time_ += (base::TimeTicks::Now() - write_start);
 230           bytes_seen_ += incoming_data_size;
 231           total_incoming_data_size += incoming_data_size;
 232         }
 233         break;
 234       case ByteStreamReader::STREAM_COMPLETE:
 235         {
 236           reason = static_cast<DownloadInterruptReason>(
 237               stream_reader_->GetStatus());
 238           SendUpdate();
 239           base::TimeTicks close_start(base::TimeTicks::Now());
 240           file_.Finish();
 241           base::TimeTicks now(base::TimeTicks::Now());
 242           disk_writes_time_ += (now - close_start);
 243           RecordFileBandwidth(
 244               bytes_seen_, disk_writes_time_, now - download_start_);
 245           update_timer_.reset();
 246         }
 247         break;
 248       default:
 249         NOTREACHED();
 250         break;
 251     }
 252     now = base::TimeTicks::Now();
 253   } while (state == ByteStreamReader::STREAM_HAS_DATA &&
 254            reason == DOWNLOAD_INTERRUPT_REASON_NONE &&
 255            now - start <= delta);
 256
 257   // If we're stopping to yield the thread, post a task so we come back.
 258   if (state == ByteStreamReader::STREAM_HAS_DATA &&
 259       now - start > delta) {
 260     BrowserThread::PostTask(
 261         BrowserThread::FILE, FROM_HERE,
 262         base::Bind(&DownloadFileImpl::StreamActive,
 263                    weak_factory_.GetWeakPtr()));
 264   }
 265
 266   if (total_incoming_data_size)
 267     RecordFileThreadReceiveBuffers(num_buffers);
 268
 269   RecordContiguousWriteTime(now - start);
 270
 271   // Take care of communication with our observer.
 272   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
 273     // Error case for both upstream source and file write.
 274     // Shut down processing and signal an error to our observer.
 275     // Our observer will clean us up.
 276     stream_reader_->RegisterCallback(base::Closure());
 277     weak_factory_.InvalidateWeakPtrs();
 278     SendUpdate();                       // Make info up to date before error.
 279     BrowserThread::PostTask(
 280         BrowserThread::UI, FROM_HERE,
 281         base::Bind(&DownloadDestinationObserver::DestinationError,
 282                    observer_, reason));
 283   } else if (state == ByteStreamReader::STREAM_COMPLETE) {
 284     // Signal successful completion and shut down processing.
 285     stream_reader_->RegisterCallback(base::Closure());
 286     weak_factory_.InvalidateWeakPtrs();
 287     std::string hash;
 288     if (!GetHash(&hash) || file_.IsEmptyHash(hash))
 289       hash.clear();
 290     SendUpdate();
 291     BrowserThread::PostTask(
 292         BrowserThread::UI, FROM_HERE,
 293         base::Bind(
 294             &DownloadDestinationObserver::DestinationCompleted,
 295             observer_, hash));
 296   }
 297   if (bound_net_log_.IsLogging()) {
 298     bound_net_log_.AddEvent(
 299         net::NetLog::TYPE_DOWNLOAD_STREAM_DRAINED,
 300         base::Bind(&FileStreamDrainedNetLogCallback, total_incoming_data_size,
 301                    num_buffers));
 302   }
 303 }
 304
 305 void DownloadFileImpl::SendUpdate() {
 306   BrowserThread::PostTask(
 307       BrowserThread::UI, FROM_HERE,
 308       base::Bind(&DownloadDestinationObserver::DestinationUpdate,
 309                  observer_, file_.bytes_so_far(), CurrentSpeed(),
 310                  GetHashState()));
 311 }
 312
 313 // static
 314 int DownloadFile::GetNumberOfDownloadFiles() {
 315   return number_active_objects_;
 316 }
 317
 318 }  // namespace content