Re-add metadata passthrough on Get operations

service/datastore/datastore.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 datastore
 
 import (
         "fmt"
         "reflect"
 
@@ skipping 109 matching lines @@
         return errors.SingleError(d.DeleteMulti([]Key{key}))
 }
 
 func (d *datastoreImpl) GetMulti(dst interface{}) error {
         slice := reflect.ValueOf(dst)
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid GetMulti input type: %T", dst)
         }
 
-        keys, err := mat.GetKeys(d.NewKey, slice)
+        keys, pms, err := mat.GetKeysPMs(d.NewKey, slice)
         if err != nil {
                 return err
         }
 
         lme := errors.LazyMultiError{Size: len(keys)}
         i := 0
-        err = d.RawInterface.GetMulti(keys, func(pm PropertyMap, err error) {
+        meta := NewMultiMetaGetter(pms)
+        err = d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) {
                 if !lme.Assign(i, err) {
                         lme.Assign(i, mat.setPM(slice.Index(i), pm))
                 }
                 i++
         })
 
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (d *datastoreImpl) PutMulti(src interface{}) error {
         slice := reflect.ValueOf(src)
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid PutMulti input type: %T", src)
         }
 
-        keys, err := mat.GetKeys(d.NewKey, slice)
+        keys, vals, err := mat.GetKeysPMs(d.NewKey, slice)
         if err != nil {
                 return err
         }
-
-        vals, err := mat.GetPMs(slice)
-        if err != nil {
-                return err
-        }
 
         lme := errors.LazyMultiError{Size: len(keys)}
         i := 0
         err = d.RawInterface.PutMulti(keys, vals, func(key Key, err error) {
                 if key != keys[i] {
                         mat.setKey(slice.Index(i), key)
                 }
                 lme.Assign(i, err)
                 i++
         })
@@ skipping 14 matching lines @@
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }