Replace newString() with stringPointer() or just &s where the compiler allows this.

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 (
         "fmt"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
@@ skipping 38 matching lines @@
 }
 
 // addTestCase() should be invoked at the start of a case in
 // TestSingleFileSerialization.
 func (test *singleFileTest) addTestCase(moduleNameSpace, contents string) {
         fileName := fmt.Sprintf("file%d", test.testCaseNum)
         test.cases = append(test.cases, singleFileTestCase{fileName, contents, false,
                 new(mojom_files.MojomFile), new(mojom_files.MojomFileGraph)})
 
         test.expectedFile().FileName = fileName
-        test.expectedFile().ModuleNamespace = newString(moduleNameSpace)
+        test.expectedFile().ModuleNamespace = &moduleNameSpace
 
         test.expectedGraph().ResolvedTypes = make(map[string]mojom_types.UserDefinedType)
         test.expectedGraph().ResolvedValues = make(map[string]mojom_types.UserDefinedValue)
 }
 
 // endTestCase() should be invoked at the end of a case in
 // TestSingleFileSerialization.
 func (test *singleFileTest) endTestCase() {
         test.expectedGraph().Files = make(map[string]mojom_files.MojomFile)
         test.expectedGraph().Files[test.fileName()] = *test.expectedFile()
         test.testCaseNum += 1
 }
 
 // newDeclData constructs a new DeclarationData with the given data.
 func (test *singleFileTest) newDeclData(shortName, fullIdentifier string) *mojom_types.DeclarationData {
         return &mojom_types.DeclarationData{
-                ShortName:        newString(shortName),
-                FullIdentifier:   newString(fullIdentifier),
+                ShortName:        &shortName,
+                FullIdentifier:   &fullIdentifier,
                 DeclaredOrdinal:  -1,
                 DeclarationOrder: -1,
                 SourceFileInfo: &mojom_types.SourceFileInfo{
                         FileName: test.fileName(),
                 }}
 }
 
 // TestSingleFileSerialization uses a series of test cases in which the text of a .mojom
 // file is specified and the expected MojomFileGraph is specified using Go struct literals.
 func TestSingleFileSerialization(t *testing.T) {
@@ skipping 58 matching lines @@
                         IntValue:    -1,
                 }}
 
                 // Hats.COWBOY
                 test.expectedGraph().ResolvedValues["TYPE_KEY:mojom.test.Foo.Hats.COWBOY"] = &mojom_types.UserDefinedValueEnumValue{mojom_types.EnumValue{
                         DeclData:    test.newDeclData("COWBOY", "mojom.test.Foo.Hats.COWBOY"),
                         EnumTypeKey: "TYPE_KEY:mojom.test.Foo.Hats",
                         IntValue:    3,
                         InitializerValue: &mojom_types.ValueUserValueReference{mojom_types.UserValueReference{
                                 Identifier:            "NUM_MAGI",
-                                ValueKey:              newString("TYPE_KEY:mojom.test.NUM_MAGI"),
+                                ValueKey:              stringPointer("TYPE_KEY:mojom.test.NUM_MAGI"),
                                 ResolvedConcreteValue: &mojom_types.ValueLiteralValue{&mojom_types.LiteralValueInt64Value{3}},
                         }},
                 }}
 
                 // ResolvedTypes
 
                 // struct Foo
                 test.expectedGraph().ResolvedTypes["TYPE_KEY:mojom.test.Foo"] = &mojom_types.UserDefinedTypeStructType{mojom_types.MojomStruct{
                         DeclData: &mojom_types.DeclarationData{
-                                ShortName:        newString("Foo"),
-                                FullIdentifier:   newString("mojom.test.Foo"),
+                                ShortName:        stringPointer("Foo"),
+                                FullIdentifier:   stringPointer("mojom.test.Foo"),
                                 DeclaredOrdinal:  -1,
                                 DeclarationOrder: -1,
                                 SourceFileInfo: &mojom_types.SourceFileInfo{
                                         FileName: test.fileName(),
                                 },
                                 ContainedDeclarations: &mojom_types.ContainedDeclarations{
                                         Enums: &[]string{"TYPE_KEY:mojom.test.Foo.Hats"}},
                         },
                         Fields: []mojom_types.StructField{
                                 // field x
@@ skipping 114 matching lines @@
                         }
                         return fmt.Errorf("*****\nexpected=\n*****\n%q\n*****\nactual=\n*****\n%q\n*****\n"+
                                 "match failed at position %d: expected=\n*****\n%s\n******\nactual=\n*****\n%s\n******\n",
                                 expectedString, actualString, diffPos, mismatchExpected, mismatchActual)
                 } else {
                         return fmt.Errorf("expected != actual but the two printed equal.")
                 }
         }
         return nil
 }