minor SkSL changes to avoid compiler errors in Chromium

src/sksl/ir/SkSLType.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #ifndef SKIASL_TYPE
 #define SKIASL_TYPE
 
 #include "SkSLModifiers.h"
 #include "SkSLSymbol.h"
 #include "../SkSLPosition.h"
 #include "../SkSLUtil.h"
 #include "../spirv.h"
 #include <vector>
 #include <memory>
 
 namespace SkSL {
 
 class Context;
 
 /**
  * Represents a type, such as int or vec4.
  */
 class Type : public Symbol {
 public:
     struct Field {
-        Field(Modifiers modifiers, std::string name, const Type& type)
+        Field(Modifiers modifiers, std::string name, const Type* type)
         : fModifiers(modifiers)
         , fName(std::move(name))
         , fType(std::move(type)) {}
 
         const std::string description() const {
-            return fType.description() + " " + fName + ";";
+            return fType->description() + " " + fName + ";";
         }
 
-        const Modifiers fModifiers;
-        const std::string fName;
-        const Type& fType;
+        Modifiers fModifiers;
+        std::string fName;
+        const Type* fType;
     };
 
     enum Kind {
         kScalar_Kind,
         kVector_Kind,
         kMatrix_Kind,
         kArray_Kind,
         kStruct_Kind,
         kGeneric_Kind,
         kSampler_Kind,
@@ skipping 201 matching lines @@
             case kVector_Kind:
                 return vector_alignment(fComponentType->size(), fColumns);
             case kMatrix_Kind:
                 return (vector_alignment(fComponentType->size(), fRows) + 15) & ~15;
             case kArray_Kind:
                 // round up to next multiple of 16
                 return (fComponentType->alignment() + 15) & ~15;
             case kStruct_Kind: {
                 size_t result = 16;
                 for (size_t i = 0; i < fFields.size(); i++) {
-                    size_t alignment = fFields[i].fType.alignment();
+                    size_t alignment = fFields[i].fType->alignment();
                     if (alignment > result) {
                         result = alignment;
                     }
                 }
             }
             default:
                 ABORT(("cannot determine size of type " + fName).c_str());
         }
     }
 
@@ skipping 22 matching lines @@
                 return 4;
             case kVector_Kind:
                 return fColumns * fComponentType->size();
             case kMatrix_Kind:
                 return vector_alignment(fComponentType->size(), fRows) * fColumns;
             case kArray_Kind:
                 return fColumns * this->stride();
             case kStruct_Kind: {
                 size_t total = 0;
                 for (size_t i = 0; i < fFields.size(); i++) {
-                    size_t alignment = fFields[i].fType.alignment();
+                    size_t alignment = fFields[i].fType->alignment();
                     if (total % alignment != 0) {
                         total += alignment - total % alignment;
                     }
                     ASSERT(false);
                     ASSERT(total % alignment == 0);
-                    total += fFields[i].fType.size();
+                    total += fFields[i].fType->size();
                 }
                 return total;
             }
             default:
                 ABORT(("cannot determine size of type " + fName).c_str());
         }
     }
 
     /**
      * Returns the corresponding vector or matrix type with the specified number of columns and 
      * rows.
      */
     const Type& toCompound(const Context& context, int columns, int rows) const;
 
 private:
     typedef Symbol INHERITED;
 
     const Kind fTypeKind;
     const bool fIsNumber = false;
     const Type* fComponentType = nullptr;
-    const std::vector<const Type*> fCoercibleTypes = { };
+    const std::vector<const Type*> fCoercibleTypes;
     const int fColumns = -1;
     const int fRows = -1;
-    const std::vector<Field> fFields = { };
+    const std::vector<Field> fFields;
     const SpvDim_ fDimensions = SpvDim1D;
     const bool fIsDepth = false;
     const bool fIsArrayed = false;
     const bool fIsMultisampled = false;
     const bool fIsSampled = false;
 };
 
 } // namespace
 
 #endif