rework GUI, scripts, and fiddle main for multiple simultaneous configs

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 61 matching lines @@
         // db is the database, nil if we don't have an SQL database to store data into.
         db *sql.DB = nil
 
         // directLink is the regex that matches URLs paths that are direct links.
         directLink = regexp.MustCompile("^/c/([a-f0-9]+)$")
 
         // iframeLink is the regex that matches URLs paths that are links to iframes.
         iframeLink = regexp.MustCompile("^/iframe/([a-f0-9]+)$")
 
         // imageLink is the regex that matches URLs paths that are direct links to PNGs.
-        imageLink = regexp.MustCompile("^/i/([a-z0-9-]+.png)$")
+        imageLink = regexp.MustCompile("^/i/([a-z0-9-_]+.png)$")
 
         // tryInfoLink is the regex that matches URLs paths that are direct links to data about a single try.
         tryInfoLink = regexp.MustCompile("^/json/([a-f0-9]+)$")
 
         // workspaceLink is the regex that matches URLs paths for workspaces.
         workspaceLink = regexp.MustCompile("^/w/([a-z0-9-]+)$")
 
         // errorRE is ther regex that matches compiler errors and extracts the line / column information.
         errorRE = regexp.MustCompile("^.*.cpp:(\\d+):(\\d+):\\s*(.*)")
 
@@ skipping 307 matching lines @@
 
 // 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 {
         Message       string         `json:"message"`
         CompileErrors []compileError `json:"compileErrors"`
-        Img           string         `json:"img"`
+        RasterImg     string         `json:"rasterImg"`
+        GPUImg        string         `json:"gpuImg"`
         Hash          string         `json:"hash"`
 }
 
 // doCmd executes the given command line string; the command being
 // run is expected to not care what its current working directory is.
 // Returns the stdout and stderr.
 func doCmd(commandLine string) (string, error) {
         glog.Infof("Command: %q\n", commandLine)
         programAndArgs := strings.SplitN(commandLine, " ", 2)
         program := programAndArgs[0]
@@ skipping 296 matching lines @@
                 }
         }
         return false
 }
 
 type TryRequest struct {
         Code   string `json:"code"`
         Width  int    `json:"width"`
         Height int    `json:"height"`
         GPU    bool   `json:"gpu"`
+        Raster bool   `json:"raster"`
+        PDF    bool   `json:"pdf"`
         Name   string `json:"name"`   // Optional name of the workspace the code is in.
         Source int    `json:"source"` // ID of the source image, 0 if none.
 }
 
 // iframeHandler handles the GET and POST of the main page.
 func iframeHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("IFrame Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
@@ skipping 114 matching lines @@
                 if n == MAX_TRY_SIZE {
                         err := fmt.Errorf("Code length equal to, or exceeded, %d", MAX_TRY_SIZE)
                         reportTryError(w, r, err, "Code too large.", "")
                         return
                 }
                 request := TryRequest{}
                 if err := json.Unmarshal(buf.Bytes(), &request); err != nil {
                         reportTryError(w, r, err, "Coulnd't decode JSON.", "")
                         return
                 }
+                if !(request.GPU || request.Raster || request.PDF) {
+                        reportTryError(w, r, nil, "No run configuration supplied...", "")
+                        return
+                }
                 if hasPreProcessor(request.Code) {
                         err := fmt.Errorf("Found preprocessor macro in code.")
                         reportTryError(w, r, err, "Preprocessor macros aren't allowed.", "")
                         return
                 }
                 hash, err := expandCode(LineNumbers(request.Code), request.Source, request.Width, request.Height)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the code to compile.", hash)
                         return
                 }
                 writeToDatabase(hash, request.Code, request.Name, request.Source, request.Width, request.Height)
                 err = expandGyp(hash)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the gyp file.", hash)
                         return
                 }
                 cmd := fmt.Sprintf("scripts/fiddle_wrapper %s --width %d --height %d", hash, request.Width, request.Height)
+                if request.Raster {
+                        cmd += " --raster"
+                }
                 if request.GPU {
                         cmd += " --gpu"
                 }
+                if request.PDF {
+                        cmd += " --pdf"
+                }
                 if *useChroot {
                         cmd = "schroot -c webtry --directory=/ -- /skia_build/skia/experimental/webtry/" + cmd
                 }
                 if request.Source > 0 {
                         cmd += fmt.Sprintf(" --source image-%d.png", request.Source)
                 }
 
                 message, err := doCmd(cmd)
 
                 outputLines := strings.Split(message, "\n")
@@ skipping 22 matching lines @@
 
                 if err != nil {
                         if len(errorLines) > 0 {
                                 reportCompileError(w, r, errorLines, hash)
                         } else {
                                 reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
                         }
                         return
                 }
 
-                png, err := ioutil.ReadFile("../../../inout/" + hash + ".png")
-                if err != nil {
-                        reportTryError(w, r, err, "Failed to open the generated PNG.", hash)
-                        return
-                }
-
                 m := response{
-                        Img:  base64.StdEncoding.EncodeToString([]byte(png)),
                         Hash: hash,
                 }
+
+                if request.Raster {
+                        png, err := ioutil.ReadFile("../../../inout/" + hash + "_raster.png")
+                        if err != nil {
+                                reportTryError(w, r, err, "Failed to open the raster-generated PNG.", hash)
+                                return
+                        }
+
+                        m.RasterImg = base64.StdEncoding.EncodeToString([]byte(png))
+                }
+
+                if request.GPU {
+                        png, err := ioutil.ReadFile("../../../inout/" + hash + "_GPU.png")
+                        if err != nil {
+                                reportTryError(w, r, err, "Failed to open the GPU-generated PNG.", hash)
+                                return
+                        }
+
+                        m.GPUImg = base64.StdEncoding.EncodeToString([]byte(png))
+                }
+
                 resp, err := json.Marshal(m)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to serialize a response.", hash)
                         return
                 }
                 w.Header().Set("Content-Type", "application/json")
                 w.Write(resp)
         }
 }
 
 func main() {
         flag.Parse()
         Init()
         http.HandleFunc("/i/", autogzip.HandleFunc(imageHandler))
         http.HandleFunc("/w/", autogzip.HandleFunc(workspaceHandler))
         http.HandleFunc("/recent/", autogzip.HandleFunc(recentHandler))
         http.HandleFunc("/iframe/", autogzip.HandleFunc(iframeHandler))
         http.HandleFunc("/json/", autogzip.HandleFunc(tryInfoHandler))
         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))
         glog.Fatal(http.ListenAndServe(*port, nil))
 }