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