code review 5707054: encoding/json: escape output from Marshalers.

src/pkg/encoding/json/encode.go

 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package json implements encoding and decoding of JSON objects as defined in
 // RFC 4627.
 //
 // See "JSON and Go" for an introduction to this package:
 // http://blog.golang.org/2011/01/json-and-go.html
 package json
@@ skipping 246 matching lines @@
                 if v.Kind() != reflect.Ptr && v.CanAddr() {
                         m, ok = v.Addr().Interface().(Marshaler)
                         if ok {
                                 v = v.Addr()
                         }
                 }
         }
         if ok && (v.Kind() != reflect.Ptr || !v.IsNil()) {
                 b, err := m.MarshalJSON()
                 if err == nil {
+                        // Ensure the JSON is properly escaped.
+                        // This could be more efficient.
+                        var buf bytes.Buffer

[r, 2012/02/29 00:34:49]

is it worth a call to bytes.IndexAny to avoid the allocation? i think so.

[dsymonds, 2012/02/29 00:53:39]

It would improve this particular approach, yeah. I want to see whether Russ
wants me to take a much more different approach (e.g. slotting an escaping
io.Writer in somewhere).

[rsc, 2012/02/29 15:50:20]

I don't want to slow things down noticeably here, but since we're
already checking validity and compacting below, it should be 
both easy and quick to make that processing do the escaping too.
A proposal:

Rename Compact to compact with an extra parameter
and a little bit more code:

func compact(dst *bytes.Buffer, src []byte, escape bool) error {
	...
	for i, c := range src {
		if escape && (c == '<' || c == '>' || c == '&') {
			if start < i {
				dst.Write(src[start:i])
			}
			dst.WriteString(`\u00`)
			dst.WriteByte(hex[c>>4])
			dst.WriteByte(hex[c&0xF])
			start = i+1
		}
		v := scan.step(&scan, int(c))
		...
		
Then Compact == compact(dst, src, false), and below the 
call can be compact(&e.Buffer, b, true).

+                        HTMLEscape(&buf, b)
+                        b = buf.Bytes()
+                }
+                if err == nil {
                         // copy JSON into buffer, checking validity.
                         err = Compact(&e.Buffer, b)
                 }
                 if err != nil {
                         e.error(&MarshalerError{v.Type(), err})
                 }
                 return
         }
 
         writeString := (*encodeState).WriteString
@@ skipping 269 matching lines @@
                                 ef.tag = name
                         }
                         ef.omitEmpty = opts.Contains("omitempty")
                         ef.quoted = opts.Contains("string")
                 }
                 fs = append(fs, ef)
         }
         encodeFieldsCache[t] = fs
         return fs
 }