| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2011 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 // Each download is represented by a DownloadItem, and all DownloadItems | |
| 6 // are owned by the DownloadManager which maintains a global list of all | |
| 7 // downloads. DownloadItems are created when a user initiates a download, | |
| 8 // and exist for the duration of the browser life time. | |
| 9 // | |
| 10 // Download observers: | |
| 11 // DownloadItem::Observer: | |
| 12 // - allows observers to receive notifications about one download from start | |
| 13 // to completion | |
| 14 // Use AddObserver() / RemoveObserver() on the appropriate download object to | |
| 15 // receive state updates. | |
| 16 | |
| 17 #ifndef CHROME_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_ | |
| 18 #define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_ | |
| 19 #pragma once | |
| 20 | |
| 21 #include <string> | |
| 22 | |
| 23 #include "base/basictypes.h" | |
| 24 #include "base/file_path.h" | |
| 25 #include "base/observer_list.h" | |
| 26 #include "base/time.h" | |
| 27 #include "base/timer.h" | |
| 28 #include "chrome/browser/download/download_request_handle.h" | |
| 29 #include "chrome/browser/download/download_state_info.h" | |
| 30 #include "content/common/notification_observer.h" | |
| 31 #include "content/common/notification_registrar.h" | |
| 32 #include "googleurl/src/gurl.h" | |
| 33 | |
| 34 class CrxInstaller; | |
| 35 class DownloadFileManager; | |
| 36 class DownloadManager; | |
| 37 struct DownloadCreateInfo; | |
| 38 struct DownloadHistoryInfo; | |
| 39 | |
| 40 // One DownloadItem per download. This is the model class that stores all the | |
| 41 // state for a download. Multiple views, such as a tab's download shelf and the | |
| 42 // Destination tab's download view, may refer to a given DownloadItem. | |
| 43 // | |
| 44 // This is intended to be used only on the UI thread. | |
| 45 class DownloadItem : public NotificationObserver { | |
| 46 public: | |
| 47 enum DownloadState { | |
| 48 // Download is actively progressing. | |
| 49 IN_PROGRESS = 0, | |
| 50 | |
| 51 // Download is completely finished. | |
| 52 COMPLETE, | |
| 53 | |
| 54 // Download has been cancelled. | |
| 55 CANCELLED, | |
| 56 | |
| 57 // This state indicates that the download item is about to be destroyed, | |
| 58 // and observers seeing this state should release all references. | |
| 59 REMOVING, | |
| 60 | |
| 61 // This state indicates that the download has been interrupted. | |
| 62 INTERRUPTED, | |
| 63 | |
| 64 // Maximum value. | |
| 65 MAX_DOWNLOAD_STATE | |
| 66 }; | |
| 67 | |
| 68 enum SafetyState { | |
| 69 SAFE = 0, | |
| 70 DANGEROUS, | |
| 71 DANGEROUS_BUT_VALIDATED // Dangerous but the user confirmed the download. | |
| 72 }; | |
| 73 | |
| 74 // This enum is used by histograms. Do not change the ordering or remove | |
| 75 // items. | |
| 76 enum DangerType { | |
| 77 NOT_DANGEROUS = 0, | |
| 78 | |
| 79 // A dangerous file to the system (e.g.: an executable or extension from | |
| 80 // places other than gallery). | |
| 81 DANGEROUS_FILE, | |
| 82 | |
| 83 // Safebrowsing service shows this URL leads to malicious file download. | |
| 84 DANGEROUS_URL, | |
| 85 | |
| 86 // Memory space for histograms is determined by the max. | |
| 87 // ALWAYS ADD NEW VALUES BEFORE THIS ONE. | |
| 88 DANGEROUS_TYPE_MAX | |
| 89 }; | |
| 90 | |
| 91 // Reason for deleting the download. Passed to Delete(). | |
| 92 enum DeleteReason { | |
| 93 DELETE_DUE_TO_BROWSER_SHUTDOWN = 0, | |
| 94 DELETE_DUE_TO_USER_DISCARD | |
| 95 }; | |
| 96 | |
| 97 // Interface that observers of a particular download must implement in order | |
| 98 // to receive updates to the download's status. | |
| 99 class Observer { | |
| 100 public: | |
| 101 virtual void OnDownloadUpdated(DownloadItem* download) = 0; | |
| 102 | |
| 103 // Called when a downloaded file has been opened. | |
| 104 virtual void OnDownloadOpened(DownloadItem* download) = 0; | |
| 105 | |
| 106 protected: | |
| 107 virtual ~Observer() {} | |
| 108 }; | |
| 109 | |
| 110 // Constructing from persistent store: | |
| 111 DownloadItem(DownloadManager* download_manager, | |
| 112 const DownloadHistoryInfo& info); | |
| 113 | |
| 114 // Constructing for a regular download: | |
| 115 DownloadItem(DownloadManager* download_manager, | |
| 116 const DownloadCreateInfo& info, | |
| 117 bool is_otr); | |
| 118 | |
| 119 // Constructing for the "Save Page As..." feature: | |
| 120 DownloadItem(DownloadManager* download_manager, | |
| 121 const FilePath& path, | |
| 122 const GURL& url, | |
| 123 bool is_otr); | |
| 124 | |
| 125 virtual ~DownloadItem(); | |
| 126 | |
| 127 void AddObserver(Observer* observer); | |
| 128 void RemoveObserver(Observer* observer); | |
| 129 | |
| 130 // Notifies our observers periodically. | |
| 131 void UpdateObservers(); | |
| 132 | |
| 133 // NotificationObserver implementation. | |
| 134 virtual void Observe(int type, | |
| 135 const NotificationSource& source, | |
| 136 const NotificationDetails& details); | |
| 137 | |
| 138 // Returns true if it is OK to open a folder which this file is inside. | |
| 139 bool CanShowInFolder(); | |
| 140 | |
| 141 // Returns true if it is OK to register the type of this file so that | |
| 142 // it opens automatically. | |
| 143 bool CanOpenDownload(); | |
| 144 | |
| 145 // Tests if a file type should be opened automatically. | |
| 146 bool ShouldOpenFileBasedOnExtension(); | |
| 147 | |
| 148 // Registers this file extension for automatic opening upon download | |
| 149 // completion if 'open' is true, or prevents the extension from automatic | |
| 150 // opening if 'open' is false. | |
| 151 void OpenFilesBasedOnExtension(bool open); | |
| 152 | |
| 153 // Open the file associated with this download (wait for the download to | |
| 154 // complete if it is in progress). | |
| 155 void OpenDownload(); | |
| 156 | |
| 157 // Show the download via the OS shell. | |
| 158 void ShowDownloadInShell(); | |
| 159 | |
| 160 // Called when the user has validated the download of a dangerous file. | |
| 161 void DangerousDownloadValidated(); | |
| 162 | |
| 163 // Received a new chunk of data | |
| 164 void Update(int64 bytes_so_far); | |
| 165 | |
| 166 // Cancel the download operation. We need to distinguish between cancels at | |
| 167 // exit (DownloadManager destructor) from user interface initiated cancels | |
| 168 // because at exit, the history system may not exist, and any updates to it | |
| 169 // require AddRef'ing the DownloadManager in the destructor which results in | |
| 170 // a DCHECK failure. Set 'update_history' to false when canceling from at | |
| 171 // exit to prevent this crash. This may result in a difference between the | |
| 172 // downloaded file's size on disk, and what the history system's last record | |
| 173 // of it is. At worst, we'll end up re-downloading a small portion of the file | |
| 174 // when resuming a download (assuming the server supports byte ranges). | |
| 175 void Cancel(bool update_history); | |
| 176 | |
| 177 // Called by external code (SavePackage) using the DownloadItem interface | |
| 178 // to display progress when the DownloadItem should be considered complete. | |
| 179 void MarkAsComplete(); | |
| 180 | |
| 181 // Called when all data has been saved. Only has display effects. | |
| 182 void OnAllDataSaved(int64 size); | |
| 183 | |
| 184 // Called when the downloaded file is removed. | |
| 185 void OnDownloadedFileRemoved(); | |
| 186 | |
| 187 // Download operation had an error. | |
| 188 // |size| is the amount of data received so far, and |os_error| is the error | |
| 189 // code that the operation received. | |
| 190 void Interrupted(int64 size, int os_error); | |
| 191 | |
| 192 // Deletes the file from disk and removes the download from the views and | |
| 193 // history. |user| should be true if this is the result of the user clicking | |
| 194 // the discard button, and false if it is being deleted for other reasons like | |
| 195 // browser shutdown. | |
| 196 void Delete(DeleteReason reason); | |
| 197 | |
| 198 // Removes the download from the views and history. | |
| 199 void Remove(); | |
| 200 | |
| 201 // Simple calculation of the amount of time remaining to completion. Fills | |
| 202 // |*remaining| with the amount of time remaining if successful. Fails and | |
| 203 // returns false if we do not have the number of bytes or the speed so can | |
| 204 // not estimate. | |
| 205 bool TimeRemaining(base::TimeDelta* remaining) const; | |
| 206 | |
| 207 // Simple speed estimate in bytes/s | |
| 208 int64 CurrentSpeed() const; | |
| 209 | |
| 210 // Rough percent complete, -1 means we don't know (since we didn't receive a | |
| 211 // total size). | |
| 212 int PercentComplete() const; | |
| 213 | |
| 214 // Called when the final path has been determined. | |
| 215 void OnPathDetermined(const FilePath& path); | |
| 216 | |
| 217 // Returns true if this download has saved all of its data. | |
| 218 bool all_data_saved() const { return all_data_saved_; } | |
| 219 | |
| 220 // Update the fields that may have changed in DownloadStateInfo as a | |
| 221 // result of analyzing the file and figuring out its type, location, etc. | |
| 222 // May only be called once. | |
| 223 void SetFileCheckResults(const DownloadStateInfo& state); | |
| 224 | |
| 225 // Update the download's path, the actual file is renamed on the download | |
| 226 // thread. | |
| 227 void Rename(const FilePath& full_path); | |
| 228 | |
| 229 // Allow the user to temporarily pause a download or resume a paused download. | |
| 230 void TogglePause(); | |
| 231 | |
| 232 // Called when the download is ready to complete. | |
| 233 // This may perform final rename if necessary and will eventually call | |
| 234 // DownloadItem::Completed(). | |
| 235 void OnDownloadCompleting(DownloadFileManager* file_manager); | |
| 236 | |
| 237 // Called when the file name for the download is renamed to its final name. | |
| 238 void OnDownloadRenamedToFinalName(const FilePath& full_path); | |
| 239 | |
| 240 // Returns true if this item matches |query|. |query| must be lower-cased. | |
| 241 bool MatchesQuery(const string16& query) const; | |
| 242 | |
| 243 // Returns true if the download needs more data. | |
| 244 bool IsPartialDownload() const; | |
| 245 | |
| 246 // Returns true if the download is still receiving data. | |
| 247 bool IsInProgress() const; | |
| 248 | |
| 249 // Returns true if the download has been cancelled or was interrupted. | |
| 250 bool IsCancelled() const; | |
| 251 | |
| 252 // Returns true if the download was interrupted. | |
| 253 bool IsInterrupted() const; | |
| 254 | |
| 255 // Returns true if we have all the data and know the final file name. | |
| 256 bool IsComplete() const; | |
| 257 | |
| 258 // Accessors | |
| 259 DownloadState state() const { return state_; } | |
| 260 const FilePath& full_path() const { return full_path_; } | |
| 261 void set_path_uniquifier(int uniquifier) { | |
| 262 state_info_.path_uniquifier = uniquifier; | |
| 263 } | |
| 264 const GURL& GetURL() const; | |
| 265 | |
| 266 const std::vector<GURL>& url_chain() const { return url_chain_; } | |
| 267 const GURL& original_url() const { return url_chain_.front(); } | |
| 268 const GURL& referrer_url() const { return referrer_url_; } | |
| 269 std::string suggested_filename() const { return suggested_filename_; } | |
| 270 std::string content_disposition() const { return content_disposition_; } | |
| 271 std::string mime_type() const { return mime_type_; } | |
| 272 std::string original_mime_type() const { return original_mime_type_; } | |
| 273 std::string referrer_charset() const { return referrer_charset_; } | |
| 274 int64 total_bytes() const { return total_bytes_; } | |
| 275 void set_total_bytes(int64 total_bytes) { | |
| 276 total_bytes_ = total_bytes; | |
| 277 } | |
| 278 int64 received_bytes() const { return received_bytes_; } | |
| 279 int32 id() const { return download_id_; } | |
| 280 base::Time start_time() const { return start_time_; } | |
| 281 void set_db_handle(int64 handle) { db_handle_ = handle; } | |
| 282 int64 db_handle() const { return db_handle_; } | |
| 283 bool is_paused() const { return is_paused_; } | |
| 284 bool open_when_complete() const { return open_when_complete_; } | |
| 285 void set_open_when_complete(bool open) { open_when_complete_ = open; } | |
| 286 bool file_externally_removed() const { return file_externally_removed_; } | |
| 287 SafetyState safety_state() const { return safety_state_; } | |
| 288 // Why |safety_state_| is not SAFE. | |
| 289 DangerType GetDangerType() const; | |
| 290 bool IsDangerous() const; | |
| 291 void MarkFileDangerous(); | |
| 292 void MarkUrlDangerous(); | |
| 293 | |
| 294 bool auto_opened() { return auto_opened_; } | |
| 295 const FilePath& target_name() const { return state_info_.target_name; } | |
| 296 bool prompt_user_for_save_location() const { | |
| 297 return state_info_.prompt_user_for_save_location; | |
| 298 } | |
| 299 bool is_otr() const { return is_otr_; } | |
| 300 bool is_extension_install() const { | |
| 301 return state_info_.is_extension_install; | |
| 302 } | |
| 303 const FilePath& suggested_path() const { return state_info_.suggested_path; } | |
| 304 bool is_temporary() const { return is_temporary_; } | |
| 305 void set_opened(bool opened) { opened_ = opened; } | |
| 306 bool opened() const { return opened_; } | |
| 307 | |
| 308 DownloadHistoryInfo GetHistoryInfo() const; | |
| 309 DownloadStateInfo state_info() const { return state_info_; } | |
| 310 const DownloadRequestHandle& request_handle() const { | |
| 311 return request_handle_; | |
| 312 } | |
| 313 | |
| 314 // Returns the final target file path for the download. | |
| 315 FilePath GetTargetFilePath() const; | |
| 316 | |
| 317 // Returns the file-name that should be reported to the user, which is | |
| 318 // target_name possibly with the uniquifier number. | |
| 319 FilePath GetFileNameToReportUser() const; | |
| 320 | |
| 321 // Returns the user-verified target file path for the download. | |
| 322 // This returns the same path as GetTargetFilePath() for safe downloads | |
| 323 // but does not for dangerous downloads until the name is verified. | |
| 324 FilePath GetUserVerifiedFilePath() const; | |
| 325 | |
| 326 // Returns true if the current file name is not the final target name yet. | |
| 327 bool NeedsRename() const { | |
| 328 return state_info_.target_name != full_path_.BaseName(); | |
| 329 } | |
| 330 | |
| 331 // Is a CRX installer running on this download? | |
| 332 bool IsCrxInstallRuning() const { | |
| 333 return (is_extension_install() && | |
| 334 all_data_saved() && | |
| 335 state_ == IN_PROGRESS); | |
| 336 } | |
| 337 | |
| 338 std::string DebugString(bool verbose) const; | |
| 339 | |
| 340 #ifdef UNIT_TEST | |
| 341 // Mock opening downloads (for testing only). | |
| 342 void TestMockDownloadOpen() { open_enabled_ = false; } | |
| 343 #endif | |
| 344 | |
| 345 private: | |
| 346 // Construction common to all constructors. |active| should be true for new | |
| 347 // downloads and false for downloads from the history. | |
| 348 void Init(bool active); | |
| 349 | |
| 350 // Internal helper for maintaining consistent received and total sizes. | |
| 351 void UpdateSize(int64 size); | |
| 352 | |
| 353 // Called when the entire download operation (including renaming etc) | |
| 354 // is completed. | |
| 355 void Completed(); | |
| 356 | |
| 357 // Start/stop sending periodic updates to our observers | |
| 358 void StartProgressTimer(); | |
| 359 void StopProgressTimer(); | |
| 360 | |
| 361 // Call to install this item as a CRX. Should only be called on | |
| 362 // items which are CRXes. Use is_extension_install() to check. | |
| 363 void StartCrxInstall(); | |
| 364 | |
| 365 // Call to transition state; all state transitions should go through this. | |
| 366 void TransitionTo(DownloadState new_state); | |
| 367 | |
| 368 // Called when safety_state_ should be recomputed from is_dangerous_file | |
| 369 // and is_dangerous_url. | |
| 370 void UpdateSafetyState(); | |
| 371 | |
| 372 // Helper function to recompute |state_info_.target_name| when | |
| 373 // it may have changed. (If it's non-null it should be left alone, | |
| 374 // otherwise updated from |full_path_|.) | |
| 375 void UpdateTarget(); | |
| 376 | |
| 377 // State information used by the download manager. | |
| 378 DownloadStateInfo state_info_; | |
| 379 | |
| 380 // The handle to the request information. Used for operations outside the | |
| 381 // download system. | |
| 382 DownloadRequestHandle request_handle_; | |
| 383 | |
| 384 // Download ID assigned by DownloadResourceHandler. | |
| 385 int32 download_id_; | |
| 386 | |
| 387 // Full path to the downloaded or downloading file. | |
| 388 FilePath full_path_; | |
| 389 | |
| 390 // A number that should be appended to the path to make it unique, or 0 if the | |
| 391 // path should be used as is. | |
| 392 int path_uniquifier_; | |
| 393 | |
| 394 // The chain of redirects that leading up to and including the final URL. | |
| 395 std::vector<GURL> url_chain_; | |
| 396 | |
| 397 // The URL of the page that initiated the download. | |
| 398 GURL referrer_url_; | |
| 399 | |
| 400 // Suggested filename in 'download' attribute of an anchor. Details: | |
| 401 // http://www.whatwg.org/specs/web-apps/current-work/#downloading-hyperlinks | |
| 402 std::string suggested_filename_; | |
| 403 | |
| 404 // Information from the request. | |
| 405 // Content-disposition field from the header. | |
| 406 std::string content_disposition_; | |
| 407 | |
| 408 // Mime-type from the header. Subject to change. | |
| 409 std::string mime_type_; | |
| 410 | |
| 411 // The value of the content type header sent with the downloaded item. It | |
| 412 // may be different from |mime_type_|, which may be set based on heuristics | |
| 413 // which may look at the file extension and first few bytes of the file. | |
| 414 std::string original_mime_type_; | |
| 415 | |
| 416 // The charset of the referring page where the download request comes from. | |
| 417 // It's used to construct a suggested filename. | |
| 418 std::string referrer_charset_; | |
| 419 | |
| 420 // Total bytes expected | |
| 421 int64 total_bytes_; | |
| 422 | |
| 423 // Current received bytes | |
| 424 int64 received_bytes_; | |
| 425 | |
| 426 // Last error. | |
| 427 int last_os_error_; | |
| 428 | |
| 429 // Start time for calculating remaining time | |
| 430 base::TimeTicks start_tick_; | |
| 431 | |
| 432 // The current state of this download | |
| 433 DownloadState state_; | |
| 434 | |
| 435 // The views of this item in the download shelf and download tab | |
| 436 ObserverList<Observer> observers_; | |
| 437 | |
| 438 // Time the download was started | |
| 439 base::Time start_time_; | |
| 440 | |
| 441 // Our persistent store handle | |
| 442 int64 db_handle_; | |
| 443 | |
| 444 // Timer for regularly updating our observers | |
| 445 base::RepeatingTimer<DownloadItem> update_timer_; | |
| 446 | |
| 447 // Our owning object | |
| 448 DownloadManager* download_manager_; | |
| 449 | |
| 450 // In progress downloads may be paused by the user, we note it here | |
| 451 bool is_paused_; | |
| 452 | |
| 453 // A flag for indicating if the download should be opened at completion. | |
| 454 bool open_when_complete_; | |
| 455 | |
| 456 // A flag for indicating if the downloaded file is externally removed. | |
| 457 bool file_externally_removed_; | |
| 458 | |
| 459 // Indicates if the download is considered potentially safe or dangerous | |
| 460 // (executable files are typically considered dangerous). | |
| 461 SafetyState safety_state_; | |
| 462 | |
| 463 // True if the download was auto-opened. We set this rather than using | |
| 464 // an observer as it's frequently possible for the download to be auto opened | |
| 465 // before the observer is added. | |
| 466 bool auto_opened_; | |
| 467 | |
| 468 // True if the download was initiated in an incognito window. | |
| 469 bool is_otr_; | |
| 470 | |
| 471 // True if the item was downloaded temporarily. | |
| 472 bool is_temporary_; | |
| 473 | |
| 474 // True if we've saved all the data for the download. | |
| 475 bool all_data_saved_; | |
| 476 | |
| 477 // Did the user open the item either directly or indirectly (such as by | |
| 478 // setting always open files of this type)? The shelf also sets this field | |
| 479 // when the user closes the shelf before the item has been opened but should | |
| 480 // be treated as though the user opened it. | |
| 481 bool opened_; | |
| 482 | |
| 483 // Do we actual open downloads when requested? For testing purposes | |
| 484 // only. | |
| 485 bool open_enabled_; | |
| 486 | |
| 487 // DownloadItem observes CRX installs it initiates. | |
| 488 NotificationRegistrar registrar_; | |
| 489 | |
| 490 DISALLOW_COPY_AND_ASSIGN(DownloadItem); | |
| 491 }; | |
| 492 | |
| 493 #endif // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_ | |
| OLD | NEW |