Update APIs to use new Google cloud paths.

client/flagpb/unmarshal.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package flagpb
 
 import (
         "bytes"
         "encoding/hex"
         "encoding/json"
         "fmt"
         "strconv"
         "strings"
 
+        "github.com/luci/luci-go/common/proto/google/descutil"
+
         "github.com/golang/protobuf/jsonpb"
         "github.com/golang/protobuf/proto"
-        "github.com/luci/luci-go/common/proto/google/descriptor"
+        "google.golang.org/genproto/protobuf"
 )
 
 // UnmarshalMessage unmarshals the proto message from flags.
 //
 // The descriptor set should be obtained from the `cproto` compiled packages'
 // FileDescriptorSet() method.
 func UnmarshalMessage(flags []string, resolver Resolver, msg proto.Message) error {
         // TODO(iannucci): avoid round-trip through parser and jsonpb and populate the
         // message directly. This would involve writing some additional reflection
         // code that may depend on implementation details of proto's generated Go
@@ skipping 95 matching lines @@
         target := &root
         if len(pathMsgs) > 0 {
                 lastMsg := pathMsgs[len(pathMsgs)-1]
                 target = &lastMsg.message
         }
         name := fieldPath[len(fieldPath)-1]
 
         // Resolve target field.
         var fieldIndex int
         if target.desc.GetOptions().GetMapEntry() {
-                if fieldIndex = target.desc.FindField("value"); fieldIndex == -1 {
+                if fieldIndex = descutil.FindField(target.desc, "value"); fieldIndex == -1 {
                         return nil, fmt.Errorf("map entry type %s does not have value field", target.desc.GetName())
                 }
         } else {
-                if fieldIndex = target.desc.FindField(name); fieldIndex == -1 {
+                if fieldIndex = descutil.FindField(target.desc, name); fieldIndex == -1 {
                         return nil, fmt.Errorf("field %s not found in message %s", name, target.desc.GetName())
                 }
         }
         field := target.desc.Field[fieldIndex]
 
         var value interface{}
         hasValue := false
 
         if !hasValueStr {
                 switch {
                 // Boolean and repeated message fields may have no value and ignore
                 // next argument.
                 case field.GetType() == descriptor.FieldDescriptorProto_TYPE_BOOL:
                         value = true
                         hasValue = true
-                case field.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE && field.Repeated():
+                case field.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE && descutil.Repeated(field):
                         value = map[string]interface{}{}
                         hasValue = true
 
                 default:
                         // Read next argument as a value.
                         if len(flags) == 0 {
                                 return nil, fmt.Errorf("value was expected")
                         }
                         valueStr, flags = flags[0], flags[1:]
                 }
         }
 
         // Check if the value is already set.
-        if target.data[name] != nil && !field.Repeated() {
+        if target.data[name] != nil && !descutil.Repeated(field) {
                 repeatedFields := make([]string, 0, len(pathMsgs))
                 for _, m := range pathMsgs {
                         if m.repeated {
                                 repeatedFields = append(repeatedFields, "-"+strings.Join(m.path, "."))
                         }
                 }
                 if len(repeatedFields) == 0 {
                         return nil, fmt.Errorf("value is already set to %v", target.data[name])
                 }
                 return nil, fmt.Errorf(
                         "value is already set to %v. Did you forgot to insert %s in between to declare a new repeated message?",
                         target.data[name], strings.Join(repeatedFields, " or "))
         }
 
         if !hasValue {
                 value, err = p.parseFieldValue(valueStr, target.desc.GetName(), field)
                 if err != nil {
                         return nil, err
                 }
         }
 
-        if !field.Repeated() {
+        if !descutil.Repeated(field) {
                 target.data[name] = value
         } else {
                 target.data[name] = append(asSlice(target.data[name]), value)
         }
 
         return flags, nil
 }
 
 type subMsg struct {
         message
@@ skipping 10 matching lines @@
 // If a field is not a message field, returns an error.
 func (p *parser) subMessages(root message, path []string) ([]subMsg, error) {
         result := make([]subMsg, 0, len(path))
 
         parent := &root
         for i, name := range path {
                 curPath := path[:i+1]
 
                 var fieldIndex int
                 if parent.desc.GetOptions().GetMapEntry() {
-                        if fieldIndex = parent.desc.FindField("value"); fieldIndex == -1 {
+                        if fieldIndex = descutil.FindField(parent.desc, "value"); fieldIndex == -1 {
                                 return nil, fmt.Errorf("map entry type %s does not have value field", parent.desc.GetName())
                         }
                 } else {
-                        if fieldIndex = parent.desc.FindField(name); fieldIndex == -1 {
+                        if fieldIndex = descutil.FindField(parent.desc, name); fieldIndex == -1 {
                                 return nil, fmt.Errorf("field %q not found in message %s", name, parent.desc.GetName())
                         }
                 }
 
                 f := parent.desc.Field[fieldIndex]
                 if f.GetType() != descriptor.FieldDescriptorProto_TYPE_MESSAGE {
                         return nil, fmt.Errorf("field %s is not a message", strings.Join(curPath, "."))
                 }
 
                 subDescInterface, err := p.resolve(f.GetTypeName())
                 if err != nil {
                         return nil, err
                 }
                 subDesc, ok := subDescInterface.(*descriptor.DescriptorProto)
                 if !ok {
                         return nil, fmt.Errorf("%s is not a message", f.GetTypeName())
                 }
 
                 sub := subMsg{
                         message:  message{desc: subDesc},
-                        repeated: f.Repeated() && !subDesc.GetOptions().GetMapEntry(),
+                        repeated: descutil.Repeated(f) && !subDesc.GetOptions().GetMapEntry(),
                         path:     curPath,
                 }
                 if value, ok := parent.data[name]; !ok {
                         sub.data = map[string]interface{}{}
                         if sub.repeated {
                                 parent.data[name] = []interface{}{sub.data}
                         } else {
                                 parent.data[name] = sub.data
                         }
                 } else {
@@ skipping 98 matching lines @@
         case 2:
                 key = parts[0]
                 value = parts[1]
                 hasValue = true
         }
         return
 }
 
 // parseEnum returns the number of an enum member, which can be name or number.
 func parseEnum(enum *descriptor.EnumDescriptorProto, member string) (int32, error) {
-        i := enum.FindValue(member)
+        i := descutil.FindEnumValue(enum, member)
         if i < 0 {
                 // Is member the number?
                 if number, err := strconv.ParseInt(member, 10, 32); err == nil {
-                        i = enum.FindValueByNumber(int32(number))
+                        i = descutil.FindValueByNumber(enum, int32(number))
                 }
         }
         if i < 0 {
                 return 0, fmt.Errorf("invalid value %q for enum %s", member, enum.GetName())
         }
         return enum.Value[i].GetNumber(), nil
 }
 
 func asSlice(x interface{}) []interface{} {
         if x == nil {
                 return nil
         }
         return x.([]interface{})
 }