Home | History | Annotate | Download | only in download 
      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 // Holds helpers for gathering UMA stats about downloads.
      6 
      7 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_STATS_H_
      8 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_STATS_H_
      9 
     10 #include <string>
     11 
     12 #include "base/basictypes.h"
     13 #include "content/common/content_export.h"
     14 #include "content/public/browser/download_danger_type.h"
     15 #include "content/public/browser/download_interrupt_reasons.h"
     16 
     17 namespace base {
     18 class FilePath;
     19 class Time;
     20 class TimeDelta;
     21 class TimeTicks;
     22 }
     23 
     24 namespace content {
     25 
     26 // We keep a count of how often various events occur in the
     27 // histogram "Download.Counts".
     28 enum DownloadCountTypes {
     29   // Stale enum values left around so that values passed to UMA don't
     30   // change.
     31   DOWNLOAD_COUNT_UNUSED_0 = 0,
     32   DOWNLOAD_COUNT_UNUSED_1,
     33   DOWNLOAD_COUNT_UNUSED_2,
     34   DOWNLOAD_COUNT_UNUSED_3,
     35   DOWNLOAD_COUNT_UNUSED_4,
     36 
     37   // Downloads that made it to DownloadResourceHandler
     38   UNTHROTTLED_COUNT,
     39 
     40   // Downloads that actually complete.
     41   COMPLETED_COUNT,
     42 
     43   // Downloads that are cancelled before completion (user action or error).
     44   CANCELLED_COUNT,
     45 
     46   // Downloads that are started. Should be equal to UNTHROTTLED_COUNT.
     47   START_COUNT,
     48 
     49   // Downloads that were interrupted by the OS.
     50   INTERRUPTED_COUNT,
     51 
     52   // (Deprecated) Write sizes for downloads.
     53   // This is equal to the number of samples in Download.WriteSize histogram.
     54   DOWNLOAD_COUNT_UNUSED_10,
     55 
     56   // (Deprecated) Counts iterations of the BaseFile::AppendDataToFile() loop.
     57   // This is equal to the number of samples in Download.WriteLoopCount
     58   // histogram.
     59   DOWNLOAD_COUNT_UNUSED_11,
     60 
     61   // Counts interruptions that happened at the end of the download.
     62   INTERRUPTED_AT_END_COUNT,
     63 
     64   // Counts errors due to writes to BaseFiles that have been detached already.
     65   // This can happen when saving web pages as complete packages. It happens
     66   // when we get messages to append data to files that have already finished and
     67   // been detached, but haven't yet been removed from the list of files in
     68   // progress.
     69   APPEND_TO_DETACHED_FILE_COUNT,
     70 
     71   // Counts the number of instances where the downloaded file is missing after a
     72   // successful invocation of ScanAndSaveDownloadedFile().
     73   FILE_MISSING_AFTER_SUCCESSFUL_SCAN_COUNT,
     74 
     75   // (Deprecated) Count of downloads with a strong ETag and specified
     76   // 'Accept-Ranges: bytes'.
     77   DOWNLOAD_COUNT_UNUSED_15,
     78 
     79   // Count of downloads that didn't have a valid WebContents at the time it was
     80   // interrupted.
     81   INTERRUPTED_WITHOUT_WEBCONTENTS,
     82 
     83   // Count of downloads that supplies a strong validator (implying byte-wise
     84   // equivalence) and has a 'Accept-Ranges: bytes' header. These downloads are
     85   // candidates for partial resumption.
     86   STRONG_VALIDATOR_AND_ACCEPTS_RANGES,
     87 
     88   DOWNLOAD_COUNT_TYPES_LAST_ENTRY
     89 };
     90 
     91 enum DownloadSource {
     92   // The download was initiated when the SavePackage system rejected
     93   // a Save Page As ... by returning false from
     94   // SavePackage::IsSaveableContents().
     95   INITIATED_BY_SAVE_PACKAGE_ON_NON_HTML = 0,
     96 
     97   // The download was initiated by a drag and drop from a drag-and-drop
     98   // enabled web application.
     99   INITIATED_BY_DRAG_N_DROP,
    100 
    101   // The download was initiated by explicit RPC from the renderer process
    102   // (e.g. by Alt-click) through the IPC ViewHostMsg_DownloadUrl.
    103   INITIATED_BY_RENDERER,
    104 
    105   // Fomerly INITIATED_BY_PEPPER_SAVE.
    106   DOWNLOAD_SOURCE_UNUSED_3,
    107 
    108   // A request that was initiated as a result of resuming an interrupted
    109   // download.
    110   INITIATED_BY_RESUMPTION,
    111 
    112   DOWNLOAD_SOURCE_LAST_ENTRY
    113 };
    114 
    115 enum DownloadDiscardReason {
    116   // The download is being discarded due to a user action.
    117   DOWNLOAD_DISCARD_DUE_TO_USER_ACTION,
    118 
    119   // The download is being discarded due to the browser being shut down.
    120   DOWNLOAD_DISCARD_DUE_TO_SHUTDOWN
    121 };
    122 
    123 // Increment one of the above counts.
    124 void RecordDownloadCount(DownloadCountTypes type);
    125 
    126 // Record initiation of a download from a specific source.
    127 void RecordDownloadSource(DownloadSource source);
    128 
    129 // Record COMPLETED_COUNT and how long the download took.
    130 void RecordDownloadCompleted(const base::TimeTicks& start, int64 download_len);
    131 
    132 // Record INTERRUPTED_COUNT, |reason|, |received| and |total| bytes.
    133 void RecordDownloadInterrupted(DownloadInterruptReason reason,
    134                                int64 received,
    135                                int64 total);
    136 
    137 // Record that a download has been classified as malicious.
    138 void RecordMaliciousDownloadClassified(DownloadDangerType danger_type);
    139 
    140 // Record a dangerous download accept event.
    141 void RecordDangerousDownloadAccept(
    142     DownloadDangerType danger_type,
    143     const base::FilePath& file_path);
    144 
    145 // Record a dangerous download discard event.
    146 void RecordDangerousDownloadDiscard(
    147     DownloadDiscardReason reason,
    148     DownloadDangerType danger_type,
    149     const base::FilePath& file_path);
    150 
    151 // Records the mime type of the download.
    152 void RecordDownloadMimeType(const std::string& mime_type);
    153 
    154 // Records usage of Content-Disposition header.
    155 void RecordDownloadContentDisposition(const std::string& content_disposition);
    156 
    157 // Record WRITE_SIZE_COUNT and data_len.
    158 void RecordDownloadWriteSize(size_t data_len);
    159 
    160 // Record WRITE_LOOP_COUNT and number of loops.
    161 void RecordDownloadWriteLoopCount(int count);
    162 
    163 // Record the number of buffers piled up by the IO thread
    164 // before the file thread gets to draining them.
    165 void RecordFileThreadReceiveBuffers(size_t num_buffers);
    166 
    167 // Record the bandwidth seen in DownloadResourceHandler
    168 // |actual_bandwidth| and |potential_bandwidth| are in bytes/second.
    169 void RecordBandwidth(double actual_bandwidth, double potential_bandwidth);
    170 
    171 // Record the time of both the first open and all subsequent opens since the
    172 // download completed.
    173 void RecordOpen(const base::Time& end, bool first);
    174 
    175 // Record whether or not the server accepts ranges, and the download size. Also
    176 // counts if a strong validator is supplied. The combination of range request
    177 // support and ETag indicates downloads that are candidates for partial
    178 // resumption.
    179 void RecordAcceptsRanges(const std::string& accepts_ranges,
    180                          int64 download_len,
    181                          bool has_strong_validator);
    182 
    183 // Record the number of downloads removed by ClearAll.
    184 void RecordClearAllSize(int size);
    185 
    186 // Record the number of completed unopened downloads when a download is opened.
    187 void RecordOpensOutstanding(int size);
    188 
    189 // Record how long we block the file thread at a time.
    190 void RecordContiguousWriteTime(base::TimeDelta time_blocked);
    191 
    192 // Record the percentage of time we had to block the network (i.e.
    193 // how often, for each download, something other than the network
    194 // was the bottleneck).
    195 void RecordNetworkBlockage(base::TimeDelta resource_handler_lifetime,
    196                            base::TimeDelta resource_handler_blocked_time);
    197 
    198 // Record overall bandwidth stats at the file end.
    199 void RecordFileBandwidth(size_t length,
    200                          base::TimeDelta disk_write_time,
    201                          base::TimeDelta elapsed_time);
    202 
    203 enum SavePackageEvent {
    204   // The user has started to save a page as a package.
    205   SAVE_PACKAGE_STARTED,
    206 
    207   // The save package operation was cancelled.
    208   SAVE_PACKAGE_CANCELLED,
    209 
    210   // The save package operation finished without being cancelled.
    211   SAVE_PACKAGE_FINISHED,
    212 
    213   // The save package tried to write to an already completed file.
    214   SAVE_PACKAGE_WRITE_TO_COMPLETED,
    215 
    216   // The save package tried to write to an already failed file.
    217   SAVE_PACKAGE_WRITE_TO_FAILED,
    218 
    219   SAVE_PACKAGE_LAST_ENTRY
    220 };
    221 
    222 void RecordSavePackageEvent(SavePackageEvent event);
    223 
    224 enum OriginStateOnResumption {
    225   ORIGIN_STATE_ON_RESUMPTION_ADDITIONAL_REDIRECTS = 1<<0,
    226   ORIGIN_STATE_ON_RESUMPTION_VALIDATORS_CHANGED = 1<<1,
    227   ORIGIN_STATE_ON_RESUMPTION_CONTENT_DISPOSITION_CHANGED = 1<<2,
    228   ORIGIN_STATE_ON_RESUMPTION_MAX = 1<<3
    229 };
    230 
    231 // Record the state of the origin information across a download resumption
    232 // request. |state| is a combination of values from OriginStateOnResumption
    233 // enum.
    234 void RecordOriginStateOnResumption(bool is_partial,
    235                                    int state);
    236 
    237 }  // namespace content
    238 
    239 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_STATS_H_
    240