content/browser/download/download_stats.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_stats.h"
   6
   7 #include "base/metrics/histogram.h"
   8 #include "base/metrics/sparse_histogram.h"
   9 #include "base/strings/string_util.h"
  10 #include "content/browser/download/download_resource_handler.h"
  11 #include "content/public/browser/download_interrupt_reasons.h"
  12 #include "net/http/http_content_disposition.h"
  13
  14 namespace content {
  15
  16 namespace {
  17
  18 // All possible error codes from the network module. Note that the error codes
  19 // are all positive (since histograms expect positive sample values).
  20 const int kAllInterruptReasonCodes[] = {
  21 #define INTERRUPT_REASON(label, value) (value),
  22 #include "content/public/browser/download_interrupt_reason_values.h"
  23 #undef INTERRUPT_REASON
  24 };
  25
  26 // These values are based on net::HttpContentDisposition::ParseResult values.
  27 // Values other than HEADER_PRESENT and IS_VALID are only measured if |IS_VALID|
  28 // is true.
  29 enum ContentDispositionCountTypes {
  30   // Count of downloads which had a Content-Disposition headers. The total
  31   // number of downloads is measured by UNTHROTTLED_COUNT.
  32   CONTENT_DISPOSITION_HEADER_PRESENT = 0,
  33
  34   // Either 'filename' or 'filename*' attributes were valid and
  35   // yielded a non-empty filename.
  36   CONTENT_DISPOSITION_IS_VALID,
  37
  38   // The following enum values correspond to
  39   // net::HttpContentDisposition::ParseResult.
  40   CONTENT_DISPOSITION_HAS_DISPOSITION_TYPE,
  41   CONTENT_DISPOSITION_HAS_UNKNOWN_TYPE,
  42
  43   CONTENT_DISPOSITION_HAS_NAME,  // Obsolete; kept for UMA compatiblity.
  44
  45   CONTENT_DISPOSITION_HAS_FILENAME,
  46   CONTENT_DISPOSITION_HAS_EXT_FILENAME,
  47   CONTENT_DISPOSITION_HAS_NON_ASCII_STRINGS,
  48   CONTENT_DISPOSITION_HAS_PERCENT_ENCODED_STRINGS,
  49   CONTENT_DISPOSITION_HAS_RFC2047_ENCODED_STRINGS,
  50
  51   CONTENT_DISPOSITION_HAS_NAME_ONLY,  // Obsolete; kept for UMA compatiblity.
  52
  53   CONTENT_DISPOSITION_LAST_ENTRY
  54 };
  55
  56 void RecordContentDispositionCount(ContentDispositionCountTypes type,
  57                                    bool record) {
  58   if (!record)
  59     return;
  60   UMA_HISTOGRAM_ENUMERATION(
  61       "Download.ContentDisposition", type, CONTENT_DISPOSITION_LAST_ENTRY);
  62 }
  63
  64 void RecordContentDispositionCountFlag(
  65     ContentDispositionCountTypes type,
  66     int flags_to_test,
  67     net::HttpContentDisposition::ParseResultFlags flag) {
  68   RecordContentDispositionCount(type, (flags_to_test & flag) == flag);
  69 }
  70
  71 // Do not insert, delete, or reorder; this is being histogrammed. Append only.
  72 // All of the download_extensions.cc file types should be in this list.
  73 const base::FilePath::CharType* kDangerousFileTypes[] = {
  74   FILE_PATH_LITERAL(".ad"),
  75   FILE_PATH_LITERAL(".ade"),
  76   FILE_PATH_LITERAL(".adp"),
  77   FILE_PATH_LITERAL(".ah"),
  78   FILE_PATH_LITERAL(".apk"),
  79   FILE_PATH_LITERAL(".app"),
  80   FILE_PATH_LITERAL(".application"),
  81   FILE_PATH_LITERAL(".asp"),
  82   FILE_PATH_LITERAL(".asx"),
  83   FILE_PATH_LITERAL(".bas"),
  84   FILE_PATH_LITERAL(".bash"),
  85   FILE_PATH_LITERAL(".bat"),
  86   FILE_PATH_LITERAL(".cfg"),
  87   FILE_PATH_LITERAL(".chi"),
  88   FILE_PATH_LITERAL(".chm"),
  89   FILE_PATH_LITERAL(".class"),
  90   FILE_PATH_LITERAL(".cmd"),
  91   FILE_PATH_LITERAL(".com"),
  92   FILE_PATH_LITERAL(".command"),
  93   FILE_PATH_LITERAL(".crt"),
  94   FILE_PATH_LITERAL(".crx"),
  95   FILE_PATH_LITERAL(".csh"),
  96   FILE_PATH_LITERAL(".deb"),
  97   FILE_PATH_LITERAL(".dex"),
  98   FILE_PATH_LITERAL(".dll"),
  99   FILE_PATH_LITERAL(".drv"),
 100   FILE_PATH_LITERAL(".exe"),
 101   FILE_PATH_LITERAL(".fxp"),
 102   FILE_PATH_LITERAL(".grp"),
 103   FILE_PATH_LITERAL(".hlp"),
 104   FILE_PATH_LITERAL(".hta"),
 105   FILE_PATH_LITERAL(".htm"),
 106   FILE_PATH_LITERAL(".html"),
 107   FILE_PATH_LITERAL(".htt"),
 108   FILE_PATH_LITERAL(".inf"),
 109   FILE_PATH_LITERAL(".ini"),
 110   FILE_PATH_LITERAL(".ins"),
 111   FILE_PATH_LITERAL(".isp"),
 112   FILE_PATH_LITERAL(".jar"),
 113   FILE_PATH_LITERAL(".jnlp"),
 114   FILE_PATH_LITERAL(".user.js"),
 115   FILE_PATH_LITERAL(".js"),
 116   FILE_PATH_LITERAL(".jse"),
 117   FILE_PATH_LITERAL(".ksh"),
 118   FILE_PATH_LITERAL(".lnk"),
 119   FILE_PATH_LITERAL(".local"),
 120   FILE_PATH_LITERAL(".mad"),
 121   FILE_PATH_LITERAL(".maf"),
 122   FILE_PATH_LITERAL(".mag"),
 123   FILE_PATH_LITERAL(".mam"),
 124   FILE_PATH_LITERAL(".manifest"),
 125   FILE_PATH_LITERAL(".maq"),
 126   FILE_PATH_LITERAL(".mar"),
 127   FILE_PATH_LITERAL(".mas"),
 128   FILE_PATH_LITERAL(".mat"),
 129   FILE_PATH_LITERAL(".mau"),
 130   FILE_PATH_LITERAL(".mav"),
 131   FILE_PATH_LITERAL(".maw"),
 132   FILE_PATH_LITERAL(".mda"),
 133   FILE_PATH_LITERAL(".mdb"),
 134   FILE_PATH_LITERAL(".mde"),
 135   FILE_PATH_LITERAL(".mdt"),
 136   FILE_PATH_LITERAL(".mdw"),
 137   FILE_PATH_LITERAL(".mdz"),
 138   FILE_PATH_LITERAL(".mht"),
 139   FILE_PATH_LITERAL(".mhtml"),
 140   FILE_PATH_LITERAL(".mmc"),
 141   FILE_PATH_LITERAL(".mof"),
 142   FILE_PATH_LITERAL(".msc"),
 143   FILE_PATH_LITERAL(".msh"),
 144   FILE_PATH_LITERAL(".mshxml"),
 145   FILE_PATH_LITERAL(".msi"),
 146   FILE_PATH_LITERAL(".msp"),
 147   FILE_PATH_LITERAL(".mst"),
 148   FILE_PATH_LITERAL(".ocx"),
 149   FILE_PATH_LITERAL(".ops"),
 150   FILE_PATH_LITERAL(".pcd"),
 151   FILE_PATH_LITERAL(".pif"),
 152   FILE_PATH_LITERAL(".pkg"),
 153   FILE_PATH_LITERAL(".pl"),
 154   FILE_PATH_LITERAL(".plg"),
 155   FILE_PATH_LITERAL(".prf"),
 156   FILE_PATH_LITERAL(".prg"),
 157   FILE_PATH_LITERAL(".pst"),
 158   FILE_PATH_LITERAL(".py"),
 159   FILE_PATH_LITERAL(".pyc"),
 160   FILE_PATH_LITERAL(".pyw"),
 161   FILE_PATH_LITERAL(".rb"),
 162   FILE_PATH_LITERAL(".reg"),
 163   FILE_PATH_LITERAL(".rpm"),
 164   FILE_PATH_LITERAL(".scf"),
 165   FILE_PATH_LITERAL(".scr"),
 166   FILE_PATH_LITERAL(".sct"),
 167   FILE_PATH_LITERAL(".sh"),
 168   FILE_PATH_LITERAL(".shar"),
 169   FILE_PATH_LITERAL(".shb"),
 170   FILE_PATH_LITERAL(".shs"),
 171   FILE_PATH_LITERAL(".shtm"),
 172   FILE_PATH_LITERAL(".shtml"),
 173   FILE_PATH_LITERAL(".spl"),
 174   FILE_PATH_LITERAL(".svg"),
 175   FILE_PATH_LITERAL(".swf"),
 176   FILE_PATH_LITERAL(".sys"),
 177   FILE_PATH_LITERAL(".tcsh"),
 178   FILE_PATH_LITERAL(".url"),
 179   FILE_PATH_LITERAL(".vb"),
 180   FILE_PATH_LITERAL(".vbe"),
 181   FILE_PATH_LITERAL(".vbs"),
 182   FILE_PATH_LITERAL(".vsd"),
 183   FILE_PATH_LITERAL(".vsmacros"),
 184   FILE_PATH_LITERAL(".vss"),
 185   FILE_PATH_LITERAL(".vst"),
 186   FILE_PATH_LITERAL(".vsw"),
 187   FILE_PATH_LITERAL(".ws"),
 188   FILE_PATH_LITERAL(".wsc"),
 189   FILE_PATH_LITERAL(".wsf"),
 190   FILE_PATH_LITERAL(".wsh"),
 191   FILE_PATH_LITERAL(".xbap"),
 192   FILE_PATH_LITERAL(".xht"),
 193   FILE_PATH_LITERAL(".xhtm"),
 194   FILE_PATH_LITERAL(".xhtml"),
 195   FILE_PATH_LITERAL(".xml"),
 196   FILE_PATH_LITERAL(".xsl"),
 197   FILE_PATH_LITERAL(".xslt")
 198 };
 199
 200 // Maps extensions to their matching UMA histogram int value.
 201 int GetDangerousFileType(const base::FilePath& file_path) {
 202   for (size_t i = 0; i < arraysize(kDangerousFileTypes); ++i) {
 203     if (file_path.MatchesExtension(kDangerousFileTypes[i]))
 204       return i + 1;
 205   }
 206   return 0;  // Unknown extension.
 207 }
 208
 209 } // namespace
 210
 211 void RecordDownloadCount(DownloadCountTypes type) {
 212   UMA_HISTOGRAM_ENUMERATION(
 213       "Download.Counts", type, DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
 214 }
 215
 216 void RecordDownloadSource(DownloadSource source) {
 217   UMA_HISTOGRAM_ENUMERATION(
 218       "Download.Sources", source, DOWNLOAD_SOURCE_LAST_ENTRY);
 219 }
 220
 221 void RecordDownloadCompleted(const base::TimeTicks& start, int64 download_len) {
 222   RecordDownloadCount(COMPLETED_COUNT);
 223   UMA_HISTOGRAM_LONG_TIMES("Download.Time", (base::TimeTicks::Now() - start));
 224   int64 max = 1024 * 1024 * 1024;  // One Terabyte.
 225   download_len /= 1024;  // In Kilobytes
 226   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.DownloadSize",
 227                               download_len,
 228                               1,
 229                               max,
 230                               256);
 231 }
 232
 233 void RecordDownloadInterrupted(DownloadInterruptReason reason,
 234                                int64 received,
 235                                int64 total) {
 236   RecordDownloadCount(INTERRUPTED_COUNT);
 237   UMA_HISTOGRAM_CUSTOM_ENUMERATION(
 238       "Download.InterruptedReason",
 239       reason,
 240       base::CustomHistogram::ArrayToCustomRanges(
 241           kAllInterruptReasonCodes, arraysize(kAllInterruptReasonCodes)));
 242
 243   // The maximum should be 2^kBuckets, to have the logarithmic bucket
 244   // boundaries fall on powers of 2.
 245   static const int kBuckets = 30;
 246   static const int64 kMaxKb = 1 << kBuckets;  // One Terabyte, in Kilobytes.
 247   int64 delta_bytes = total - received;
 248   bool unknown_size = total <= 0;
 249   int64 received_kb = received / 1024;
 250   int64 total_kb = total / 1024;
 251   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedReceivedSizeK",
 252                               received_kb,
 253                               1,
 254                               kMaxKb,
 255                               kBuckets);
 256   if (!unknown_size) {
 257     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedTotalSizeK",
 258                                 total_kb,
 259                                 1,
 260                                 kMaxKb,
 261                                 kBuckets);
 262     if (delta_bytes == 0) {
 263       RecordDownloadCount(INTERRUPTED_AT_END_COUNT);
 264       UMA_HISTOGRAM_CUSTOM_ENUMERATION(
 265           "Download.InterruptedAtEndReason",
 266           reason,
 267           base::CustomHistogram::ArrayToCustomRanges(
 268               kAllInterruptReasonCodes,
 269               arraysize(kAllInterruptReasonCodes)));
 270     } else if (delta_bytes > 0) {
 271       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedOverrunBytes",
 272                                   delta_bytes,
 273                                   1,
 274                                   kMaxKb,
 275                                   kBuckets);
 276     } else {
 277       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedUnderrunBytes",
 278                                   -delta_bytes,
 279                                   1,
 280                                   kMaxKb,
 281                                   kBuckets);
 282     }
 283   }
 284
 285   UMA_HISTOGRAM_BOOLEAN("Download.InterruptedUnknownSize", unknown_size);
 286 }
 287
 288 void RecordMaliciousDownloadClassified(DownloadDangerType danger_type) {
 289   UMA_HISTOGRAM_ENUMERATION("Download.MaliciousDownloadClassified",
 290                             danger_type,
 291                             DOWNLOAD_DANGER_TYPE_MAX);
 292 }
 293
 294 void RecordDangerousDownloadAccept(DownloadDangerType danger_type,
 295                                    const base::FilePath& file_path) {
 296   UMA_HISTOGRAM_ENUMERATION("Download.DangerousDownloadValidated",
 297                             danger_type,
 298                             DOWNLOAD_DANGER_TYPE_MAX);
 299   if (danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE) {
 300     UMA_HISTOGRAM_SPARSE_SLOWLY(
 301         "Download.DangerousFile.DangerousDownloadValidated",
 302         GetDangerousFileType(file_path));
 303   }
 304 }
 305
 306 void RecordDangerousDownloadDiscard(DownloadDiscardReason reason,
 307                                     DownloadDangerType danger_type,
 308                                     const base::FilePath& file_path) {
 309   switch (reason) {
 310     case DOWNLOAD_DISCARD_DUE_TO_USER_ACTION:
 311       UMA_HISTOGRAM_ENUMERATION(
 312           "Download.UserDiscard", danger_type, DOWNLOAD_DANGER_TYPE_MAX);
 313       if (danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE) {
 314         UMA_HISTOGRAM_SPARSE_SLOWLY("Download.DangerousFile.UserDiscard",
 315                                     GetDangerousFileType(file_path));
 316       }
 317       break;
 318     case DOWNLOAD_DISCARD_DUE_TO_SHUTDOWN:
 319       UMA_HISTOGRAM_ENUMERATION(
 320           "Download.Discard", danger_type, DOWNLOAD_DANGER_TYPE_MAX);
 321       if (danger_type == DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE) {
 322         UMA_HISTOGRAM_SPARSE_SLOWLY("Download.DangerousFile.Discard",
 323                                     GetDangerousFileType(file_path));
 324       }
 325       break;
 326     default:
 327       NOTREACHED();
 328   }
 329 }
 330
 331 void RecordDownloadWriteSize(size_t data_len) {
 332   int max = 1024 * 1024;  // One Megabyte.
 333   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.WriteSize", data_len, 1, max, 256);
 334 }
 335
 336 void RecordDownloadWriteLoopCount(int count) {
 337   UMA_HISTOGRAM_ENUMERATION("Download.WriteLoopCount", count, 20);
 338 }
 339
 340 void RecordAcceptsRanges(const std::string& accepts_ranges,
 341                          int64 download_len,
 342                          bool has_strong_validator) {
 343   int64 max = 1024 * 1024 * 1024;  // One Terabyte.
 344   download_len /= 1024;  // In Kilobytes
 345   static const int kBuckets = 50;
 346
 347   if (base::LowerCaseEqualsASCII(accepts_ranges, "none")) {
 348     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.AcceptRangesNone.KBytes",
 349                                 download_len,
 350                                 1,
 351                                 max,
 352                                 kBuckets);
 353   } else if (base::LowerCaseEqualsASCII(accepts_ranges, "bytes")) {
 354     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.AcceptRangesBytes.KBytes",
 355                                 download_len,
 356                                 1,
 357                                 max,
 358                                 kBuckets);
 359     if (has_strong_validator)
 360       RecordDownloadCount(STRONG_VALIDATOR_AND_ACCEPTS_RANGES);
 361   } else {
 362     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.AcceptRangesMissingOrInvalid.KBytes",
 363                                 download_len,
 364                                 1,
 365                                 max,
 366                                 kBuckets);
 367   }
 368 }
 369
 370 namespace {
 371
 372 enum DownloadContent {
 373   DOWNLOAD_CONTENT_UNRECOGNIZED = 0,
 374   DOWNLOAD_CONTENT_TEXT = 1,
 375   DOWNLOAD_CONTENT_IMAGE = 2,
 376   DOWNLOAD_CONTENT_AUDIO = 3,
 377   DOWNLOAD_CONTENT_VIDEO = 4,
 378   DOWNLOAD_CONTENT_OCTET_STREAM = 5,
 379   DOWNLOAD_CONTENT_PDF = 6,
 380   DOWNLOAD_CONTENT_DOC = 7,
 381   DOWNLOAD_CONTENT_XLS = 8,
 382   DOWNLOAD_CONTENT_PPT = 9,
 383   DOWNLOAD_CONTENT_ARCHIVE = 10,
 384   DOWNLOAD_CONTENT_EXE = 11,
 385   DOWNLOAD_CONTENT_DMG = 12,
 386   DOWNLOAD_CONTENT_CRX = 13,
 387   DOWNLOAD_CONTENT_MAX = 14,
 388 };
 389
 390 struct MimeTypeToDownloadContent {
 391   const char* mime_type;
 392   DownloadContent download_content;
 393 };
 394
 395 static MimeTypeToDownloadContent kMapMimeTypeToDownloadContent[] = {
 396   {"application/octet-stream", DOWNLOAD_CONTENT_OCTET_STREAM},
 397   {"binary/octet-stream", DOWNLOAD_CONTENT_OCTET_STREAM},
 398   {"application/pdf", DOWNLOAD_CONTENT_PDF},
 399   {"application/msword", DOWNLOAD_CONTENT_DOC},
 400   {"application/vnd.ms-excel", DOWNLOAD_CONTENT_XLS},
 401   {"application/vns.ms-powerpoint", DOWNLOAD_CONTENT_PPT},
 402   {"application/zip", DOWNLOAD_CONTENT_ARCHIVE},
 403   {"application/x-gzip", DOWNLOAD_CONTENT_ARCHIVE},
 404   {"application/x-rar-compressed", DOWNLOAD_CONTENT_ARCHIVE},
 405   {"application/x-tar", DOWNLOAD_CONTENT_ARCHIVE},
 406   {"application/x-bzip", DOWNLOAD_CONTENT_ARCHIVE},
 407   {"application/x-exe", DOWNLOAD_CONTENT_EXE},
 408   {"application/x-apple-diskimage", DOWNLOAD_CONTENT_DMG},
 409   {"application/x-chrome-extension", DOWNLOAD_CONTENT_CRX},
 410 };
 411
 412 enum DownloadImage {
 413   DOWNLOAD_IMAGE_UNRECOGNIZED = 0,
 414   DOWNLOAD_IMAGE_GIF = 1,
 415   DOWNLOAD_IMAGE_JPEG = 2,
 416   DOWNLOAD_IMAGE_PNG = 3,
 417   DOWNLOAD_IMAGE_TIFF = 4,
 418   DOWNLOAD_IMAGE_ICON = 5,
 419   DOWNLOAD_IMAGE_WEBP = 6,
 420   DOWNLOAD_IMAGE_MAX = 7,
 421 };
 422
 423 struct MimeTypeToDownloadImage {
 424   const char* mime_type;
 425   DownloadImage download_image;
 426 };
 427
 428 static MimeTypeToDownloadImage kMapMimeTypeToDownloadImage[] = {
 429   {"image/gif", DOWNLOAD_IMAGE_GIF},
 430   {"image/jpeg", DOWNLOAD_IMAGE_JPEG},
 431   {"image/png", DOWNLOAD_IMAGE_PNG},
 432   {"image/tiff", DOWNLOAD_IMAGE_TIFF},
 433   {"image/vnd.microsoft.icon", DOWNLOAD_IMAGE_ICON},
 434   {"image/webp", DOWNLOAD_IMAGE_WEBP},
 435 };
 436
 437 void RecordDownloadImageType(const std::string& mime_type_string) {
 438   DownloadImage download_image = DOWNLOAD_IMAGE_UNRECOGNIZED;
 439
 440   // Look up exact matches.
 441   for (size_t i = 0; i < arraysize(kMapMimeTypeToDownloadImage); ++i) {
 442     const MimeTypeToDownloadImage& entry = kMapMimeTypeToDownloadImage[i];
 443     if (mime_type_string == entry.mime_type) {
 444       download_image = entry.download_image;
 445       break;
 446     }
 447   }
 448
 449   UMA_HISTOGRAM_ENUMERATION("Download.ContentImageType",
 450                             download_image,
 451                             DOWNLOAD_IMAGE_MAX);
 452 }
 453
 454 }  // namespace
 455
 456 void RecordDownloadMimeType(const std::string& mime_type_string) {
 457   DownloadContent download_content = DOWNLOAD_CONTENT_UNRECOGNIZED;
 458
 459   // Look up exact matches.
 460   for (size_t i = 0; i < arraysize(kMapMimeTypeToDownloadContent); ++i) {
 461     const MimeTypeToDownloadContent& entry = kMapMimeTypeToDownloadContent[i];
 462     if (mime_type_string == entry.mime_type) {
 463       download_content = entry.download_content;
 464       break;
 465     }
 466   }
 467
 468   // Do partial matches.
 469   if (download_content == DOWNLOAD_CONTENT_UNRECOGNIZED) {
 470     if (base::StartsWithASCII(mime_type_string, "text/", true)) {
 471       download_content = DOWNLOAD_CONTENT_TEXT;
 472     } else if (base::StartsWithASCII(mime_type_string, "image/", true)) {
 473       download_content = DOWNLOAD_CONTENT_IMAGE;
 474       RecordDownloadImageType(mime_type_string);
 475     } else if (base::StartsWithASCII(mime_type_string, "audio/", true)) {
 476       download_content = DOWNLOAD_CONTENT_AUDIO;
 477     } else if (base::StartsWithASCII(mime_type_string, "video/", true)) {
 478       download_content = DOWNLOAD_CONTENT_VIDEO;
 479     }
 480   }
 481
 482   // Record the value.
 483   UMA_HISTOGRAM_ENUMERATION("Download.ContentType",
 484                             download_content,
 485                             DOWNLOAD_CONTENT_MAX);
 486 }
 487
 488 void RecordDownloadContentDisposition(
 489     const std::string& content_disposition_string) {
 490   if (content_disposition_string.empty())
 491     return;
 492   net::HttpContentDisposition content_disposition(content_disposition_string,
 493                                                   std::string());
 494   int result = content_disposition.parse_result_flags();
 495
 496   bool is_valid = !content_disposition.filename().empty();
 497   RecordContentDispositionCount(CONTENT_DISPOSITION_HEADER_PRESENT, true);
 498   RecordContentDispositionCount(CONTENT_DISPOSITION_IS_VALID, is_valid);
 499   if (!is_valid)
 500     return;
 501
 502   RecordContentDispositionCountFlag(
 503       CONTENT_DISPOSITION_HAS_DISPOSITION_TYPE, result,
 504       net::HttpContentDisposition::HAS_DISPOSITION_TYPE);
 505   RecordContentDispositionCountFlag(
 506       CONTENT_DISPOSITION_HAS_UNKNOWN_TYPE, result,
 507       net::HttpContentDisposition::HAS_UNKNOWN_DISPOSITION_TYPE);
 508   RecordContentDispositionCountFlag(
 509       CONTENT_DISPOSITION_HAS_FILENAME, result,
 510       net::HttpContentDisposition::HAS_FILENAME);
 511   RecordContentDispositionCountFlag(
 512       CONTENT_DISPOSITION_HAS_EXT_FILENAME, result,
 513       net::HttpContentDisposition::HAS_EXT_FILENAME);
 514   RecordContentDispositionCountFlag(
 515       CONTENT_DISPOSITION_HAS_NON_ASCII_STRINGS, result,
 516       net::HttpContentDisposition::HAS_NON_ASCII_STRINGS);
 517   RecordContentDispositionCountFlag(
 518       CONTENT_DISPOSITION_HAS_PERCENT_ENCODED_STRINGS, result,
 519       net::HttpContentDisposition::HAS_PERCENT_ENCODED_STRINGS);
 520   RecordContentDispositionCountFlag(
 521       CONTENT_DISPOSITION_HAS_RFC2047_ENCODED_STRINGS, result,
 522       net::HttpContentDisposition::HAS_RFC2047_ENCODED_STRINGS);
 523 }
 524
 525 void RecordFileThreadReceiveBuffers(size_t num_buffers) {
 526     UMA_HISTOGRAM_CUSTOM_COUNTS(
 527       "Download.FileThreadReceiveBuffers", num_buffers, 1,
 528       100, 100);
 529 }
 530
 531 void RecordBandwidth(double actual_bandwidth, double potential_bandwidth) {
 532   UMA_HISTOGRAM_CUSTOM_COUNTS(
 533       "Download.ActualBandwidth", actual_bandwidth, 1, 1000000000, 50);
 534   UMA_HISTOGRAM_CUSTOM_COUNTS(
 535       "Download.PotentialBandwidth", potential_bandwidth, 1, 1000000000, 50);
 536   UMA_HISTOGRAM_PERCENTAGE(
 537       "Download.BandwidthUsed",
 538       (int) ((actual_bandwidth * 100)/ potential_bandwidth));
 539 }
 540
 541 void RecordOpen(const base::Time& end, bool first) {
 542   if (!end.is_null()) {
 543     UMA_HISTOGRAM_LONG_TIMES("Download.OpenTime", (base::Time::Now() - end));
 544     if (first) {
 545       UMA_HISTOGRAM_LONG_TIMES("Download.FirstOpenTime",
 546                               (base::Time::Now() - end));
 547     }
 548   }
 549 }
 550
 551 void RecordClearAllSize(int size) {
 552   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.ClearAllSize",
 553                               size,
 554                               0/*min*/,
 555                               (1 << 10)/*max*/,
 556                               32/*num_buckets*/);
 557 }
 558
 559 void RecordOpensOutstanding(int size) {
 560   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.OpensOutstanding",
 561                               size,
 562                               0/*min*/,
 563                               (1 << 10)/*max*/,
 564                               64/*num_buckets*/);
 565 }
 566
 567 void RecordContiguousWriteTime(base::TimeDelta time_blocked) {
 568   UMA_HISTOGRAM_TIMES("Download.FileThreadBlockedTime", time_blocked);
 569 }
 570
 571 // Record what percentage of the time we have the network flow controlled.
 572 void RecordNetworkBlockage(base::TimeDelta resource_handler_lifetime,
 573                            base::TimeDelta resource_handler_blocked_time) {
 574   int percentage = 0;
 575   // Avoid division by zero errors.
 576   if (resource_handler_blocked_time != base::TimeDelta()) {
 577     percentage =
 578         resource_handler_blocked_time * 100 / resource_handler_lifetime;
 579   }
 580
 581   UMA_HISTOGRAM_COUNTS_100("Download.ResourceHandlerBlockedPercentage",
 582                            percentage);
 583 }
 584
 585 void RecordFileBandwidth(size_t length,
 586                          base::TimeDelta disk_write_time,
 587                          base::TimeDelta elapsed_time) {
 588   size_t elapsed_time_ms = elapsed_time.InMilliseconds();
 589   if (0u == elapsed_time_ms)
 590     elapsed_time_ms = 1;
 591   size_t disk_write_time_ms = disk_write_time.InMilliseconds();
 592   if (0u == disk_write_time_ms)
 593     disk_write_time_ms = 1;
 594
 595   UMA_HISTOGRAM_CUSTOM_COUNTS(
 596       "Download.BandwidthOverallBytesPerSecond",
 597       (1000 * length / elapsed_time_ms), 1, 50000000, 50);
 598   UMA_HISTOGRAM_CUSTOM_COUNTS(
 599       "Download.BandwidthDiskBytesPerSecond",
 600       (1000 * length / disk_write_time_ms), 1, 50000000, 50);
 601   UMA_HISTOGRAM_COUNTS_100("Download.DiskBandwidthUsedPercentage",
 602                            disk_write_time_ms * 100 / elapsed_time_ms);
 603 }
 604
 605 void RecordDownloadFileRenameResultAfterRetry(
 606     base::TimeDelta time_since_first_failure,
 607     DownloadInterruptReason interrupt_reason) {
 608   if (interrupt_reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
 609     UMA_HISTOGRAM_TIMES("Download.TimeToRenameSuccessAfterInitialFailure",
 610                         time_since_first_failure);
 611   } else {
 612     UMA_HISTOGRAM_TIMES("Download.TimeToRenameFailureAfterInitialFailure",
 613                         time_since_first_failure);
 614   }
 615 }
 616
 617 void RecordSavePackageEvent(SavePackageEvent event) {
 618   UMA_HISTOGRAM_ENUMERATION("Download.SavePackage",
 619                             event,
 620                             SAVE_PACKAGE_LAST_ENTRY);
 621 }
 622
 623 void RecordOriginStateOnResumption(bool is_partial,
 624                                    int state) {
 625   if (is_partial)
 626     UMA_HISTOGRAM_ENUMERATION("Download.OriginStateOnPartialResumption", state,
 627                               ORIGIN_STATE_ON_RESUMPTION_MAX);
 628   else
 629     UMA_HISTOGRAM_ENUMERATION("Download.OriginStateOnFullResumption", state,
 630                               ORIGIN_STATE_ON_RESUMPTION_MAX);
 631 }
 632
 633 }  // namespace content