Mojom runtime type info: Use compression and base64 encoding.

mojom/mojom_parser/serialization/serialization_test.go

 // Copyright 2015 The Chromium 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 serialization
 
 import (
+        "bytes"
+        "compress/gzip"
+        "encoding/base64"
         "fmt"
+        "io/ioutil"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
         "mojom/mojom_parser/generated/mojom_types"
         "mojom/mojom_parser/mojom"
         "mojom/mojom_parser/parser"
         "reflect"
         "testing"
         myfmt "third_party/golang/src/fmt"
 )
 
@@ skipping 1996 matching lines @@
                         t.Errorf("Serialization error for case %d: %s", i, err.Error())
                         continue
                 }
 
                 // Deserialize
                 decoder := bindings.NewDecoder(bytes, nil)
                 fileGraph := mojom_files.MojomFileGraph{}
                 fileGraph.Decode(decoder)
 
                 // Deserialize  RuntimeTypeInfo A
-                decoder = bindings.NewDecoder(*fileGraph.Files[fileNameA].SerializedRuntimeTypeInfo, nil)
-                runtimeTypeInfoA := mojom_types.RuntimeTypeInfo{}
-                runtimeTypeInfoA.Decode(decoder)
+                runtimeTypeInfoA := deserializeRuntimeTypeInfo(*fileGraph.Files[fileNameA].SerializedRuntimeTypeInfo)
 
                 // Deserialize  RuntimeTypeInfo B
-                decoder = bindings.NewDecoder(*fileGraph.Files[fileNameB].SerializedRuntimeTypeInfo, nil)
-                runtimeTypeInfoB := mojom_types.RuntimeTypeInfo{}
-                runtimeTypeInfoB.Decode(decoder)
+                runtimeTypeInfoB := deserializeRuntimeTypeInfo(*fileGraph.Files[fileNameB].SerializedRuntimeTypeInfo)
 
                 // Compare A
                 if err := compareTwoGoObjects(c.expectedRuntimeTypeInfoA, &runtimeTypeInfoA); err != nil {
                         t.Errorf("case %d A:\n%s", i, err.Error())
                 }
 
                 // Compare B
                 if err := compareTwoGoObjects(c.expectedRuntimeTypeInfoB, &runtimeTypeInfoB); err != nil {
                         t.Errorf("case %d B:\n%s", i, err.Error())
                 }
         }
 }
 
+func deserializeRuntimeTypeInfo(base64String string) mojom_types.RuntimeTypeInfo {
+        compressedBytes, err := base64.StdEncoding.DecodeString(base64String)
+        if err != nil {
+                panic(fmt.Sprintf("Error while unencoding runtimeTypeInfo: %s", err.Error()))
+        }
+        reader, err2 := gzip.NewReader(bytes.NewBuffer(compressedBytes))
+        if err2 != nil {
+                panic(fmt.Sprintf("Error while decompressing runtimeTypeInfo: %s", err.Error()))
+        }
+        uncompressedBytes, err3 := ioutil.ReadAll(reader)
+        if err3 != nil {
+                panic(fmt.Sprintf("Error while decompressing runtimeTypeInfo: %s", err2.Error()))
+        }
+        if err = reader.Close(); err != nil {
+                panic(fmt.Sprintf("Error while decompressing runtimeTypeInfo: %s", err.Error()))
+        }
+        decoder := bindings.NewDecoder(uncompressedBytes, nil)
+        runtimeTypeInfo := mojom_types.RuntimeTypeInfo{}
+        runtimeTypeInfo.Decode(decoder)
+        return runtimeTypeInfo
+}
+
 // compareTwoGoObjects compares |expected| and |actual| and returns a non-nil
 // error if they are not deeply equal. The error message contains a human-readable
 // string containing a deep-print of expected and actual along with the substrings
 // starting from the first character where they differ.
 func compareTwoGoObjects(expected interface{}, actual interface{}) error {
         if !reflect.DeepEqual(expected, actual) {
                 // Note(rudominer) The myfmt package is a local modification of the fmt package
                 // that does a deep printing that follows pointers for up to 50 levels.
                 // Thus expectedString and actualString should contain enough information to
                 // precisely capture the structure of expected and actual.
@@ skipping 15 matching lines @@
                         }
                         return fmt.Errorf("*****\nexpected=\n*****\n%q\n*****\nactual=\n*****\n%q\n*****\n"+
                                 "match failed at position %d: expected=\n*****\n%q\n******\nactual=\n*****\n%q\n******\n",
                                 expectedString, actualString, diffPos, mismatchExpected, mismatchActual)
                 } else {
                         return fmt.Errorf("expected != actual but the two printed equal.")
                 }
         }
         return nil
 }