add support for skfiddle width/height options

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 139 matching lines @@
         if err != nil {
                 panic(err)
         }
         gypTemplate, err = template.ParseFiles(filepath.Join(cwd, "templates/template.gyp"))
         if err != nil {
                 panic(err)
         }
         indexTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/index.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
+                filepath.Join(cwd, "templates/sidebar.html"),
                 filepath.Join(cwd, "templates/content.html"),
                 filepath.Join(cwd, "templates/headercommon.html"),
                 filepath.Join(cwd, "templates/footercommon.html"),
         )
         if err != nil {
                 panic(err)
         }
         iframeTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/iframe.html"),
                 filepath.Join(cwd, "templates/content.html"),
                 filepath.Join(cwd, "templates/headercommon.html"),
                 filepath.Join(cwd, "templates/footercommon.html"),
         )
         if err != nil {
                 panic(err)
         }
         recentTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/recent.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
+                filepath.Join(cwd, "templates/sidebar.html"),
                 filepath.Join(cwd, "templates/headercommon.html"),
                 filepath.Join(cwd, "templates/footercommon.html"),
         )
         if err != nil {
                 panic(err)
         }
         workspaceTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/workspace.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
+                filepath.Join(cwd, "templates/sidebar.html"),
                 filepath.Join(cwd, "templates/content.html"),
                 filepath.Join(cwd, "templates/headercommon.html"),
                 filepath.Join(cwd, "templates/footercommon.html"),
         )
         if err != nil {
                 panic(err)
         }
 
         // The git command returns output of the format:
         //
@@ skipping 47 matching lines @@
              )`
                 _, err = db.Exec(sql)
                 if err != nil {
                         log.Printf("Info: status creating sqlite table for sources: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS webtry (
              code               TEXT      DEFAULT ''                 NOT NULL,
              create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
              hash               CHAR(64)  DEFAULT ''                 NOT NULL,
+             width                      INTEGER   DEFAULT 256                NOT NULL,
+             height                     INTEGER   DEFAULT 256                NOT NULL,
              source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
 
              PRIMARY KEY(hash)
             )`
                 _, err = db.Exec(sql)
                 if err != nil {
                         log.Printf("Info: status creating sqlite table for webtry: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS workspace (
           name      CHAR(64)  DEFAULT ''                 NOT NULL,
           create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
           PRIMARY KEY(name)
         )`
                 _, err = db.Exec(sql)
                 if err != nil {
                         log.Printf("Info: status creating sqlite table for workspace: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS workspacetry (
           name               CHAR(64)  DEFAULT ''                 NOT NULL,
           create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
           hash               CHAR(64)  DEFAULT ''                 NOT NULL,
+          width                  INTEGER   DEFAULT 256                NOT NULL,
+          height                 INTEGER   DEFAULT 256                NOT NULL,
           hidden             INTEGER   DEFAULT 0                  NOT NULL,
           source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
 
           FOREIGN KEY (name)   REFERENCES workspace(name)
         )`
                 _, err = db.Exec(sql)
                 if err != nil {
                         log.Printf("Info: status creating sqlite table for workspace try: %q\n", err)
                 }
         }
@@ skipping 50 matching lines @@
 // Titlebar is used in titlebar template expansion.
 type Titlebar struct {
         GitHash string
         GitInfo string
 }
 
 // userCode is used in template expansion.
 type userCode struct {
         Code     string
         Hash     string
+        Width    int
+        Height   int
         Source   int
         Titlebar Titlebar
 }
 
 // writeTemplate creates a given output file and writes the template
 // result there.
 func writeTemplate(filename string, t *template.Template, context interface{}) error {
         f, err := os.Create(filename)
         if err != nil {
                 return err
         }
         defer f.Close()
         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}})
