Formatting.

Author: garretrieger

common/woff2.cc

@@ -15,7 +15,8 @@ using woff2::WOFF2StringOut;
 
 namespace common {
 
-StatusOr<FontData> Woff2::EncodeWoff2(string_view font, bool glyf_transform, int quality) {
+StatusOr<FontData> Woff2::EncodeWoff2(string_view font, bool glyf_transform,
+                                      int quality) {
   WOFF2Params params;
   params.brotli_quality = quality;
   params.allow_transforms = glyf_transform;

common/woff2.h

@@ -9,7 +9,8 @@ namespace common {
 
 struct Woff2 {
   static absl::StatusOr<FontData> EncodeWoff2(absl::string_view font,
-                                              bool glyf_transform = true, int quality = 11);
+                                              bool glyf_transform = true,
+                                              int quality = 11);
   static absl::StatusOr<FontData> DecodeWoff2(absl::string_view font);
 };
 

ift/encoder/candidate_merge.cc

@@ -14,6 +14,7 @@
 #include "common/font_helper.h"
 #include "common/int_set.h"
 #include "common/try.h"
+#include "common/woff2.h"
 #include "ift/encoder/activation_condition.h"
 #include "ift/encoder/glyph_groupings.h"
 #include "ift/encoder/requested_segmentation_information.h"
@@ -22,7 +23,6 @@
 #include "ift/encoder/subset_definition.h"
 #include "ift/encoder/types.h"
 #include "ift/glyph_keyed_diff.h"
-#include "common/woff2.h"
 
 namespace ift::encoder {
 
@@ -217,24 +217,26 @@ StatusOr<uint32_t> CandidateMerge::Woff2SizeOf(hb_face_t* original_face,
   return (double)woff2.size();
 }
 
-static StatusOr<int64_t> InitFontDelta(const SegmentationContext& context, const SegmentSet& merged_segments) {
+static StatusOr<int64_t> InitFontDelta(const SegmentationContext& context,
+                                       const SegmentSet& merged_segments) {
   int quality = context.GetMergeStrategy().BrotliQuality();
   SubsetDefinition init_def = context.SegmentationInfo().InitFontSegment();
-  int64_t before = TRY(CandidateMerge::Woff2SizeOf(context.original_face.get(), init_def, quality));
+  int64_t before = TRY(CandidateMerge::Woff2SizeOf(context.original_face.get(),
+                                                   init_def, quality));
 
   for (segment_index_t s : merged_segments) {
     init_def.Union(context.SegmentationInfo().Segments().at(s).Definition());
   }
 
-  int64_t after = TRY(CandidateMerge::Woff2SizeOf(context.original_face.get(), init_def, quality));
+  int64_t after = TRY(CandidateMerge::Woff2SizeOf(context.original_face.get(),
+                                                  init_def, quality));
 
   return after - before;
 }
 
-StatusOr<double> CandidateMerge::ComputeCostDelta(const SegmentationContext& context,
-                                                  const SegmentSet& merged_segments,
-                                                  std::optional<const Segment*> merged_segment,
-                                                  uint32_t new_patch_size) {
+StatusOr<double> CandidateMerge::ComputeCostDelta(
+    const SegmentationContext& context, const SegmentSet& merged_segments,
+    std::optional<const Segment*> merged_segment, uint32_t new_patch_size) {
   bool moving_to_init_font = !merged_segment.has_value();
   const uint32_t per_request_overhead =
       context.GetMergeStrategy().NetworkOverheadCost();
@@ -262,10 +264,12 @@ StatusOr<double> CandidateMerge::ComputeCostDelta(const SegmentationContext& con
     // "new_patch_size", add the associated cost.
     double p = (*merged_segment)->Probability();
     cost_delta += p * (new_patch_size + per_request_overhead);
-    VLOG(1) << "  cost_delta for merge of " << merged_segments.ToString() << " =";
+    VLOG(1) << "  cost_delta for merge of " << merged_segments.ToString()
+            << " =";
 
-    VLOG(1) << "    + (" << p << " * " << (new_patch_size + per_request_overhead)
-            << ") -> " << cost_delta << " [merged patch]";
+    VLOG(1) << "    + (" << p << " * "
+            << (new_patch_size + per_request_overhead) << ") -> " << cost_delta
+            << " [merged patch]";
   } else {
     // Otherwise the merged segments are being moved to the init font, compute
     // the resulting size delta.
@@ -307,8 +311,10 @@ StatusOr<double> CandidateMerge::ComputeCostDelta(const SegmentationContext& con
       // the cost addition as usual.
       SegmentSet condition_segments = c.TriggeringSegments();
       condition_segments.subtract(merged_segments);
-      ActivationCondition new_condition = ActivationCondition::and_segments(condition_segments, 0);
-      double p = TRY(c.Probability(segments, *context.GetMergeStrategy().ProbabilityCalculator()));
+      ActivationCondition new_condition =
+          ActivationCondition::and_segments(condition_segments, 0);
+      double p = TRY(c.Probability(
+          segments, *context.GetMergeStrategy().ProbabilityCalculator()));
       double d = p * (size + per_request_overhead);
       VLOG(1) << "    + " << d << " [modified patch " << c.ToString() << "]";
       cost_delta += d;
@@ -371,10 +377,12 @@ StatusOr<std::optional<CandidateMerge>> CandidateMerge::AssessMerge(
     // threshold on the segments to be merged that will allow us to quickly
     // discard merges which can't possibily beat the current best.
     unsigned segment_to_merge = segments_to_merge.min().value();
-    const GlyphSet& glyphs = context.glyph_condition_set.GlyphsWithSegment(segment_to_merge);
+    const GlyphSet& glyphs =
+        context.glyph_condition_set.GlyphsWithSegment(segment_to_merge);
     unsigned segment_to_merge_size = 0;
     if (!glyphs.empty()) {
-      segment_to_merge_size = TRY(context.patch_size_cache->GetPatchSize(glyphs));
+      segment_to_merge_size =
+          TRY(context.patch_size_cache->GetPatchSize(glyphs));
     }
     double threshold = best_merge_candidate->InertProbabilityThreshold(
         segment_to_merge_size, merged_segment.Probability());

ift/encoder/candidate_merge.h

@@ -109,7 +109,8 @@ struct CandidateMerge {
                                    network_overhead +
                                    BEST_CASE_MERGE_SIZE_DELTA;
     double total_base_size = base_size + network_overhead;
-    double total_patch_size = patch_size > 0 ? patch_size + network_overhead : 0;
+    double total_patch_size =
+        patch_size > 0 ? patch_size + network_overhead : 0;
 
     double numerator = merged_probability * best_case_merged_size -
                        base_probability * total_base_size - cost_delta;
@@ -131,10 +132,10 @@ struct CandidateMerge {
       SegmentationContext& context, segment_index_t base_segment_index,
       const common::GlyphSet& glyphs);
 
-  static absl::StatusOr<double> ComputeCostDelta(const SegmentationContext& context,
-                                                 const common::SegmentSet& merged_segments,
-                                                 std::optional<const Segment*> merged_segment,
-                                                 uint32_t new_patch_size);
+  static absl::StatusOr<double> ComputeCostDelta(
+      const SegmentationContext& context,
+      const common::SegmentSet& merged_segments,
+      std::optional<const Segment*> merged_segment, uint32_t new_patch_size);
 
   static absl::StatusOr<uint32_t> Woff2SizeOf(hb_face_t* original_face,
                                               const SubsetDefinition& def,

ift/encoder/closure_glyph_segmenter.cc

@@ -274,9 +274,10 @@ Status CollectExclusiveCandidateMerges(
       continue;
     }
 
-    if (context.InertSegments().contains(*it) && context.glyph_condition_set.GlyphsWithSegment(*it).empty()) {
-      // this segment is effectively a noop, it interacts with nothing and has no glyphs
-      // so don't consider it for a merge.
+    if (context.InertSegments().contains(*it) &&
+        context.glyph_condition_set.GlyphsWithSegment(*it).empty()) {
+      // this segment is effectively a noop, it interacts with nothing and has
+      // no glyphs so don't consider it for a merge.
       continue;
     }
 
@@ -509,41 +510,50 @@ static StatusOr<std::vector<Segment>> ToSegments(
   return segments;
 }
 
-Status ClosureGlyphSegmenter::MoveSegmentsToInitFont(SegmentationContext& context) const {
+Status ClosureGlyphSegmenter::MoveSegmentsToInitFont(
+    SegmentationContext& context) const {
   if (!context.GetMergeStrategy().InitFontMergeThreshold().has_value()) {
-    return absl::FailedPreconditionError("Cannot be called when there is no merge threshold configured.");
+    return absl::FailedPreconditionError(
+        "Cannot be called when there is no merge threshold configured.");
   }
 
   double threshold = *context.GetMergeStrategy().InitFontMergeThreshold();
 
-  VLOG(0) << "Checking if there are any segments which should be moved into the initial font.";
+  VLOG(0) << "Checking if there are any segments which should be moved into "
+             "the initial font.";
 
-  SubsetDefinition initial_segment = context.SegmentationInfo().InitFontSegment();
+  SubsetDefinition initial_segment =
+      context.SegmentationInfo().InitFontSegment();
   bool change_made;
   do {
     change_made = false;
     SegmentSet segments_to_move;
-    for (const auto& [c, glyphs] : context.glyph_groupings.ConditionsAndGlyphs()) {
+    for (const auto& [c, glyphs] :
+         context.glyph_groupings.ConditionsAndGlyphs()) {
       SegmentSet candidate_segments = c.TriggeringSegments();
       if (!candidate_segments.intersects(context.ActiveSegments())) {
-        // Only do this check for things involving active segments, this let's us skip
-        // checks for conditions are are extremely unlikely to benefit from merging
-        // into the init font.
+        // Only do this check for things involving active segments, this let's
+        // us skip checks for conditions are are extremely unlikely to benefit
+        // from merging into the init font.
         continue;
       }
 
-      double delta = TRY(CandidateMerge::ComputeCostDelta(context, candidate_segments, std::nullopt, 0));
-      if (delta >= threshold * (double) candidate_segments.size()) {
+      double delta = TRY(CandidateMerge::ComputeCostDelta(
+          context, candidate_segments, std::nullopt, 0));
+      if (delta >= threshold * (double)candidate_segments.size()) {
         // Merging doesn't improve cost, skip.
         continue;
       }
 
-      // TODO(garretrieger): to get a more accurate picture we should consider comparing
+      // TODO(garretrieger): to get a more accurate picture we should consider
+      // comparing
       //   to an updated init subset definition on each iteration.
       segments_to_move.union_set(candidate_segments);
-      VLOG(0) << "  Moving segments " << candidate_segments.ToString() << " into the initial font (cost delta = " << delta << ")";
+      VLOG(0) << "  Moving segments " << candidate_segments.ToString()
+              << " into the initial font (cost delta = " << delta << ")";
       for (segment_index_t s : segments_to_move) {
-        initial_segment.Union(context.SegmentationInfo().Segments()[s].Definition());
+        initial_segment.Union(
+            context.SegmentationInfo().Segments()[s].Definition());
       }
 
       TRYV(context.ReassignInitSubset(initial_segment, segments_to_move));
@@ -552,7 +562,8 @@ Status ClosureGlyphSegmenter::MoveSegmentsToInitFont(SegmentationContext& contex
     }
   } while (change_made);
 
-  VLOG(0) << "Initial font now has " << initial_segment.codepoints.size() << " codepoints.";
+  VLOG(0) << "Initial font now has " << initial_segment.codepoints.size()
+          << " codepoints.";
   return absl::OkStatus();
 }
 
@@ -579,9 +590,11 @@ StatusOr<GlyphSegmentation> ClosureGlyphSegmenter::CodepointToGlyphSegments(
     return context.ToGlyphSegmentation();
   }
 
-  // ### First phase of merging is to check for any patches which should be moved to the initial font
+  // ### First phase of merging is to check for any patches which should be
+  // moved to the initial font
   //     (eg. cases where the probability of a patch is ~1.0).
-  if (context.GetMergeStrategy().UseCosts() && context.GetMergeStrategy().InitFontMergeThreshold().has_value()) {
+  if (context.GetMergeStrategy().UseCosts() &&
+      context.GetMergeStrategy().InitFontMergeThreshold().has_value()) {
     TRYV(MoveSegmentsToInitFont(context));
   }
 
@@ -668,9 +681,10 @@ StatusOr<SegmentationCost> ClosureGlyphSegmenter::TotalCost(
     segments.push_back(std::move(s));
   }
 
-  double init_font_size =
-      TRY(CandidateMerge::Woff2SizeOf(original_face, segmentation.InitialFontSegment(), 11));
-  double non_ift_font_size = TRY(CandidateMerge::Woff2SizeOf(original_face, non_ift, 11));
+  double init_font_size = TRY(CandidateMerge::Woff2SizeOf(
+      original_face, segmentation.InitialFontSegment(), 11));
+  double non_ift_font_size =
+      TRY(CandidateMerge::Woff2SizeOf(original_face, non_ift, 11));
 
   // TODO(garretrieger): for the total cost we need to also add in the table
   // keyed patch costs

ift/encoder/closure_glyph_segmenter.h

@@ -64,8 +64,8 @@ class ClosureGlyphSegmenter {
       hb_face_t* original_face, const GlyphSegmentation& segmentation,
       const freq::ProbabilityCalculator& probability_calculator) const;
 
-  private:
-    absl::Status MoveSegmentsToInitFont(SegmentationContext& context) const;
+ private:
+  absl::Status MoveSegmentsToInitFont(SegmentationContext& context) const;
 };
 
 }  // namespace ift::encoder

ift/encoder/closure_glyph_segmenter_test.cc

@@ -784,7 +784,11 @@ TEST_F(ClosureGlyphSegmenterTest, NoGlyphSegments_CostMerging) {
 
   auto segmentation = segmenter.CodepointToGlyphSegments(
       roboto.get(), {0x106 /* Cacute */},
-      {{'A'}, {'B'}, {'C'},},
+      {
+          {'A'},
+          {'B'},
+          {'C'},
+      },
       *MergeStrategy::CostBased(std::move(frequencies)));
   ASSERT_TRUE(segmentation.ok()) << segmentation.status();
 
@@ -793,7 +797,7 @@ TEST_F(ClosureGlyphSegmenterTest, NoGlyphSegments_CostMerging) {
   std::vector<SubsetDefinition> expected_segments = {
       {'A', 'B'},
       {},
-      {'C'}, // C glyph was already pulled in to the init font, so no merge
+      {'C'},  // C glyph was already pulled in to the init font, so no merge
   };
   ASSERT_EQ(segmentation->Segments(), expected_segments);
 
@@ -806,29 +810,28 @@ if (s0) then p0
 )");
 }
 
-
 TEST_F(ClosureGlyphSegmenterTest, InitFontMerging) {
   // In this test we enable merging of segments into the init font
   UnicodeFrequencies frequencies{
       {{'a', 'a'}, 100},
-      {{'b', 'b'},  50},
-      {{'c', 'c'},  50},
+      {{'b', 'b'}, 50},
+      {{'c', 'c'}, 50},
       {{'d', 'd'}, 100},
 
       // b and c co-occur
-      {{'b', 'c'},  50},
+      {{'b', 'c'}, 50},
   };
 
-  MergeStrategy strategy = *MergeStrategy::BigramCostBased(std::move(frequencies));
+  MergeStrategy strategy =
+      *MergeStrategy::BigramCostBased(std::move(frequencies));
   strategy.SetInitFontMergeThreshold(-75);
 
   auto segmentation = segmenter.CodepointToGlyphSegments(
-      roboto.get(), {},
-      {{'a'}, {'d'}, {'b'}, {'c'}},
-      strategy);
+      roboto.get(), {}, {{'a'}, {'d'}, {'b'}, {'c'}}, strategy);
   ASSERT_TRUE(segmentation.ok()) << segmentation.status();
 
-  //  'a' and 'd' will be moved to the init font, leaving only two segments 'b', 'c'
+  //  'a' and 'd' will be moved to the init font, leaving only two segments 'b',
+  //  'c'
   std::vector<SubsetDefinition> expected_segments = {
       {},
       {},
@@ -848,16 +851,14 @@ TEST_F(ClosureGlyphSegmenterTest, InitFontMerging_CommonGlyphs) {
   UnicodeFrequencies frequencies{
       {{'A', 'A'}, 1},
       {{'C', 'C'}, 1},
-      {{0x106, 0x106}, 100}, // Cacute (contains C glyph)
+      {{0x106, 0x106}, 100},  // Cacute (contains C glyph)
   };
 
   MergeStrategy strategy = *MergeStrategy::CostBased(std::move(frequencies));
   strategy.SetInitFontMergeThreshold(-75);
 
   auto segmentation = segmenter.CodepointToGlyphSegments(
-      roboto.get(), {},
-      {{0x106}, {'A'}, {'C'}},
-      strategy);
+      roboto.get(), {}, {{0x106}, {'A'}, {'C'}}, strategy);
   ASSERT_TRUE(segmentation.ok()) << segmentation.status();
 
   std::vector<SubsetDefinition> expected_segments = {
@@ -867,7 +868,8 @@ TEST_F(ClosureGlyphSegmenterTest, InitFontMerging_CommonGlyphs) {
   };
   ASSERT_EQ(segmentation->Segments(), expected_segments);
 
-  // C get's covered by the Cacute merge into int, so only A is left in the patch.
+  // C get's covered by the Cacute merge into int, so only A is left in the
+  // patch.
   ASSERT_EQ(segmentation->ToString(),
             R"(initial font: { gid0, gid39, gid117, gid700 }
 p0: { gid37 }

ift/encoder/requested_segmentation_information.cc

@@ -9,8 +9,7 @@ namespace ift::encoder {
 RequestedSegmentationInformation::RequestedSegmentationInformation(
     std::vector<Segment> segments, SubsetDefinition init_font_segment,
     GlyphClosureCache& closure_cache)
-    : segments_(std::move(segments)),
-      init_font_segment_() {
+    : segments_(std::move(segments)), init_font_segment_() {
   ReassignInitSubset(closure_cache, std::move(init_font_segment), {});
 }
 

ift/encoder/requested_segmentation_information.h

@@ -33,7 +33,9 @@ class RequestedSegmentationInformation {
     return base_segment.Definition().codepoints.size();
   }
 
-  void ReassignInitSubset(GlyphClosureCache& closure_cache, SubsetDefinition new_def, const common::SegmentSet& removed_segments) {
+  void ReassignInitSubset(GlyphClosureCache& closure_cache,
+                          SubsetDefinition new_def,
+                          const common::SegmentSet& removed_segments) {
     for (segment_index_t s : removed_segments) {
       segments_[s].Clear();
     }