Add gzip encoding responses.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
-        _ "github.com/go-sql-driver/mysql"
-        _ "github.com/mattn/go-sqlite3"
         htemplate "html/template"
         "io/ioutil"
         "log"
         "math/rand"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "strings"
         "text/template"
         "time"
 )
 
+import (
+        "github.com/fiorix/go-web/autogzip"
+        _ "github.com/go-sql-driver/mysql"
+        _ "github.com/mattn/go-sqlite3"
+)
+
 const (
         RESULT_COMPILE = `../../experimental/webtry/safec++ -DSK_GAMMA_SRGB -DSK_GAMMA_APPLY_TO_A8 -DSK_SCALAR_TO_FLOAT_EXCLUDED -DSK_ALLOW_STATIC_GLOBAL_INITIALIZERS=1 -DSK_SUPPORT_GPU=0 -DSK_SUPPORT_OPENCL=0 -DSK_FORCE_DISTANCEFIELD_FONTS=0 -DSK_SCALAR_IS_FLOAT -DSK_CAN_USE_FLOAT -DSK_SAMPLES_FOR_X -DSK_BUILD_FOR_UNIX -DSK_USE_POSIX_THREADS -DSK_SYSTEM_ZLIB=1 -DSK_DEBUG -DSK_DEVELOPER=1 -I../../src/core -I../../src/images -I../../tools/flags -I../../include/config -I../../include/core -I../../include/pathops -I../../include/pipe -I../../include/effects -I../../include/ports -I../../src/sfnt -I../../include/utils -I../../src/utils -I../../include/images -g -fno-exceptions -fstrict-aliasing -Wall -Wextra -Winit-self -Wpointer-arith -Wno-unused-parameter -m64 -fno-rtti -Wnon-virtual-dtor -c ../../../cache/%s.cpp -o ../../../cache/%s.o`
         LINK           = `../../experimental/webtry/safec++ -m64 -lstdc++ -lm -o ../../../inout/%s -Wl,--start-group ../../../cache/%s.o obj/experimental/webtry/webtry.main.o obj/gyp/libflags.a libskia_images.a libskia_core.a libskia_effects.a obj/gyp/libjpeg.a obj/gyp/libwebp_dec.a obj/gyp/libwebp_demux.a obj/gyp/libwebp_dsp.a obj/gyp/libwebp_enc.a obj/gyp/libwebp_utils.a libskia_utils.a libskia_opts.a libskia_opts_ssse3.a libskia_ports.a libskia_sfnt.a -Wl,--end-group -lpng -lz -lgif -lpthread -lfontconfig -ldl -lfreetype`
         DEFAULT_SAMPLE = `void draw(SkCanvas* canvas) {
     SkPaint p;
     p.setColor(SK_ColorRED);
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(10);
 
@@ skipping 284 matching lines @@
         if err != nil {
                 log.Printf("Exit status: %s\n", err.Error())
                 return string(message), fmt.Errorf("Failed to run command.")
         }
         return string(message), nil
 }
 
 // reportError formats an HTTP error response and also logs the detailed error message.
 func reportError(w http.ResponseWriter, r *http.Request, err error, message string) {
         log.Printf("Error: %s\n%s", message, err.Error())
+        w.Header().Set("Content-Type", "text/plain")
         http.Error(w, message, 500)
 }
 
 // reportTryError formats an HTTP error response in JSON and also logs the detailed error message.
 func reportTryError(w http.ResponseWriter, r *http.Request, err error, message, hash string) {
         m := response{
                 Message: message,
                 Hash:    hash,
         }
         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) {
         if db == nil {
                 return
         }
         if _, err := db.Exec("INSERT INTO webtry (code, hash) VALUES(?, ?)", code, hash); err != nil {
                 log.Printf("ERROR: Failed to insert code into database: %q\n", err)
         }
@@ skipping 10 matching lines @@
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := imageLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         filename := match[1]
+        w.Header().Set("Content-Type", "image/png")
         http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))
 }
 
 type Try struct {
         Hash     string `json:"hash"`
         CreateTS string `json:"create_ts"`
 }
 
 type Recent struct {
         Tries    []Try
@@ skipping 13 matching lines @@
         recent := []Try{}
         for rows.Next() {
                 var hash string
                 var create_ts time.Time
                 if err := rows.Scan(&create_ts, &hash); err != nil {
                         log.Printf("Error: failed to fetch from database: %q", err)
                         continue
                 }
                 recent = append(recent, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
         }
+        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
         Tries    []Try
@@ skipping 50 matching lines @@
                         }
                 }
                 var code string
                 var hash string
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                 } else {
                         hash = tries[len(tries)-1].Hash
                         code, _ = getCode(hash)
                 }
+                w.Header().Set("Content-Type", "text/html")
                 if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, 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)
@@ skipping 33 matching lines @@
                 http.NotFound(w, r)
                 return
         }
         var code string
         code, 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}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type TryInfo struct {
         Hash string `json:"hash"`
         Code string `json:"code"`
 }
 
@@ skipping 47 matching lines @@
                                 http.NotFound(w, r)
                                 return
                         }
                         // Update 'code' with the code found in the database.
                         if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); 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, 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
@@ skipping 59 matching lines @@
                         Message: message,
                         StdOut:  execMessage,
                         Img:     base64.StdEncoding.EncodeToString([]byte(png)),
                         Hash:    hash,
                 }
                 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()
-        http.HandleFunc("/i/", imageHandler)
-        http.HandleFunc("/w/", workspaceHandler)
-        http.HandleFunc("/recent/", recentHandler)
-        http.HandleFunc("/iframe/", iframeHandler)
-        http.HandleFunc("/json/", tryInfoHandler)
+        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))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
-        http.Handle("/res/", http.FileServer(http.Dir("./")))
+        http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
-        http.HandleFunc("/", mainHandler)
+        http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
         log.Fatal(http.ListenAndServe(*port, nil))
 }