Prevent potential leaking of memory by using SkString and SkTArray.

src/ports/SkFontConfigInterface_android.cpp

 
 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkTypeface_android.h"
@@ skipping 156 matching lines @@
             return true;
         }
     }
     return false;
 }
 
 #ifndef SK_FONT_FILE_PREFIX
     #define SK_FONT_FILE_PREFIX          "/fonts/"
 #endif
 
-static void get_path_for_sys_fonts(SkString* full, const char name[]) {
+static void get_path_for_sys_fonts(SkString* full, const SkString& name) {
     if (gTestFontFilePrefix) {
         full->set(gTestFontFilePrefix);
     } else {
         full->set(getenv("ANDROID_ROOT"));
         full->append(SK_FONT_FILE_PREFIX);
     }
     full->append(name);
 }
 
 static void insert_into_name_dict(SkTDict<FamilyRecID>& familyNameDict,
@@ skipping 25 matching lines @@
     for (int i = 0; i < fontFamilies.count(); ++i) {
         FontFamily* family = fontFamilies[i];
 
         // defer initializing the familyRec until we can be sure that at least
         // one of it's children contains a valid font file
         FamilyRec* familyRec = NULL;
         FamilyRecID familyRecID = INVALID_FAMILY_REC_ID;
 
         for (int j = 0; j < family->fFontFiles.count(); ++j) {
             SkString filename;
-            get_path_for_sys_fonts(&filename, family->fFontFiles[j]->fFileName);
+            get_path_for_sys_fonts(&filename, family->fFontFiles[j].fFileName);
 
             if (has_font(fFonts, filename)) {
                 SkDebugf("---- system font and fallback font files specify a duplicate "
                         "font %s, skipping the second occurrence", filename.c_str());
                 continue;
             }
 
             FontRec& fontRec = fFonts.push_back();
             fontRec.fFileName = filename;
             fontRec.fStyle = SkTypeface::kNormal;
@@ skipping 24 matching lines @@
             }
 
             // create a familyRec now that we know that at least one font in
             // the family is valid
             if (familyRec == NULL) {
                 familyRec = &fFontFamilies.push_back();
                 familyRecID = fFontFamilies.count() - 1;
                 fontRec.fFamilyRecID = familyRecID;
 
                 familyRec->fIsFallbackFont = family->fIsFallbackFont;
-                familyRec->fPaintOptions = family->fFontFiles[j]->fPaintOptions;
+                familyRec->fPaintOptions = family->fFontFiles[j].fPaintOptions;
 
-            } else if (familyRec->fPaintOptions != family->fFontFiles[j]->fPaintOptions) {
+            } else if (familyRec->fPaintOptions != family->fFontFiles[j].fPaintOptions) {
                 SkDebugf("Every font file within a family must have identical"
                          "language and variant attributes");
                 sk_throw();
             }
 
             // add this font to the current familyRec
             if (INVALID_FONT_REC_ID != familyRec->fFontRecID[fontRec.fStyle]) {
                 DEBUG_FONT(("Overwriting familyRec for style[%d] old,new:(%d,%d)",
                             fontRec.fStyle, familyRec->fFontRecID[fontRec.fStyle],
                             fontRecID));
             }
             familyRec->fFontRecID[fontRec.fStyle] = fontRecID;
         }
 
         if (familyRec) {
             if (familyRec->fIsFallbackFont) {
                 // add the font to the appropriate fallback chains and also insert a
                 // unique name into the familyNameDict for internal usage
                 addFallbackFamily(familyRecID);
             } else {
                 // add the names that map to this family to the dictionary for easy lookup
-                const SkTDArray<const char*>& names = family->fNames;
-                if (names.isEmpty()) {
+                const SkTArray<SkString>& names = family->fNames;
+                if (names.empty()) {
                     SkDEBUGFAIL("ERROR: non-fallback font with no name");
                     continue;
                 }
 
                 for (int i = 0; i < names.count(); i++) {
-                    insert_into_name_dict(fFamilyNameDict, names[i], familyRecID);
+                    insert_into_name_dict(fFamilyNameDict, names[i].c_str(), familyRecID);
                 }
             }
         }
     }
 
     DEBUG_FONT(("---- We have %d system fonts", fFonts.count()));
 
     if (fFontFamilies.count() > 0) {
         fDefaultFamilyRecID = 0;
     }
@@ skipping 596 matching lines @@
     return SkSafeRef(retTypeface);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return NULL;
 }