Recording download mime types for normal profile

content/browser/download/download_stats.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/download/download_stats.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 560 matching lines @@
 
   // Look up exact matches.
   for (size_t i = 0; i < arraysize(kMapMimeTypeToDownloadImage); ++i) {
     const MimeTypeToDownloadImage& entry = kMapMimeTypeToDownloadImage[i];
     if (mime_type_string == entry.mime_type) {
       download_image = entry.download_image;
       break;
     }
   }
 
-  UMA_HISTOGRAM_ENUMERATION("Download.ContentImageType",
-                            download_image,
+  UMA_HISTOGRAM_ENUMERATION("Download.ContentImageType", download_image,
                             DOWNLOAD_IMAGE_MAX);
 }
 
-}  // namespace
-
-void RecordDownloadMimeType(const std::string& mime_type_string) {
+DownloadContent DownloadContentFromMimeType(
+    const std::string& mime_type_string) {
   DownloadContent download_content = DOWNLOAD_CONTENT_UNRECOGNIZED;
 
   // Look up exact matches.
   for (size_t i = 0; i < arraysize(kMapMimeTypeToDownloadContent); ++i) {
     const MimeTypeToDownloadContent& entry = kMapMimeTypeToDownloadContent[i];
     if (mime_type_string == entry.mime_type) {
       download_content = entry.download_content;
       break;
     }
   }
 
   // Do partial matches.
   if (download_content == DOWNLOAD_CONTENT_UNRECOGNIZED) {
     if (base::StartsWith(mime_type_string, "text/",
                          base::CompareCase::SENSITIVE)) {
       download_content = DOWNLOAD_CONTENT_TEXT;
     } else if (base::StartsWith(mime_type_string, "image/",
                                 base::CompareCase::SENSITIVE)) {
       download_content = DOWNLOAD_CONTENT_IMAGE;
       RecordDownloadImageType(mime_type_string);
     } else if (base::StartsWith(mime_type_string, "audio/",
                                 base::CompareCase::SENSITIVE)) {
       download_content = DOWNLOAD_CONTENT_AUDIO;
     } else if (base::StartsWith(mime_type_string, "video/",
                                 base::CompareCase::SENSITIVE)) {
       download_content = DOWNLOAD_CONTENT_VIDEO;
     }
   }
 
-  // Record the value.
+  return download_content;
+}
+
+}  // namespace
+
+void RecordDownloadMimeType(const std::string& mime_type_string) {
   UMA_HISTOGRAM_ENUMERATION("Download.ContentType",
-                            download_content,
+                            DownloadContentFromMimeType(mime_type_string),
                             DOWNLOAD_CONTENT_MAX);
 }
 
+void RecordDownloadMimeTypeForNormalProfile(
+    const std::string& mime_type_string) {
+  UMA_HISTOGRAM_ENUMERATION("Download.ContentType.NormalProfile",
+                            DownloadContentFromMimeType(mime_type_string),
+                            DOWNLOAD_CONTENT_MAX);
+}
+
 void RecordDownloadContentDisposition(
     const std::string& content_disposition_string) {
   if (content_disposition_string.empty())
     return;
   net::HttpContentDisposition content_disposition(content_disposition_string,
                                                   std::string());
   int result = content_disposition.parse_result_flags();
 
   bool is_valid = !content_disposition.filename().empty();
   RecordContentDispositionCount(CONTENT_DISPOSITION_HEADER_PRESENT, true);
@@ skipping 161 matching lines @@
   if (!page_transition)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       "Download.PageTransition",
       ui::PageTransitionStripQualifier(page_transition.value()),
       ui::PAGE_TRANSITION_LAST_CORE + 1);
 }
 
 }  // namespace content