Use lock-free lazy initialization for static histogram references

net/base/mime_sniffer.cc

 // Copyright (c) 2011 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 191 matching lines @@
   MAGIC_HTML_TAG("table")  // Mozilla
   MAGIC_HTML_TAG("a")  // Mozilla
   MAGIC_HTML_TAG("style")  // Mozilla
   MAGIC_HTML_TAG("title")  // Mozilla
   MAGIC_HTML_TAG("b")  // Mozilla
   MAGIC_HTML_TAG("body")  // Mozilla
   MAGIC_HTML_TAG("br")
   MAGIC_HTML_TAG("p")  // Mozilla
 };
 
-static scoped_refptr<base::Histogram> UMASnifferHistogramGet(const char* name,
-                                                             int array_size) {
-  scoped_refptr<base::Histogram> counter =
+static base::Histogram* UMASnifferHistogramGet(const char* name,
+                                               int array_size) {
+  base::Histogram* counter =
       base::LinearHistogram::FactoryGet(name, 1, array_size - 1, array_size,
       base::Histogram::kUmaTargetedHistogramFlag);
   return counter;
 }
 
 // Compare content header to a magic number where magic_entry can contain '.'
 // for single character of anything, allowing some bytes to be skipped.
 static bool MagicCmp(const char* magic_entry, const char* content, size_t len) {
   while (len) {
     if ((*magic_entry != '.') && (*magic_entry != *content))
@@ skipping 76 matching lines @@
   *have_enough_content &= TruncateSize(512, &size);
 
   // 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;
   }
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kSniffableTags2",
-                             arraysize(kSniffableTags));
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("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.get(), result);
+                              counter, result);
 }
 
 // Returns true and sets result if the content matches any of kMagicNumbers.
 // Clears have_enough_content if more data could possibly change the result.
 static bool SniffForMagicNumbers(const char* content,
                                  size_t size,
                                  bool* have_enough_content,
                                  std::string* result) {
   *have_enough_content &= TruncateSize(kBytesRequiredForMagic, &size);
 
   // Check our big table of Magic Numbers
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kMagicNumbers2",
-                             arraysize(kMagicNumbers));
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("mime_sniffer.kMagicNumbers2",
+                                     arraysize(kMagicNumbers));
   return CheckForMagicNumbers(content, size,
                               kMagicNumbers, arraysize(kMagicNumbers),
-                              counter.get(), result);
+                              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.
   // So we match explicitly on this, and don't match other ways of writing
   // it in semantically-equivalent ways.
   MAGIC_STRING("application/xhtml+xml",
                "<html xmlns=\"http://www.w3.org/1999/xhtml\"")
@@ skipping 15 matching lines @@
                      std::string* result) {
   // We allow at most 300 bytes of content before we expect the opening tag.
   *have_enough_content &= TruncateSize(300, &size);
   const char* pos = content;
   const char* const end = content + size;
 
   // 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.
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kMagicXML2",
-                             arraysize(kMagicXML));
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("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;
       continue;
     } else if (base::strncasecmp(pos, "<!DOCTYPE",
                                  sizeof("<!DOCTYPE")-1) == 0) {
       // Skip DOCTYPE declarations.
       ++pos;
       continue;
     }
 
     if (CheckForMagicNumbers(pos, end - pos,
                              kMagicXML, arraysize(kMagicXML),
-                             counter.get(), result))
+                             counter, result))
       return true;
 
     // TODO(evanm): handle RSS 1.0, which is an RDF format and more difficult
     // to identify.
 
     // If we get here, we've hit an initial tag that hasn't matched one of the
     // above tests.  Abort.
     return true;
   }
 
