Report UseCounter metric when observing NotDef glyphs

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 132 matching lines @@
   hb_buffer_set_direction(buffer, direction);
 
   hb_font_t* hb_font = face->GetScaledFont(std::move(current_font_range_set));
   hb_shape(hb_font, buffer, font_features, font_features_size);
 
   return true;
 }
 
 }  // namespace
 
-bool HarfBuzzShaper::ExtractShapeResults(
+void HarfBuzzShaper::ExtractShapeResults(
     RangeData* range_data,
     bool& font_cycle_queued,
     const HolesQueueItem& current_queue_item,
     const SimpleFontData* current_font,
     UScriptCode current_run_script,
     bool is_last_resort,
     ShapeResult* shape_result) const {
   enum ClusterResult { kShaped, kNotDef, kUnknown };
   ClusterResult current_cluster_result = kUnknown;
   ClusterResult previous_cluster_result = kUnknown;
   unsigned previous_cluster = 0;
   unsigned current_cluster = 0;
 
   // Find first notdef glyph in buffer.
   unsigned num_glyphs = hb_buffer_get_length(range_data->buffer);
   hb_glyph_info_t* glyph_info =
       hb_buffer_get_glyph_infos(range_data->buffer, 0);
 
   unsigned last_change_position = 0;
 
-  if (!num_glyphs) {
-    DLOG(ERROR) << "HarfBuzz returned empty glyph buffer after shaping.";
-    return false;
-  }
+  if (!num_glyphs)
+    return;
 
   for (unsigned glyph_index = 0; glyph_index <= num_glyphs; ++glyph_index) {
     // Iterating by clusters, check for when the state switches from shaped
     // to non-shaped and vice versa. Taking into account the edge cases of
     // beginning of the run and end of the run.
     previous_cluster = current_cluster;
     current_cluster = glyph_info[glyph_index].cluster;
 
     if (glyph_index < num_glyphs) {
       // Still the same cluster, merge shaping status.
       if (previous_cluster == current_cluster && glyph_index != 0) {
         if (glyph_info[glyph_index].codepoint == 0) {
           current_cluster_result = kNotDef;
         } else {
           // We can only call the current cluster fully shapped, if
           // all characters that are part of it are shaped, so update
-          // currentClusterResult to Shaped only if the previous
+          // currentClusterResult to kShaped only if the previous
           // characters have been shaped, too.
           current_cluster_result =
               current_cluster_result == kShaped ? kShaped : kNotDef;
         }
         continue;
       }
       // We've moved to a new cluster.
       previous_cluster_result = current_cluster_result;
       current_cluster_result =
           glyph_info[glyph_index].codepoint == 0 ? kNotDef : kShaped;
     } else {
-      // The code below operates on the "flanks"/changes between NotDef
-      // and Shaped. In order to keep the code below from explictly
+      // The code below operates on the "flanks"/changes between kNotDef
+      // and kShaped. In order to keep the code below from explictly
       // dealing with character indices and run end, we explicitly
       // terminate the cluster/run here by setting the result value to the
       // opposite of what it was, leading to atChange turning true.
       previous_cluster_result = current_cluster_result;
       current_cluster_result =
           current_cluster_result == kNotDef ? kShaped : kNotDef;
     }
 
     bool at_change = (previous_cluster_result != current_cluster_result) &&
                      previous_cluster_result != kUnknown;
@@ skipping 61 matching lines @@
     // choice than adding boxes to the ShapeResult.
     if ((current_cluster_result == kNotDef && num_characters) ||
         is_last_resort) {
       hb_direction_t direction = range_data->HarfBuzzDirection(current_font);
       // Here we need to specify glyph positions.
       ShapeResult::RunInfo* run = new ShapeResult::RunInfo(
           current_font, direction, ICUScriptToHBScript(current_run_script),
           start_index, num_glyphs_to_insert, num_characters);
       shape_result->InsertRun(WTF::WrapUnique(run), last_change_position,
                               num_glyphs_to_insert, range_data->buffer);
+      range_data->font->ReportNotDefGlyph();
     }
     last_change_position = glyph_index;
   }
-  return true;
 }
 
 static inline const SimpleFontData* FontDataAdjustedForOrientation(
     const SimpleFontData* original_font,
     FontOrientation run_orientation,
     OrientationIterator::RenderOrientation render_orientation) {
   if (!IsVerticalBaseline(run_orientation))
     return original_font;
 
   if (run_orientation == FontOrientation::kVerticalRotated ||
@@ skipping 366 matching lines @@
     if (!ShapeRange(range_data->buffer,
                     range_data->font_features.IsEmpty()
                         ? 0
                         : range_data->font_features.data(),
                     range_data->font_features.size(),
                     direction_and_small_caps_adjusted_font,
                     current_font_data_for_range_set->Ranges(), segment.script,
                     direction, language))
       DLOG(ERROR) << "Shaping range failed.";
 
-    if (!ExtractShapeResults(range_data, font_cycle_queued, current_queue_item,
-                             direction_and_small_caps_adjusted_font,
-                             segment.script, !fallback_iterator->HasNext(),
-                             result))
-      DLOG(ERROR) << "Shape result extraction failed.";
+    ExtractShapeResults(range_data, font_cycle_queued, current_queue_item,
+                        direction_and_small_caps_adjusted_font, segment.script,
+                        !fallback_iterator->HasNext(), result);
 
     hb_buffer_reset(range_data->buffer);
   }
 }
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::Shape(const Font* font,
                                               TextDirection direction,
                                               unsigned start,
                                               unsigned end) const {
   DCHECK(end >= start);
@@ skipping 25 matching lines @@
   }
   return result.Release();
 }
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::Shape(const Font* font,
                                               TextDirection direction) const {
   return Shape(font, direction, 0, text_length_);
 }
 
 }  // namespace blink