Remove dependency on std::string

src/ports/SkFontConfigInterface_direct.cpp

 /*
  * Copyright 2009 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
 
-#include <string>
 #include <unistd.h>
 #include <fcntl.h>
 
 #include <fontconfig/fontconfig.h>
 
 #include "SkBuffer.h"
 #include "SkFontConfigInterface.h"
 #include "SkLazyPtr.h"
 #include "SkStream.h"
+#include "SkString.h"
 
 size_t SkFontConfigInterface::FontIdentity::writeToMemory(void* addr) const {
     size_t size = sizeof(fID) + sizeof(fTTCIndex);
     size += sizeof(int32_t) + sizeof(int32_t) + sizeof(uint8_t); // weight, width, italic
     size += sizeof(int32_t) + fString.size();    // store length+data
     if (addr) {
         SkWBuffer buffer(addr, size);
 
         buffer.write32(fID);
         buffer.write32(fTTCIndex);
@@ skipping 281 matching lines @@
     FontEquivClass class_a = GetFontEquivClass(font_a);
     FontEquivClass class_b = GetFontEquivClass(font_b);
 
     return class_a != OTHER && class_a == class_b;
 }
 
 // Normally we only return exactly the font asked for. In last-resort
 // cases, the request either doesn't specify a font or is one of the
 // basic font names like "Sans", "Serif" or "Monospace". This function
 // tells you whether a given request is for such a fallback.
-bool IsFallbackFontAllowed(const std::string& family) {
+bool IsFallbackFontAllowed(const SkString& family) {
   const char* family_cstr = family.c_str();
-  return family.empty() ||
+  return family.isEmpty() ||
          strcasecmp(family_cstr, "sans") == 0 ||
          strcasecmp(family_cstr, "serif") == 0 ||
          strcasecmp(family_cstr, "monospace") == 0;
 }
 
 static bool valid_pattern(FcPattern* pattern) {
 #ifdef SK_FONT_CONFIG_ONLY_ALLOW_SCALABLE_FONTS
     FcBool is_scalable;
     if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &is_scalable) != FcResultMatch
         || !is_scalable) {
         return false;
     }
 #endif
 
     // fontconfig can also return fonts which are unreadable
     const char* c_filename = get_name(pattern, FC_FILE);
     if (!c_filename) {
         return false;
     }
     if (access(c_filename, R_OK) != 0) {
         return false;
     }
     return true;
 }
 
 // Find matching font from |font_set| for the given font family.
 FcPattern* MatchFont(FcFontSet* font_set,
                      const char* post_config_family,
-                     const std::string& family) {
+                     const SkString& family) {
   // Older versions of fontconfig have a bug where they cannot select
   // only scalable fonts so we have to manually filter the results.
   FcPattern* match = NULL;
   for (int i = 0; i < font_set->nfont; ++i) {
     FcPattern* current = font_set->fonts[i];
     if (valid_pattern(current)) {
       match = current;
       break;
     }
   }
@@ skipping 71 matching lines @@
 }
 
 SkFontConfigInterfaceDirect::~SkFontConfigInterfaceDirect() {
 }
 
 bool SkFontConfigInterfaceDirect::matchFamilyName(const char familyName[],
                                                   SkTypeface::Style style,
                                                   FontIdentity* outIdentity,
                                                   SkString* outFamilyName,
                                                   SkTypeface::Style* outStyle) {
-    std::string familyStr(familyName ? familyName : "");
-    if (familyStr.length() > kMaxFontFamilyLength) {
+    SkString familyStr(familyName ? familyName : "");
+    if (familyStr.size() > kMaxFontFamilyLength) {
         return false;
     }
 
     SkAutoMutexAcquire ac(mutex_);
 
     FcPattern* pattern = FcPatternCreate();
 
     if (familyName) {
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
     }
@@ skipping 145 matching lines @@
     return SkDataTable::NewCopyArrays((const void*const*)names.begin(),
                                       sizes.begin(), names.count());
 }
 
 bool SkFontConfigInterfaceDirect::matchFamilySet(const char inFamilyName[],
                                                  SkString* outFamilyName,
                                                  SkTArray<FontIdentity>* ids) {
     SkAutoMutexAcquire ac(mutex_);
 
 #if 0
-    std::string familyStr(familyName ? familyName : "");
-    if (familyStr.length() > kMaxFontFamilyLength) {
+    SkString familyStr(familyName ? familyName : "");
+    if (familyStr.size() > kMaxFontFamilyLength) {
         return false;
     }
 
     SkAutoMutexAcquire ac(mutex_);
 
     FcPattern* pattern = FcPatternCreate();
 
     if (familyName) {
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
     }
@@ skipping 101 matching lines @@
                 *trimmedMatches.append() = match[i];
             }
         }
 
         SkFontStyleSet_FC* sset = SkNEW_ARGS(SkFontStyleSet_FC,
                                              (trimmedMatches.begin(),
                                               trimmedMatches.count()));
 #endif
     return false;
 }