Update woff2 to 2bc6acf

third_party/woff2/src/glyph.cc

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 104 matching lines @@
     if (!buffer.Skip(glyph->instructions_size)) {
       return FONT_COMPRESSION_FAILURE();
     }
 
     // Read the run-length coded flags.
     std::vector<std::vector<uint8_t> > flags(num_contours);
     uint8_t flag = 0;
     uint8_t flag_repeat = 0;
     for (int i = 0; i < num_contours; ++i) {
       flags[i].resize(glyph->contours[i].size());
-      for (int j = 0; j < glyph->contours[i].size(); ++j) {
+      for (size_t j = 0; j < glyph->contours[i].size(); ++j) {
         if (flag_repeat == 0) {
           if (!buffer.ReadU8(&flag)) {
             return FONT_COMPRESSION_FAILURE();
           }
           if (flag & kFLAG_REPEAT) {
             if (!buffer.ReadU8(&flag_repeat)) {
               return FONT_COMPRESSION_FAILURE();
             }
           }
         } else {
           flag_repeat--;
         }
         flags[i][j] = flag;
         glyph->contours[i][j].on_curve = flag & kFLAG_ONCURVE;
       }
     }
 
     // Read the x coordinates.
     int prev_x = 0;
     for (int i = 0; i < num_contours; ++i) {
-      for (int j = 0; j < glyph->contours[i].size(); ++j) {
+      for (size_t j = 0; j < glyph->contours[i].size(); ++j) {
         uint8_t flag = flags[i][j];
         if (flag & kFLAG_XSHORT) {
           // single byte x-delta coord value
           uint8_t x_delta;
           if (!buffer.ReadU8(&x_delta)) {
             return FONT_COMPRESSION_FAILURE();
           }
           int sign = (flag & kFLAG_XREPEATSIGN) ? 1 : -1;
           glyph->contours[i][j].x = prev_x + sign * x_delta;
         } else {
           // double byte x-delta coord value
           int16_t x_delta = 0;
           if (!(flag & kFLAG_XREPEATSIGN)) {
             if (!buffer.ReadS16(&x_delta)) {
               return FONT_COMPRESSION_FAILURE();
             }
           }
           glyph->contours[i][j].x = prev_x + x_delta;
         }
         prev_x = glyph->contours[i][j].x;
       }
     }
 
     // Read the y coordinates.
     int prev_y = 0;
     for (int i = 0; i < num_contours; ++i) {
-      for (int j = 0; j < glyph->contours[i].size(); ++j) {
+      for (size_t j = 0; j < glyph->contours[i].size(); ++j) {
         uint8_t flag = flags[i][j];
         if (flag & kFLAG_YSHORT) {
           // single byte y-delta coord value
           uint8_t y_delta;
           if (!buffer.ReadU8(&y_delta)) {
             return FONT_COMPRESSION_FAILURE();
           }
           int sign = (flag & kFLAG_YREPEATSIGN) ? 1 : -1;
           glyph->contours[i][j].y = prev_y + sign * y_delta;
         } else {
@@ skipping 187 matching lines @@
     StoreInstructions(glyph, &offset, dst);
     if (!StorePoints(glyph, &offset, dst, *dst_size)) {
       return FONT_COMPRESSION_FAILURE();
     }
   }
   *dst_size = offset;
   return true;
 }
 
 } // namespace woff2