Re-land ganesh checkbox. I needed to increase the size of the address

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 237 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,
+             width              INTEGER   DEFAULT 256                NOT NULL,
+             height             INTEGER   DEFAULT 256                NOT NULL,
+             gpu                BOOL      DEFAULT 0                  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,
+          width              INTEGER   DEFAULT 256                NOT NULL,
+          height             INTEGER   DEFAULT 256                NOT NULL,
+          gpu                BOOL      DEFAULT 0                  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 52 matching lines @@
         GitHash string
         GitInfo string
 }
 
 // userCode is used in template expansion.
 type userCode struct {
         Code     string
         Hash     string
         Width    int
         Height   int
+        GPU      bool
         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},
         })
 }
 
 // expandCode expands the template into a file and calculates the MD5 hash.
 // 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) {
+func expandCode(code string, source int, width, height int, gpu bool) (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);", fmt.Sprintf("// WxH: %d, %d", width, height)}
+        outputCodeLines := []string{
+                "DECLARE_bool(portableFonts);",
+                fmt.Sprintf("// WxH: %d, %d", width, height),
+                fmt.Sprintf("// GPU: %v", gpu),
+        }
         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, width, height int) {
+func writeToDatabase(hash string, code string, workspaceName string, source int, width, height int, gpu bool) {
         if db == nil {
                 return
         }
-        if _, err := db.Exec("INSERT INTO webtry (code, hash, width, height, source_image_id) VALUES(?, ?, ?, ?, ?)", code, hash, width, height, source); err != nil {
+        if _, err := db.Exec("INSERT INTO webtry (code, hash, width, height, gpu, source_image_id) VALUES(?, ?, ?, ?, ?, ?)", code, hash, width, height, gpu, 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, width, height, source_image_id) VALUES(?, ?, ?, ?, ?)", workspaceName, hash, width, height, source); err != nil {
+                if _, err := db.Exec("INSERT INTO workspacetry (name, hash, width, height, gpu, source_image_id) VALUES(?, ?, ?, ?, ?, ?)", workspaceName, hash, width, height, gpu, 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 122 matching lines @@
         }
 }
 
 type Workspace struct {
         Name     string
         Code     string
         Hash     string
         Width    int
         Height   int
         Source   int
+        GPU      bool
         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, int, int, error) {
+func getCode(hash string) (string, int, int, int, bool, error) {
         code := ""
         width := 0
         height := 0
         source := 0
-        if err := db.QueryRow("SELECT code, width, height, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &source); err != nil {
+        gpu := false
+        if err := db.QueryRow("SELECT code, width, height, gpu, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &gpu, &source); err != nil {
                 log.Printf("ERROR: Code for hash is missing: %q\n", err)
-                return code, width, height, source, err
+                return code, width, height, source, gpu, err
         }
-        return code, width, height, source, nil
+        return code, width, height, source, gpu, 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]
@@ skipping 11 matching lines @@
                                         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
+                gpu := false
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                         width = 256
                         height = 256
                 } else {
                         hash = tries[len(tries)-1].Hash
-                        code, width, height, source, _ = getCode(hash)
+                        code, width, height, source, gpu, _ = getCode(hash)
                 }
                 w.Header().Set("Content-Type", "text/html")
-                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 {
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Width: width, Height: height, GPU: gpu, 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"`
+        GPU    bool   `json:"gpu"`
         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, width, height, source, err := getCode(hash)
+        code, width, height, source, gpu, 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, Width: width, Height: height, Hash: hash, Source: source}); err != nil {
+        if err := iframeTemplate.Execute(w, userCode{Code: code, Width: width, Height: height, GPU: gpu, 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"`
+        GPU    bool   `json:"gpu"`
         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, width, height, source, err := getCode(hash)
+        code, width, height, source, gpu, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         m := TryInfo{
                 Hash:   hash,
                 Code:   code,
                 Width:  width,
                 Height: height,
+                GPU:    gpu,
                 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
+                gpu := false
                 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, width, height, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &source); err != nil {
+                        if err := db.QueryRow("SELECT code, width, height, gpu, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &gpu, &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, Width: width, Height: height, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source, Width: width, Height: height, GPU: gpu, 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, request.Width, request.Height)
+                hash, err := expandCode(LineNumbers(request.Code), request.Source, request.Width, request.Height, request.GPU)
                 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)
+                writeToDatabase(hash, request.Code, request.Name, request.Source, request.Width, request.Height, request.GPU)
                 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.GPU {
+                        cmd += " --gpu"
+                }
                 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)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
@@ skipping 30 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))
 }