+        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) {
+// We include the width and height here so that a single hash can capture
+// both the code and the supplied width/height parameters.
+func expandCode(code string, source int, width, height 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{"DECLARE_bool(portableFonts);"}
+        outputCodeLines := []string{"DECLARE_bool(portableFonts);", fmt.Sprintf("// WxH: %d, %d", width, height)}
         for _, line := range inputCodeLines {
                 outputCodeLines = append(outputCodeLines, line)
                 if strings.HasPrefix(strings.TrimSpace(line), "SkPaint p") {
                         outputCodeLines = append(outputCodeLines, "FLAGS_portableFonts = true;")
                         outputCodeLines = append(outputCodeLines, "sk_tool_utils::set_portable_typeface(&p, \"Helvetica\", SkTypeface::kNormal);")
                 }
         }
 
         fontFriendlyCode := strings.Join(outputCodeLines, "\n")
 
@@ skipping 58 matching lines @@
         log.Printf("Error: %s\n%s", message, err.Error())
         resp, err := json.Marshal(m)
         if err != nil {
                 http.Error(w, "Failed to serialize a response", 500)
                 return
         }
         w.Header().Set("Content-Type", "text/plain")
         w.Write(resp)
 }
 
-func writeToDatabase(hash string, code string, workspaceName string, source int) {
+func writeToDatabase(hash string, code string, workspaceName string, source int, width, height int) {
         if db == nil {
                 return
         }
-        if _, err := db.Exec("INSERT INTO webtry (code, hash, source_image_id) VALUES(?, ?, ?)", code, hash, source); err != nil {
+        if _, err := db.Exec("INSERT INTO webtry (code, hash, width, height, source_image_id) VALUES(?, ?, ?, ?, ?)", code, hash, width, height, source); err != nil {
                 log.Printf("ERROR: Failed to insert code into database: %q\n", err)
         }
         if workspaceName != "" {
-                if _, err := db.Exec("INSERT INTO workspacetry (name, hash, source_image_id) VALUES(?, ?, ?)", workspaceName, hash, source); err != nil {
+                if _, err := db.Exec("INSERT INTO workspacetry (name, hash, width, height, source_image_id) VALUES(?, ?, ?, ?, ?)", workspaceName, hash, width, height, source); err != nil {
                         log.Printf("ERROR: Failed to insert into workspacetry table: %q\n", err)
                 }
         }
 }
 
 type Sources struct {
         Id int `json:"id"`
 }
 
 // sourcesHandler serves up the PNG of a specific try.
@@ skipping 119 matching lines @@
         w.Header().Set("Content-Type", "text/html")
         if err := recentTemplate.Execute(w, Recent{Tries: recent, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type Workspace struct {
         Name     string
         Code     string
         Hash     string
+        Width    int
+        Height   int
         Source   int
         Tries    []Try
         Titlebar Titlebar
 }
 
 // newWorkspace generates a new random workspace name and stores it in the database.
 func newWorkspace() (string, error) {
         for i := 0; i < 10; i++ {
                 adj := workspaceNameAdj[rand.Intn(len(workspaceNameAdj))]
                 noun := workspaceNameNoun[rand.Intn(len(workspaceNameNoun))]
                 suffix := rand.Intn(1000)
                 name := fmt.Sprintf("%s-%s-%d", adj, noun, suffix)
                 if _, err := db.Exec("INSERT INTO workspace (name) VALUES(?)", name); err == nil {
                         return name, nil
                 } else {
                         log.Printf("ERROR: Failed to insert workspace into database: %q\n", err)
                 }
         }
         return "", fmt.Errorf("Failed to create a new workspace")
 }
 
 // getCode returns the code for a given hash, or the empty string if not found.
-func getCode(hash string) (string, int, error) {
+func getCode(hash string) (string, int, int, int, error) {
         code := ""
+        width := 0
+        height := 0
         source := 0
-        if err := db.QueryRow("SELECT code, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &source); err != nil {
+        if err := db.QueryRow("SELECT code, width, height, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &source); err != nil {
                 log.Printf("ERROR: Code for hash is missing: %q\n", err)
-                return code, source, err
+                return code, width, height, source, err
         }
-        return code, source, nil
+        return code, width, height, source, nil
 }
 
 func workspaceHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Workspace Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
                         rows, err := db.Query("SELECT create_ts, hash, source_image_id FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
                                 var source int
                                 if err := rows.Scan(&create_ts, &hash, &source); err != nil {
                                         log.Printf("Error: failed to fetch from database: %q", err)
                                         continue
                                 }
                                 tries = append(tries, Try{Hash: hash, Source: source, CreateTS: create_ts.Format("2006-02-01")})
                         }
                 }
                 var code string
                 var hash string
+                var width int
+                var height int
                 source := 0
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
+                        width = 256
+                        height = 256
                 } else {
                         hash = tries[len(tries)-1].Hash
-                        code, source, _ = getCode(hash)
+                        code, width, height, source, _ = getCode(hash)
                 }
                 w.Header().Set("Content-Type", "text/html")
-                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Source: source, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Width: width, Height: height, Source: source, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 name, err := newWorkspace()
                 if err != nil {
                         http.Error(w, "Failed to create a new workspace.", 500)
                         return
                 }
                 http.Redirect(w, r, "/w/"+name, 302)
         }
 }
 
 // hasPreProcessor returns true if any line in the code begins with a # char.
 func hasPreProcessor(code string) bool {
         lines := strings.Split(code, "\n")
         for _, s := range lines {
                 if strings.HasPrefix(strings.TrimSpace(s), "#") {
                         return true
                 }
         }
         return false
 }
 
 type TryRequest struct {
         Code   string `json:"code"`
+        Width  int    `json:"width"`
+        Height int    `json:"height"`
         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) {
         log.Printf("IFrame Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := iframeLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
         if db == nil {
                 http.NotFound(w, r)
                 return
         }
         var code string
-        code, source, err := getCode(hash)
+        code, width, height, source, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         // Expand the template.
         w.Header().Set("Content-Type", "text/html")
-        if err := iframeTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source}); err != nil {
+        if err := iframeTemplate.Execute(w, userCode{Code: code, Width: width, Height: height, Hash: hash, Source: source}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type TryInfo struct {
         Hash   string `json:"hash"`
         Code   string `json:"code"`
+        Width  int    `json:"width"`
+        Height int    `json:"height"`
         Source int    `json:"source"`
 }
 
 // tryInfoHandler returns information about a specific try.
 func tryInfoHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Try Info Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := tryInfoLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
-        code, source, err := getCode(hash)
+        code, width, height, source, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         m := TryInfo{
                 Hash:   hash,
                 Code:   code,
+                Width:  width,
+                Height: height,
                 Source: source,
         }
         resp, err := json.Marshal(m)
         if err != nil {
                 reportError(w, r, err, "Failed to serialize a response.")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         w.Write(resp)
 }
 
 func cleanCompileOutput(s, hash string) string {
         old := "../../../cache/src/" + hash + ".cpp:"
         log.Printf("INFO: replacing %q\n", old)
         return strings.Replace(s, old, "usercode.cpp:", -1)
 }
 
 // mainHandler handles the GET and POST of the main page.
 func mainHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Main Handler: %q\n", r.URL.Path)
         requestsCounter.Inc(1)
         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
                 source := 0
+                width := 256
+                height := 256
                 match := directLink.FindStringSubmatch(r.URL.Path)
                 var hash string
                 if len(match) == 2 && r.URL.Path != "/" {
                         hash = match[1]
                         if db == nil {
                                 http.NotFound(w, r)
                                 return
                         }
                         // Update 'code' with the code found in the database.
-                        if err := db.QueryRow("SELECT code, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &source); err != nil {
+                        if err := db.QueryRow("SELECT code, width, height, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &source); err != nil {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
                 w.Header().Set("Content-Type", "text/html")
-                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source, Width: width, Height: height, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 w.Header().Set("Content-Type", "application/json")
                 buf := bytes.NewBuffer(make([]byte, 0, MAX_TRY_SIZE))
                 n, err := buf.ReadFrom(r.Body)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to read a request body.", "")
                         return
                 }
                 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 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)
+                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)
+                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 := "scripts/fiddle_wrapper " + hash
+                cmd := fmt.Sprintf("scripts/fiddle_wrapper %s --width %d --height %d", hash, request.Width, request.Height)
                 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)
+                        cmd += fmt.Sprintf(" --source 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")
                 if err != nil {
                         reportTryError(w, r, err, "Failed to open the generated PNG.", hash)
@@ skipping 25 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))
 }