@@ skipping 41 matching lines @@
   // There is no concensus about exactly how to sniff for binary content.
   // * IE 7: Don't sniff for binary looking bytes, but trust the file extension.
   // * Firefox 3.5: Sniff first 4096 bytes for a binary looking byte.
   // Here, we side with FF, but with a smaller buffer. This size was chosen
   // because it is small enough to comfortably fit into a single packet (after
   // allowing for headers) and yet large enough to account for binary formats
   // that have a significant amount of ASCII at the beginning (crbug.com/15314).
   const bool is_truncated = TruncateSize(kMaxBytesToSniff, &size);
 
   // First, we look for a BOM.
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kByteOrderMark2",
-                             arraysize(kByteOrderMark));
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("mime_sniffer.kByteOrderMark2",
+                                     arraysize(kByteOrderMark));
   std::string unused;
   if (CheckForMagicNumbers(content, size,
                            kByteOrderMark, arraysize(kByteOrderMark),
-                           counter.get(), &unused)) {
+                           counter, &unused)) {
     // If there is BOM, we think the buffer is not binary.
     result->assign("text/plain");
     return false;
   }
 
   // Next we look to see if any of the bytes "look binary."
   for (size_t i = 0; i < size; ++i) {
     // If we a see a binary-looking byte, we think the content is binary.
     if (kByteLooksBinary[static_cast<unsigned char>(content[i])]) {
       result->assign("application/octet-stream");
@@ skipping 15 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 */*
     "*/*",
   };
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kUnknownMimeTypes2",
-                             arraysize(kUnknownMimeTypes) + 1);
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("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;
 }
 
 // Returns true and sets result if the content appears to be a crx (chrome
 // extension) file.
 // Clears have_enough_content if more data could possibly change the result.
 static bool SniffCRX(const char* content,
                      size_t size,
                      const GURL& url,
                      const std::string& type_hint,
                      bool* have_enough_content,
                      std::string* result) {
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kSniffCRX", 3);
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("mime_sniffer.kSniffCRX", 3);
 
   // Technically, the crx magic number is just Cr24, but the bytes after that
   // are a version number which changes infrequently. Including it in the
   // sniffing gives us less room for error. If the version number ever changes,
   // we can just add an entry to this list.
   //
   // TODO(aa): If we ever have another magic number, we'll want to pass a
   // histogram into CheckForMagicNumbers(), below, to see which one matched.
   static const struct MagicNumber kCRXMagicNumbers[] = {
     MAGIC_NUMBER("application/x-chrome-extension", "Cr24\x02\x00\x00\x00")
@@ skipping 16 matching lines @@
                            NULL, result)) {
     counter->Add(2);
   } else {
     return false;
   }
 
   return true;
 }
 
 bool ShouldSniffMimeType(const GURL& url, const std::string& mime_type) {
-  scoped_refptr<base::Histogram> should_sniff_counter =
-      UMASnifferHistogramGet("mime_sniffer.ShouldSniffMimeType2", 3);
+  base::Histogram* should_sniff_counter(NULL);
+  if (!should_sniff_counter)

[ramant (doing other things), 2011/04/01 20:05:38]

Should we make this static?

[jar (doing other things), 2011/04/01 21:50:27]

Done.

+    should_sniff_counter =
+        UMASnifferHistogramGet("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") ||
                           url.SchemeIsFile();
   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",
     // We want to sniff application/octet-stream for
     // application/x-chrome-extension, but nothing else.
     "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",
   };
-  scoped_refptr<base::Histogram> counter =
-      UMASnifferHistogramGet("mime_sniffer.kSniffableTypes2",
-                             arraysize(kSniffableTypes) + 1);
+  static base::Histogram* counter(NULL);
+  if (!counter)
+    counter = UMASnifferHistogramGet("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
     // type that we ignore.
@@ skipping 73 matching lines @@
   // Now we look in our large table of magic numbers to see if we can find
   // anything that matches the content.
   if (SniffForMagicNumbers(content, content_size,
                            &have_enough_content, result))
     return true;  // We've matched a magic number.  No more content needed.
 
   return have_enough_content;
 }
 
 }  // namespace net