reflow comments in core/frame

third_party/WebKit/Source/core/frame/UseCounter.cpp

 /*
  * Copyright (C) 2012 Google, Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1040 matching lines @@
     case CSSPropertyOffsetPath:
       return 541;
     case CSSPropertyOffsetRotation:
       return 542;
     case CSSPropertyOffset:
       return 543;
     case CSSPropertyOffsetAnchor:
       return 544;
     case CSSPropertyOffsetPosition:
       return 545;
-    // 1. Add new features above this line (don't change the assigned numbers of the existing
-    // items).
+    // 1. Add new features above this line (don't change the assigned numbers of
+    // the existing items).
     // 2. Update kMaximumCSSSampleId with the new maximum value.
     // 3. Run the update_use_counter_css.py script in
     // chromium/src/tools/metrics/histograms to update the UMA histogram names.
 
     case CSSPropertyInvalid:
       ASSERT_NOT_REACHED();
       return 0;
   }
 
   ASSERT_NOT_REACHED();
@@ skipping 17 matching lines @@
 void UseCounter::recordMeasurement(Feature feature) {
   if (m_muteCount)
     return;
 
   DCHECK(feature != OBSOLETE_PageDestruction &&
          feature !=
              PageVisits);  // PageDestruction is reserved as a scaling factor.
   DCHECK(feature < NumberOfFeatures);
 
   if (!m_featuresRecorded.quickGet(feature)) {
-    // Note that HTTPArchive tooling looks specifically for this event - see https://github.com/HTTPArchive/httparchive/issues/59
+    // Note that HTTPArchive tooling looks specifically for this event - see
+    // https://github.com/HTTPArchive/httparchive/issues/59
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
                  "FeatureFirstUsed", "feature", feature);
     featuresHistogram().count(feature);
     m_featuresRecorded.quickSet(feature);
   }
   m_legacyCounter.countFeature(feature);
 }
 
 bool UseCounter::hasRecordedMeasurement(Feature feature) const {
   if (m_muteCount)
@@ skipping 102 matching lines @@
 }
 
 void UseCounter::count(CSSParserMode cssParserMode, CSSPropertyID property) {
   DCHECK(property >= firstCSSProperty);
   DCHECK(property <= lastUnresolvedCSSProperty);
 
   if (!isUseCounterEnabledForMode(cssParserMode) || m_muteCount)
     return;
 
   if (!m_CSSRecorded.quickGet(property)) {
-    // Note that HTTPArchive tooling looks specifically for this event - see https://github.com/HTTPArchive/httparchive/issues/59
+    // Note that HTTPArchive tooling looks specifically for this event - see
+    // https://github.com/HTTPArchive/httparchive/issues/59
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.feature_usage"),
                  "CSSFeatureFirstUsed", "feature", property);
     cssHistogram().count(mapCSSPropertyIdToCSSSampleIdForHistogram(property));
     m_CSSRecorded.quickSet(property);
   }
   m_legacyCounter.countCSS(property);
 }
 
 void UseCounter::count(Feature feature) {
   DCHECK(Deprecation::deprecationMessage(feature).isEmpty());
@@ skipping 15 matching lines @@
 UseCounter* UseCounter::getFrom(const StyleSheetContents* sheetContents) {
   // FIXME: We may want to handle stylesheets that have multiple owners
   //        https://crbug.com/242125
   if (sheetContents && sheetContents->hasSingleOwnerNode())
     return getFrom(sheetContents->singleOwnerDocument());
   return 0;
 }
 
 EnumerationHistogram& UseCounter::featuresHistogram() const {
   // TODO(rbyers): Fix the SVG case.  crbug.com/236262
-  // Eg. every SVGImage has it's own Page instance, they should probably all be delegating
-  // their UseCounter to the containing Page.  For now just use a separate histogram.
+  // Eg. every SVGImage has it's own Page instance, they should probably all be
+  // delegating their UseCounter to the containing Page.  For now just use a
+  // separate histogram.
   DEFINE_STATIC_LOCAL(blink::EnumerationHistogram, histogram,
                       ("WebCore.UseCounter_TEST.Features",
                        blink::UseCounter::NumberOfFeatures));
   DEFINE_STATIC_LOCAL(blink::EnumerationHistogram, svgHistogram,
                       ("WebCore.UseCounter_TEST.SVGImage.Features",
                        blink::UseCounter::NumberOfFeatures));
 
   return m_context == SVGImageContext ? svgHistogram : histogram;
 }
 
 EnumerationHistogram& UseCounter::cssHistogram() const {
   DEFINE_STATIC_LOCAL(
       blink::EnumerationHistogram, histogram,
       ("WebCore.UseCounter_TEST.CSSProperties", kMaximumCSSSampleId));
   DEFINE_STATIC_LOCAL(
       blink::EnumerationHistogram, svgHistogram,
       ("WebCore.UseCounter_TEST.SVGImage.CSSProperties", kMaximumCSSSampleId));
 
   return m_context == SVGImageContext ? svgHistogram : histogram;
 }
 
 /*
  *
- * LEGACY metrics support - WebCore.FeatureObserver is to be superceded by WebCore.UseCounter
+ * LEGACY metrics support - WebCore.FeatureObserver is to be superceded by
+ * WebCore.UseCounter
  *
  */
 
 static EnumerationHistogram& featureObserverHistogram() {
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, histogram,
       ("WebCore.FeatureObserver", UseCounter::NumberOfFeatures));
   return histogram;
 }
 
 UseCounter::LegacyCounter::LegacyCounter()
     : m_featureBits(NumberOfFeatures),
       m_CSSBits(lastUnresolvedCSSProperty + 1) {}
 
 UseCounter::LegacyCounter::~LegacyCounter() {
-  // PageDestruction was intended to be used as a scale, but it's broken (due to fast shutdown).
-  // See https://crbug.com/597963.
+  // PageDestruction was intended to be used as a scale, but it's broken (due to
+  // fast shutdown).  See https://crbug.com/597963.
   featureObserverHistogram().count(OBSOLETE_PageDestruction);
   updateMeasurements();
 }
 
 void UseCounter::LegacyCounter::countFeature(Feature feature) {
   m_featureBits.quickSet(feature);
 }
 
 void UseCounter::LegacyCounter::countCSS(CSSPropertyID property) {
   m_CSSBits.quickSet(property);
 }
 
 void UseCounter::LegacyCounter::updateMeasurements() {
   EnumerationHistogram& featureHistogram = featureObserverHistogram();
   featureHistogram.count(PageVisits);
   for (size_t i = 0; i < NumberOfFeatures; ++i) {
     if (m_featureBits.quickGet(i))
       featureHistogram.count(i);
   }
   // Clearing count bits is timing sensitive.
   m_featureBits.clearAll();
 
-  // FIXME: Sometimes this function is called more than once per page. The following
-  //        bool guards against incrementing the page count when there are no CSS
-  //        bits set. https://crbug.com/236262.
+  // FIXME: Sometimes this function is called more than once per page. The
+  // following bool guards against incrementing the page count when there are no
+  // CSS bits set. https://crbug.com/236262.
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, cssPropertiesHistogram,
       ("WebCore.FeatureObserver.CSSProperties", kMaximumCSSSampleId));
   bool needsPagesMeasuredUpdate = false;
   for (size_t i = firstCSSProperty; i <= lastUnresolvedCSSProperty; ++i) {
     if (m_CSSBits.quickGet(i)) {
       int cssSampleId = mapCSSPropertyIdToCSSSampleIdForHistogram(
           static_cast<CSSPropertyID>(i));
       cssPropertiesHistogram.count(cssSampleId);
       needsPagesMeasuredUpdate = true;
     }
   }
 
   if (needsPagesMeasuredUpdate)
     cssPropertiesHistogram.count(totalPagesMeasuredCSSSampleId());
 
   m_CSSBits.clearAll();
 }
 
 }  // namespace blink