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

src/pkg/encoding/json/encode.go

Index: src/pkg/encoding/json/encode.go
===================================================================
--- a/src/pkg/encoding/json/encode.go
+++ b/src/pkg/encoding/json/encode.go
@@ -264,6 +264,13 @@
 	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)
 		}