Use string for Histogram names since these are all ASCII anyway wide-characte...

net/base/mime_sniffer.cc

 // Copyright (c) 2006-2008 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.
 
 // Detecting mime types is a tricky business because we need to balance
 // compatibility concerns with security issues.  Here is a survey of how other
 // browsers behave and then a description of how we intend to behave.
 //
 // HTML payload, no Content-Type header:
 // * IE 7: Render as HTML
@@ skipping 85 matching lines @@
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_util.h"
 
 namespace {
 
 class SnifferHistogram : public LinearHistogram {
  public:
-  SnifferHistogram(const wchar_t* name, int array_size)
+  SnifferHistogram(const char* name, int array_size)
       : LinearHistogram(name, 0, array_size - 1, array_size) {
     SetFlags(kUmaTargetedHistogramFlag);
   }
 };
 
 }  // namespace
 
 namespace net {
 
 // We aren't interested in looking at more than 512 bytes of content
@@ skipping 149 matching lines @@
 static bool SniffForHTML(const char* content, size_t size,
                          std::string* result) {
   // We adopt a strategy similar to that used by Mozilla to sniff HTML tags,
   // but with some modifications to better match the HTML5 spec.
   const char* const end = content + size;
   const char* pos;
   for (pos = content; pos < end; ++pos) {
     if (!IsAsciiWhitespace(*pos))
       break;
   }
-  static SnifferHistogram counter(L"mime_sniffer.kSniffableTags2",
+  static SnifferHistogram counter("mime_sniffer.kSniffableTags2",
                                   arraysize(kSniffableTags));
   // |pos| now points to first non-whitespace character (or at end).
   return CheckForMagicNumbers(pos, end - pos,
                               kSniffableTags, arraysize(kSniffableTags),
                               &counter, result);
 }
 
 static bool SniffForMagicNumbers(const char* content, size_t size,
                                  std::string* result) {
   // Check our big table of Magic Numbers
-  static SnifferHistogram counter(L"mime_sniffer.kMagicNumbers2",
+  static SnifferHistogram counter("mime_sniffer.kMagicNumbers2",
                                   arraysize(kMagicNumbers));
   return CheckForMagicNumbers(content, size,
                               kMagicNumbers, arraysize(kMagicNumbers),
                               &counter, result);
 }
 
 // Byte order marks
 static const MagicNumber kMagicXML[] = {
   // We want to be very conservative in interpreting text/xml content as
   // XHTML -- we just want to sniff enough to make unit tests pass.
@@ skipping 15 matching lines @@
   // We allow at most kFirstTagBytes bytes of content before we expect the
   // opening tag.
   const size_t kFeedAllowedHeaderBytes = 300;
   const char* const end = content + std::min(size, kFeedAllowedHeaderBytes);
   const char* pos = content;
 
   // This loop iterates through tag-looking offsets in the file.
   // We want to skip XML processing instructions (of the form "<?xml ...")
   // and stop at the first "plain" tag, then make a decision on the mime-type
   // based on the name (or possibly attributes) of that tag.
-  static SnifferHistogram counter(L"mime_sniffer.kMagicXML2",
+  static SnifferHistogram counter("mime_sniffer.kMagicXML2",
                                   arraysize(kMagicXML));
   const int kMaxTagIterations = 5;
   for (int i = 0; i < kMaxTagIterations && pos < end; ++i) {
     pos = reinterpret_cast<const char*>(memchr(pos, '<', end - pos));
     if (!pos)
       return false;
 
     if (base::strncasecmp(pos, "<?xml", sizeof("<?xml")-1) == 0) {
       // Skip XML declarations.
       ++pos;
@@ skipping 46 matching lines @@
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xA0 - 0xAF
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xB0 - 0xBF
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xC0 - 0xCF
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xD0 - 0xDF
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xE0 - 0xEF
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // 0xF0 - 0xFF
 };
 
 static bool LooksBinary(const char* content, size_t size) {
   // First, we look for a BOM.
-  static SnifferHistogram counter(L"mime_sniffer.kByteOrderMark2",
+  static SnifferHistogram counter("mime_sniffer.kByteOrderMark2",
                                   arraysize(kByteOrderMark));
   std::string unused;
   if (CheckForMagicNumbers(content, size,
                            kByteOrderMark, arraysize(kByteOrderMark),
                            &counter, &unused)) {
     // If there is BOM, we think the buffer is not binary.
     return false;
   }
 
   // Next we look to see if any of the bytes "look binary."
@@ skipping 13 matching lines @@
   static const char* kUnknownMimeTypes[] = {
     // Empty mime types are as unknown as they get.
     "",
     // The unknown/unknown type is popular and uninformative
     "unknown/unknown",
     // The second most popular unknown mime type is application/unknown
     "application/unknown",
     // Firefox rejects a mime type if it is exactly */*
     "*/*",
   };
-  static SnifferHistogram counter(L"mime_sniffer.kUnknownMimeTypes2",
+  static SnifferHistogram counter("mime_sniffer.kUnknownMimeTypes2",
                                   arraysize(kUnknownMimeTypes) + 1);
   for (size_t i = 0; i < arraysize(kUnknownMimeTypes); ++i) {
     if (mime_type == kUnknownMimeTypes[i]) {
       counter.Add(i);
       return true;
     }
   }
   if (mime_type.find('/') == std::string::npos) {
     // Firefox rejects a mime type if it does not contain a slash
     counter.Add(arraysize(kUnknownMimeTypes));
     return true;
   }
   return false;
 }
 
 bool ShouldSniffMimeType(const GURL& url, const std::string& mime_type) {
   static SnifferHistogram should_sniff_counter(
-      L"mime_sniffer.ShouldSniffMimeType2", 3);
+      "mime_sniffer.ShouldSniffMimeType2", 3);
   // We are willing to sniff the mime type for HTTP, HTTPS, and FTP
   bool sniffable_scheme = url.is_empty() ||
                           url.SchemeIs("http") ||
                           url.SchemeIs("https") ||
                           url.SchemeIs("ftp");
   if (!sniffable_scheme) {
     should_sniff_counter.Add(1);
     return false;
   }
 
   static const char* kSniffableTypes[] = {
     // Many web servers are misconfigured to send text/plain for many
     // different types of content.
     "text/plain",
     // IIS 4.0 and 5.0 send application/octet-stream when serving .xhtml
     // files.  Firefox 2.0 does not sniff xhtml here, but Safari 3,
     // Opera 9, and IE do.
     "application/octet-stream",
     // XHTML and Atom/RSS feeds are often served as plain xml instead of
     // their more specific mime types.
     "text/xml",
     "application/xml",
   };
-  static SnifferHistogram counter(L"mime_sniffer.kSniffableTypes2",
+  static SnifferHistogram counter("mime_sniffer.kSniffableTypes2",
                                   arraysize(kSniffableTypes) + 1);
   for (size_t i = 0; i < arraysize(kSniffableTypes); ++i) {
     if (mime_type == kSniffableTypes[i]) {
       counter.Add(i);
       should_sniff_counter.Add(2);
       return true;
     }
   }
   if (IsUnknownMimeType(mime_type)) {
     // The web server didn't specify a content type or specified a mime
@@ skipping 71 matching lines @@
       result->assign("text/plain");
     // We could change our mind if a binary-looking byte appears later in
     // the content, so we only have enough content if we have the max.
     return content_size >= kMaxBytesToSniff;
   }
 
   return have_enough_content;
 }
 
 }  // namespace net
-