preliminary support for fiddle font use

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 18 matching lines @@
 )
 
 import (
         "github.com/fiorix/go-web/autogzip"
         _ "github.com/go-sql-driver/mysql"
         _ "github.com/mattn/go-sqlite3"
         "github.com/rcrowley/go-metrics"
 )
 
 const (
-
         DEFAULT_SAMPLE = `void draw(SkCanvas* canvas) {
     SkPaint p;
     p.setColor(SK_ColorRED);
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(10);
 
     canvas->drawLine(20, 20, 100, 100, p);
 }`
         // Don't increase above 2^16 w/o altering the db tables to accept something bigger than TEXT.
@@ skipping 311 matching lines @@
         return t.Execute(f, context)
 }
 
 // expandToFile expands the template and writes the result to the file.
 func expandToFile(filename string, code string, t *template.Template) error {
         return writeTemplate(filename, t, userCode{Code: code, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}})
 }
 
 // expandCode expands the template into a file and calculates the MD5 hash.
 func expandCode(code string, source int) (string, error) {
+        // in order to support fonts in the chroot jail, we need to make sure
+        // we're using portable typefaces.
+        // TODO(humper):  Make this more robust, supporting things like setTypeface
+
+        inputCodeLines := strings.Split(code, "\n")
+        outputCodeLines := []string{}
+        for _, line := range inputCodeLines {
+                outputCodeLines = append(outputCodeLines, line)
+                if strings.HasPrefix(strings.TrimSpace(line), "SkPaint ") {
+                        outputCodeLines = append(outputCodeLines, "sk_tool_utils::set_portable_typeface(&p);")
+                }
+        }
+
+        fontFriendlyCode := strings.Join(outputCodeLines, "\n")
+
         h := md5.New()
-        h.Write([]byte(code))
+        h.Write([]byte(fontFriendlyCode))
         binary.Write(h, binary.LittleEndian, int64(source))
         hash := fmt.Sprintf("%x", h.Sum(nil))
         // At this point we are running in skia/experimental/webtry, making cache a
         // peer directory to skia.
         // TODO(jcgregorio) Make all relative directories into flags.
-        err := expandToFile(fmt.Sprintf("../../../cache/src/%s.cpp", hash), code, codeTemplate)
+        err := expandToFile(fmt.Sprintf("../../../cache/src/%s.cpp", hash), fontFriendlyCode, codeTemplate)
         return hash, err
 }
 
 // expandGyp produces the GYP file needed to build the code
 func expandGyp(hash string) error {
         return writeTemplate(fmt.Sprintf("../../../cache/%s.gyp", hash), gypTemplate, struct{ Hash string }{hash})
 }
 
 // response is serialized to JSON as a response to POSTs.
 type response struct {
@@ skipping 421 matching lines @@
                 }
                 writeToDatabase(hash, request.Code, request.Name, request.Source)
                 err = expandGyp(hash)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the gyp file.", hash)
                         return
                 }
                 cmd := "scripts/fiddle_wrapper " + hash
                 if *useChroot {
                         cmd = "schroot -c webtry --directory=/ -- /skia_build/skia/experimental/webtry/" + cmd
-                } 
+                }
                 if request.Source > 0 {
                         cmd += fmt.Sprintf(" image-%d.png", request.Source)
                 }
 
                 message, err := doCmd(cmd)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
                         return
                 }
                 png, err := ioutil.ReadFile("../../../inout/" + hash + ".png")
@@ skipping 27 matching lines @@
         http.HandleFunc("/sources/", autogzip.HandleFunc(sourcesHandler))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
         http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
         log.Fatal(http.ListenAndServe(*port, nil))
 }