remove versioning interface

cmd/kube-apiserver/app/BUILD

@@ -59,7 +59,6 @@ go_library(
         "//vendor/k8s.io/apiextensions-apiserver/pkg/apiserver:go_default_library",
         "//vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/internalversion:go_default_library",
         "//vendor/k8s.io/apiextensions-apiserver/pkg/cmd/server:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/errors:go_default_library",

cmd/kube-apiserver/app/server.go

@@ -35,7 +35,6 @@ import (
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 
-	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
@@ -576,7 +575,7 @@ func BuildAdmissionPluginInitializers(
 	// We have a functional client so we can use that to build our discovery backed REST mapper
 	// Use a discovery client capable of being refreshed.
 	discoveryClient := cacheddiscovery.NewMemCacheClient(client.Discovery())
-	discoveryRESTMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.InterfacesForUnstructured)
+	discoveryRESTMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient)
 
 	admissionPostStartHook := func(context genericapiserver.PostStartHookContext) error {
 		discoveryRESTMapper.Reset()

cmd/kube-controller-manager/app/BUILD

@@ -109,7 +109,6 @@ go_library(
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/spf13/cobra:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",

cmd/kube-controller-manager/app/autoscaling.go

@@ -21,7 +21,6 @@ limitations under the License.
 package app
 
 import (
-	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/discovery"
 	discocache "k8s.io/client-go/discovery/cached"
@@ -77,7 +76,7 @@ func startHPAControllerWithMetricsClient(ctx ControllerContext, metricsClient me
 	// TODO: we need something like deferred discovery REST mapper that calls invalidate
 	// on cache misses.
 	cachedDiscovery := discocache.NewMemCacheClient(hpaClientGoClient.Discovery())
-	restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscovery, apimeta.InterfacesForUnstructured)
+	restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscovery)
 	restMapper.Reset()
 	// we don't use cached discovery because DiscoveryScaleKindResolver does its own caching,
 	// so we want to re-fetch every time when we actually ask for it

cmd/kube-controller-manager/app/core.go

@@ -29,7 +29,6 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/discovery"
@@ -352,7 +351,7 @@ func startGarbageCollectorController(ctx ControllerContext) (bool, error) {
 
 	// Use a discovery client capable of being refreshed.
 	discoveryClient := cacheddiscovery.NewMemCacheClient(gcClientset.Discovery())
-	restMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.InterfacesForUnstructured)
+	restMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient)
 	restMapper.Reset()
 
 	config := ctx.ClientBuilder.ConfigOrDie("generic-garbage-collector")

pkg/api/testapi/testapi.go

@@ -407,16 +407,6 @@ func (g TestGroup) StorageCodec() runtime.Codec {
 	return legacyscheme.Codecs.CodecForVersions(s, ds, schema.GroupVersions{g.externalGroupVersion}, nil)
 }
 
-// Converter returns the legacyscheme.Scheme for the API version to test against, as set by the
-// KUBE_TEST_API env var.
-func (g TestGroup) Converter() runtime.ObjectConvertor {
-	interfaces, err := legacyscheme.Registry.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
-	if err != nil {
-		panic(err)
-	}
-	return interfaces.ObjectConvertor
-}
-
 // SelfLink returns a self link that will appear to be for the version Version().
 // 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be
 // empty for lists.

pkg/apis/core/install/install_test.go

@@ -66,17 +66,6 @@ func TestCodec(t *testing.T) {
 	}
 }
 
-func TestInterfacesFor(t *testing.T) {
-	if _, err := legacyscheme.Registry.GroupOrDie(internal.GroupName).InterfacesFor(internal.SchemeGroupVersion); err == nil {
-		t.Fatalf("unexpected non-error: %v", err)
-	}
-	for i, version := range legacyscheme.Registry.GroupOrDie(internal.GroupName).GroupVersions {
-		if vi, err := legacyscheme.Registry.GroupOrDie(internal.GroupName).InterfacesFor(version); err != nil || vi == nil {
-			t.Fatalf("%d: unexpected result: %v", i, err)
-		}
-	}
-}
-
 func TestRESTMapper(t *testing.T) {
 	gv := schema.GroupVersion{Group: "", Version: "v1"}
 	rcGVK := gv.WithKind("ReplicationController")

pkg/controller/garbagecollector/garbagecollector_test.go

@@ -59,7 +59,7 @@ func (_ *testRESTMapper) Reset() {}
 func TestGarbageCollectorConstruction(t *testing.T) {
 	config := &restclient.Config{}
 	config.ContentConfig.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: metaonly.NewMetadataCodecFactory()}
-	tweakableRM := meta.NewDefaultRESTMapper(nil, nil)
+	tweakableRM := meta.NewDefaultRESTMapper(nil)
 	rm := &testRESTMapper{meta.MultiRESTMapper{tweakableRM, legacyscheme.Registry.RESTMapper()}}
 	metaOnlyClientPool := dynamic.NewClientPool(config, rm, dynamic.LegacyAPIPathResolverFunc)
 	config.ContentConfig.NegotiatedSerializer = nil

pkg/controller/history/BUILD

@@ -11,6 +11,7 @@ go_test(
     srcs = ["controller_history_test.go"],
     embed = [":go_default_library"],
     deps = [
+        "//pkg/api/legacyscheme:go_default_library",
         "//pkg/api/testapi:go_default_library",
         "//pkg/controller:go_default_library",
         "//vendor/k8s.io/api/apps/v1:go_default_library",

pkg/controller/history/controller_history_test.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/api/core/v1"
 	"k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes/fake"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/controller"
 
@@ -966,7 +967,7 @@ func TestRealHistory_AdoptControllerRevision(t *testing.T) {
 				if err != nil {
 					return true, nil, err
 				}
-				patched, err := testapi.Apps.Converter().ConvertToVersion(obj, apps.SchemeGroupVersion)
+				patched, err := legacyscheme.Scheme.ConvertToVersion(obj, apps.SchemeGroupVersion)
 				if err != nil {
 					return true, nil, err
 				}
@@ -1217,7 +1218,7 @@ func TestRealHistory_ReleaseControllerRevision(t *testing.T) {
 				if err != nil {
 					return true, nil, err
 				}
-				patched, err := testapi.Apps.Converter().ConvertToVersion(obj, apps.SchemeGroupVersion)
+				patched, err := legacyscheme.Scheme.ConvertToVersion(obj, apps.SchemeGroupVersion)
 				if err != nil {
 					return true, nil, err
 				}

pkg/kubectl/cmd/testing/BUILD

@@ -18,7 +18,6 @@ go_library(
         "//pkg/kubectl/cmd/util/openapi:go_default_library",
         "//pkg/kubectl/cmd/util/openapi/testing:go_default_library",
         "//pkg/kubectl/resource:go_default_library",
-        "//pkg/kubectl/scheme:go_default_library",
         "//pkg/kubectl/validation:go_default_library",
         "//pkg/printers:go_default_library",
         "//vendor/github.com/spf13/cobra:go_default_library",

pkg/kubectl/cmd/testing/fake.go

@@ -49,7 +49,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
 	openapitesting "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
-	"k8s.io/kubernetes/pkg/kubectl/scheme"
 	"k8s.io/kubernetes/pkg/kubectl/validation"
 	"k8s.io/kubernetes/pkg/printers"
 )
@@ -203,11 +202,7 @@ func AddToScheme(scheme *runtime.Scheme) (meta.RESTMapper, runtime.Codec) {
 
 	codecs := serializer.NewCodecFactory(scheme)
 	codec := codecs.LegacyCodec(UnlikelyGV)
-	mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{UnlikelyGV, ValidVersionGV}, func(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
+	mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{UnlikelyGV, ValidVersionGV})
-		return &meta.VersionInterfaces{
-			ObjectConvertor: scheme,
-		}, versionErrIfFalse(version == ValidVersionGV || version == UnlikelyGV)
-	})
 	for _, gv := range []schema.GroupVersion{UnlikelyGV, ValidVersionGV} {
 		for kind := range scheme.KnownTypes(gv) {
 			gvk := gv.WithKind(kind)
@@ -435,21 +430,7 @@ func (f *TestFactory) ClientSetForVersion(requiredVersion *schema.GroupVersion)
 
 func (f *TestFactory) Object() (meta.RESTMapper, runtime.ObjectTyper) {
 	groupResources := testDynamicResources()
-	mapper := discovery.NewRESTMapper(
+	mapper := discovery.NewRESTMapper(groupResources)
-		groupResources,
-		meta.InterfacesForUnstructuredConversion(func(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-			switch version {
-			// provide typed objects for these two versions
-			case ValidVersionGV, UnlikelyGV:
-				return &meta.VersionInterfaces{
-					ObjectConvertor: scheme.Scheme,
-				}, nil
-				// otherwise fall back to the legacy scheme
-			default:
-				return legacyscheme.Registry.InterfacesFor(version)
-			}
-		}),
-	)
 	// for backwards compatibility with existing tests, allow rest mappings from the scheme to show up
 	// TODO: make this opt-in?
 	mapper = meta.FirstHitRESTMapper{

pkg/kubectl/cmd/util/factory_object_mapping.go

@@ -94,8 +94,7 @@ func (f *ring1Factory) objectLoader() (meta.RESTMapper, runtime.ObjectTyper, err
 	}
 
 	// allow conversion between typed and unstructured objects
-	interfaces := meta.InterfacesForUnstructuredConversion(legacyscheme.Registry.InterfacesFor)
+	mapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient)
-	mapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.VersionInterfacesFunc(interfaces))
 	// TODO: should this also indicate it recognizes typed objects?
 	typer := discovery.NewUnstructuredObjectTyper(groupResources, legacyscheme.Scheme)
 	expander := NewShortcutExpander(mapper, discoveryClient)

pkg/kubelet/config/file_linux_test.go

@@ -34,6 +34,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
@@ -198,7 +199,7 @@ func getTestCases(hostname types.NodeName) []*testCase {
 
 func (tc *testCase) writeToFile(dir, name string, t *testing.T) string {
 	var versionedPod runtime.Object
-	err := testapi.Default.Converter().Convert(&tc.pod, &versionedPod, nil)
+	err := legacyscheme.Scheme.Convert(&tc.pod, &versionedPod, nil)
 	if err != nil {
 		t.Fatalf("%s: error in versioning the pod: %v", tc.desc, err)
 	}

pkg/kubelet/config/http_test.go

@@ -290,7 +290,7 @@ func TestExtractPodsFromHTTP(t *testing.T) {
 
 	for _, testCase := range testCases {
 		var versionedPods runtime.Object
-		err := testapi.Default.Converter().Convert(&testCase.pods, &versionedPods, nil)
+		err := legacyscheme.Scheme.Convert(&testCase.pods, &versionedPods, nil)
 		if err != nil {
 			t.Fatalf("%s: error in versioning the pods: %s", testCase.desc, err)
 		}

staging/src/k8s.io/api/Godeps/Godeps.json

@@ -126,10 +126,6 @@
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver/resources.go

@@ -323,7 +323,7 @@ func CreateNewScaleClient(crd *apiextensionsv1beta1.CustomResourceDefinition, co
 		},
 	}
 
-	restMapper := discovery.NewRESTMapper(resources, nil)
+	restMapper := discovery.NewRESTMapper(resources)
 	resolver := scale.NewDiscoveryScaleKindResolver(discoveryClient)
 
 	return scale.NewForConfig(config, restMapper, dynamic.LegacyAPIPathResolverFunc, resolver)

staging/src/k8s.io/apimachinery/pkg/api/meta/BUILD

@@ -38,13 +38,11 @@ go_library(
         "multirestmapper.go",
         "priority.go",
         "restmapper.go",
-        "unstructured.go",
     ],
     importpath = "k8s.io/apimachinery/pkg/api/meta",
     deps = [
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",

staging/src/k8s.io/apimachinery/pkg/api/meta/interfaces.go

@@ -23,11 +23,6 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 )
 
-// VersionInterfaces contains the interfaces one should use for dealing with types of a particular version.
-type VersionInterfaces struct {
-	ObjectConvertor runtime.ObjectConvertor
-}
-
 type ListMetaAccessor interface {
 	GetListMeta() List
 }

staging/src/k8s.io/apimachinery/pkg/api/meta/restmapper.go

@@ -62,8 +62,6 @@ type DefaultRESTMapper struct {
 	kindToScope          map[schema.GroupVersionKind]RESTScope
 	singularToPlural     map[schema.GroupVersionResource]schema.GroupVersionResource
 	pluralToSingular     map[schema.GroupVersionResource]schema.GroupVersionResource
-
-	interfacesFunc VersionInterfacesFunc
 }
 
 func (m *DefaultRESTMapper) String() string {
@@ -72,16 +70,12 @@ func (m *DefaultRESTMapper) String() string {
 
 var _ RESTMapper = &DefaultRESTMapper{}
 
-// VersionInterfacesFunc returns the appropriate typer, and metadata accessor for a
-// given api version, or an error if no such api version exists.
-type VersionInterfacesFunc func(version schema.GroupVersion) (*VersionInterfaces, error)
-
 // NewDefaultRESTMapper initializes a mapping between Kind and APIVersion
 // to a resource name and back based on the objects in a runtime.Scheme
 // and the Kubernetes API conventions. Takes a group name, a priority list of the versions
 // to search when an object has no default version (set empty to return an error),
 // and a function that retrieves the correct metadata for a given version.
-func NewDefaultRESTMapper(defaultGroupVersions []schema.GroupVersion, f VersionInterfacesFunc) *DefaultRESTMapper {
+func NewDefaultRESTMapper(defaultGroupVersions []schema.GroupVersion) *DefaultRESTMapper {
 	resourceToKind := make(map[schema.GroupVersionResource]schema.GroupVersionKind)
 	kindToPluralResource := make(map[schema.GroupVersionKind]schema.GroupVersionResource)
 	kindToScope := make(map[schema.GroupVersionKind]RESTScope)
@@ -96,7 +90,6 @@ func NewDefaultRESTMapper(defaultGroupVersions []schema.GroupVersion, f VersionI
 		defaultGroupVersions: defaultGroupVersions,
 		singularToPlural:     singularToPlural,
 		pluralToSingular:     pluralToSingular,
-		interfacesFunc:       f,
 	}
 }
 

staging/src/k8s.io/apimachinery/pkg/api/meta/restmapper_test.go

@@ -43,16 +43,8 @@ func (fakeConvertor) ConvertFieldLabel(version, kind, label, value string) (stri
 var validAccessor = resourceAccessor{}
 var validConvertor = fakeConvertor{}
 
-func fakeInterfaces(version schema.GroupVersion) (*VersionInterfaces, error) {
-	return &VersionInterfaces{ObjectConvertor: validConvertor}, nil
-}
-
 var unmatchedErr = errors.New("no version")
 
-func unmatchedVersionInterfaces(version schema.GroupVersion) (*VersionInterfaces, error) {
-	return nil, unmatchedErr
-}
-
 func TestRESTMapperVersionAndKindForResource(t *testing.T) {
 	testGroup := "test.group"
 	testVersion := "test"
@@ -71,7 +63,7 @@ func TestRESTMapperVersionAndKindForResource(t *testing.T) {
 		{Resource: schema.GroupVersionResource{Resource: "internalobjects"}, ExpectedGVK: testGroupVersion.WithKind("InternalObject")},
 	}
 	for i, testCase := range testCases {
-		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testGroupVersion}, fakeInterfaces)
+		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testGroupVersion})
 		if len(testCase.ExpectedGVK.Kind) != 0 {
 			mapper.Add(testCase.ExpectedGVK, RESTScopeNamespace)
 		}
@@ -104,7 +96,7 @@ func TestRESTMapperGroupForResource(t *testing.T) {
 		{Resource: schema.GroupVersionResource{Resource: "myobje"}, Err: true, GroupVersionKind: schema.GroupVersionKind{Group: "testapi", Version: "test", Kind: "MyObject"}},
 	}
 	for i, testCase := range testCases {
-		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testCase.GroupVersionKind.GroupVersion()}, fakeInterfaces)
+		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testCase.GroupVersionKind.GroupVersion()})
 		mapper.Add(testCase.GroupVersionKind, RESTScopeNamespace)
 
 		actualGVK, err := mapper.KindFor(testCase.Resource)
@@ -249,7 +241,7 @@ func TestRESTMapperKindsFor(t *testing.T) {
 	}
 	for _, testCase := range testCases {
 		tcName := testCase.Name
-		mapper := NewDefaultRESTMapper(testCase.PreferredOrder, fakeInterfaces)
+		mapper := NewDefaultRESTMapper(testCase.PreferredOrder)
 		for _, kind := range testCase.KindsToRegister {
 			mapper.Add(kind, RESTScopeNamespace)
 		}
@@ -426,7 +418,7 @@ func TestRESTMapperResourcesFor(t *testing.T) {
 		tcName := testCase.Name
 
 		for _, partialResource := range []schema.GroupVersionResource{testCase.PluralPartialResourceToRequest, testCase.SingularPartialResourceToRequest} {
-			mapper := NewDefaultRESTMapper(testCase.PreferredOrder, fakeInterfaces)
+			mapper := NewDefaultRESTMapper(testCase.PreferredOrder)
 			for _, kind := range testCase.KindsToRegister {
 				mapper.Add(kind, RESTScopeNamespace)
 			}
@@ -511,7 +503,7 @@ func TestRESTMapperResourceSingularizer(t *testing.T) {
 		{Kind: "lowercases", Plural: "lowercaseses", Singular: "lowercases"},
 	}
 	for i, testCase := range testCases {
-		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testGroupVersion}, fakeInterfaces)
+		mapper := NewDefaultRESTMapper([]schema.GroupVersion{testGroupVersion})
 		// create singular/plural mapping
 		mapper.Add(testGroupVersion.WithKind(testCase.Kind), RESTScopeNamespace)
 
@@ -556,7 +548,7 @@ func TestRESTMapperRESTMapping(t *testing.T) {
 		// TODO: add test for a resource that exists in one version but not another
 	}
 	for i, testCase := range testCases {
-		mapper := NewDefaultRESTMapper(testCase.DefaultVersions, fakeInterfaces)
+		mapper := NewDefaultRESTMapper(testCase.DefaultVersions)
 		mapper.Add(internalGroupVersion.WithKind("InternalObject"), RESTScopeNamespace)
 
 		preferredVersions := []string{}
@@ -595,7 +587,7 @@ func TestRESTMapperRESTMappingSelectsVersion(t *testing.T) {
 	internalObjectGK := schema.GroupKind{Group: "tgroup", Kind: "InternalObject"}
 	otherObjectGK := schema.GroupKind{Group: "tgroup", Kind: "OtherObject"}
 
-	mapper := NewDefaultRESTMapper([]schema.GroupVersion{expectedGroupVersion1, expectedGroupVersion2}, fakeInterfaces)
+	mapper := NewDefaultRESTMapper([]schema.GroupVersion{expectedGroupVersion1, expectedGroupVersion2})
 	mapper.Add(expectedGroupVersion1.WithKind("InternalObject"), RESTScopeNamespace)
 	mapper.Add(expectedGroupVersion2.WithKind("OtherObject"), RESTScopeNamespace)
 
@@ -696,7 +688,7 @@ func TestRESTMapperRESTMappings(t *testing.T) {
 	}
 
 	for i, testCase := range testCases {
-		mapper := NewDefaultRESTMapper(testCase.DefaultVersions, fakeInterfaces)
+		mapper := NewDefaultRESTMapper(testCase.DefaultVersions)
 		for _, gvk := range testCase.AddGroupVersionKind {
 			mapper.Add(gvk, RESTScopeNamespace)
 		}
@@ -735,7 +727,7 @@ func TestRESTMapperReportsErrorOnBadVersion(t *testing.T) {
 	expectedGroupVersion2 := schema.GroupVersion{Group: "tgroup", Version: "test2"}
 	internalObjectGK := schema.GroupKind{Group: "tgroup", Kind: "InternalObject"}
 
-	mapper := NewDefaultRESTMapper([]schema.GroupVersion{expectedGroupVersion1, expectedGroupVersion2}, unmatchedVersionInterfaces)
+	mapper := NewDefaultRESTMapper([]schema.GroupVersion{expectedGroupVersion1, expectedGroupVersion2})
 	mapper.Add(expectedGroupVersion1.WithKind("InternalObject"), RESTScopeNamespace)
 	_, err := mapper.RESTMapping(internalObjectGK, "test3")
 	if err == nil {

staging/src/k8s.io/apimachinery/pkg/api/meta/unstructured.go

@@ -1,45 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package meta
-
-import (
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// InterfacesForUnstructuredConversion returns VersionInterfaces suitable for
-// dealing with unstructured.Unstructured objects and supports conversion
-// from typed objects (provided by parent) to untyped objects.
-func InterfacesForUnstructuredConversion(parent VersionInterfacesFunc) VersionInterfacesFunc {
-	return func(version schema.GroupVersion) (*VersionInterfaces, error) {
-		if i, err := parent(version); err == nil {
-			return &VersionInterfaces{
-				ObjectConvertor: i.ObjectConvertor,
-			}, nil
-		}
-		return InterfacesForUnstructured(version)
-	}
-}
-
-// InterfacesForUnstructured returns VersionInterfaces suitable for
-// dealing with unstructured.Unstructured objects. It will return errors for
-// other conversions.
-func InterfacesForUnstructured(schema.GroupVersion) (*VersionInterfaces, error) {
-	return &VersionInterfaces{
-		ObjectConvertor: &unstructured.UnstructuredObjectConverter{},
-	}, nil
-}

staging/src/k8s.io/apimachinery/pkg/apimachinery/BUILD

@@ -3,14 +3,6 @@ package(default_visibility = ["//visibility:public"])
 load(
     "@io_bazel_rules_go//go:def.bzl",
     "go_library",
-    "go_test",
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["types_test.go"],
-    embed = [":go_default_library"],
-    deps = ["//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library"],
 )
 
 go_library(

staging/src/k8s.io/apimachinery/pkg/apimachinery/announced/group_factory.go

@@ -157,18 +157,6 @@ func (gmf *GroupMetaFactory) Register(m *registered.APIRegistrationManager, sche
 		SelfLinker:      runtime.SelfLinker(accessor),
 		RootScopedKinds: gmf.GroupArgs.RootScopedKinds,
 	}
-	for _, v := range externalVersions {
-		gvf := gmf.VersionArgs[v.Version]
-		if err := groupMeta.AddVersionInterfaces(
-			schema.GroupVersion{Group: gvf.GroupName, Version: gvf.VersionName},
-			&meta.VersionInterfaces{
-				ObjectConvertor: scheme,
-			},
-		); err != nil {
-			return err
-		}
-	}
-	groupMeta.InterfacesFor = groupMeta.DefaultInterfacesFor
 	groupMeta.RESTMapper = gmf.newRESTMapper(scheme, externalVersions, groupMeta)
 
 	if err := m.RegisterGroup(*groupMeta); err != nil {
@@ -190,7 +178,7 @@ func (gmf *GroupMetaFactory) newRESTMapper(scheme *runtime.Scheme, externalVersi
 		ignoredKinds = gmf.GroupArgs.IgnoredKinds
 	}
 
-	mapper := meta.NewDefaultRESTMapper(externalVersions, groupMeta.InterfacesFor)
+	mapper := meta.NewDefaultRESTMapper(externalVersions)
 	for _, gv := range externalVersions {
 		for kind := range scheme.KnownTypes(gv) {
 			if ignoredKinds.Has(kind) {

staging/src/k8s.io/apimachinery/pkg/apimachinery/registered/registered.go

@@ -124,15 +124,6 @@ func (m *APIRegistrationManager) RegisteredVersionsForGroup(group string) []sche
 	return ret
 }
 
-// InterfacesFor is a union meta.VersionInterfacesFunc func for all registered types
-func (m *APIRegistrationManager) InterfacesFor(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	groupMeta, err := m.Group(version.Group)
-	if err != nil {
-		return nil, err
-	}
-	return groupMeta.InterfacesFor(version)
-}
-
 // TODO: This is an expedient function, because we don't check if a Group is
 // supported throughout the code base. We will abandon this function and
 // checking the error returned by the Group() function.

staging/src/k8s.io/apimachinery/pkg/apimachinery/types.go

@@ -17,8 +17,6 @@ limitations under the License.
 package apimachinery
 
 import (
-	"fmt"
-
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -41,47 +39,4 @@ type GroupMeta struct {
 	// RESTMapper provides the default mapping between REST paths and the objects declared in a Scheme and all known
 	// versions.
 	RESTMapper meta.RESTMapper
-
-	// InterfacesFor returns the default Codec and ResourceVersioner for a given version
-	// string, or an error if the version is not known.
-	// TODO: make this stop being a func pointer and always use the default
-	// function provided below once every place that populates this field has been changed.
-	InterfacesFor func(version schema.GroupVersion) (*meta.VersionInterfaces, error)
-
-	// InterfacesByVersion stores the per-version interfaces.
-	InterfacesByVersion map[schema.GroupVersion]*meta.VersionInterfaces
-}
-
-// DefaultInterfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-// TODO: Remove the "Default" prefix.
-func (gm *GroupMeta) DefaultInterfacesFor(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	if v, ok := gm.InterfacesByVersion[version]; ok {
-		return v, nil
-	}
-	return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, gm.GroupVersions)
-}
-
-// AddVersionInterfaces adds the given version to the group. Only call during
-// init, after that GroupMeta objects should be immutable. Not thread safe.
-// (If you use this, be sure to set .InterfacesFor = .DefaultInterfacesFor)
-// TODO: remove the "Interfaces" suffix and make this also maintain the
-// .GroupVersions member.
-func (gm *GroupMeta) AddVersionInterfaces(version schema.GroupVersion, interfaces *meta.VersionInterfaces) error {
-	if e, a := gm.GroupVersions[0].Group, version.Group; a != e {
-		return fmt.Errorf("got a version in group %v, but am in group %v", a, e)
-	}
-	if gm.InterfacesByVersion == nil {
-		gm.InterfacesByVersion = make(map[schema.GroupVersion]*meta.VersionInterfaces)
-	}
-	gm.InterfacesByVersion[version] = interfaces
-
-	// TODO: refactor to make the below error not possible, this function
-	// should *set* GroupVersions rather than depend on it.
-	for _, v := range gm.GroupVersions {
-		if v == version {
-			return nil
-		}
-	}
-	return fmt.Errorf("added a version interface without the corresponding version %v being in the list %#v", version, gm.GroupVersions)
 }

staging/src/k8s.io/apimachinery/pkg/apimachinery/types_test.go

@@ -1,39 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package apimachinery
-
-import (
-	"testing"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-func TestAdd(t *testing.T) {
-	gm := GroupMeta{
-		GroupVersions: []schema.GroupVersion{{Group: "test", Version: "v1"}},
-	}
-
-	gm.AddVersionInterfaces(schema.GroupVersion{Group: "test", Version: "v1"}, nil)
-	if e, a := 1, len(gm.InterfacesByVersion); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	// GroupVersions is unchanged
-	if e, a := 1, len(gm.GroupVersions); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-}

staging/src/k8s.io/apiserver/pkg/endpoints/apiserver_test.go

@@ -130,33 +130,6 @@ func init() {
 	examplev1.AddToScheme(scheme)
 }
 
-func interfacesFor(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case testGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor: scheme,
-		}, nil
-	case newGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor: scheme,
-		}, nil
-	case grouplessGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor: scheme,
-		}, nil
-	case testGroup2Version:
-		return &meta.VersionInterfaces{
-			ObjectConvertor: scheme,
-		}, nil
-	default:
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, groupVersions)
-	}
-}
-
-func newMapper() *meta.DefaultRESTMapper {
-	return meta.NewDefaultRESTMapper([]schema.GroupVersion{testGroupVersion, newGroupVersion}, interfacesFor)
-}
-
 func addGrouplessTypes() {
 	scheme.AddKnownTypes(grouplessGroupVersion,
 		&genericapitesting.Simple{}, &genericapitesting.SimpleList{}, &metav1.ListOptions{}, &metav1.ExportOptions{},

staging/src/k8s.io/apiserver/pkg/server/genericapiserver_test.go

@@ -153,20 +153,13 @@ func TestInstallAPIGroups(t *testing.T) {
 		scheme.AddKnownTypes(v1GroupVersion, &metav1.Status{})
 		metav1.AddToGroupVersion(scheme, v1GroupVersion)
 
-		interfacesFor := func(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
+		mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv})
-			return &meta.VersionInterfaces{
-				ObjectConvertor: scheme,
-			}, nil
-		}
-
-		mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, interfacesFor)
 		for kind := range scheme.KnownTypes(gv) {
 			mapper.Add(gv.WithKind(kind), meta.RESTScopeNamespace)
 		}
 		groupMeta := apimachinery.GroupMeta{
 			GroupVersions: []schema.GroupVersion{gv},
 			RESTMapper:    mapper,
-			InterfacesFor: interfacesFor,
 		}
 
 		return APIGroupInfo{

staging/src/k8s.io/client-go/discovery/restmapper.go

@@ -39,7 +39,7 @@ type APIGroupResources struct {
 
 // NewRESTMapper returns a PriorityRESTMapper based on the discovered
 // groups and resources passed in.
-func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
+func NewRESTMapper(groupResources []*APIGroupResources) meta.RESTMapper {
 	unionMapper := meta.MultiRESTMapper{}
 
 	var groupPriority []string
@@ -90,7 +90,7 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 			}
 
 			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
+			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv})
 
 			for _, resource := range resources {
 				scope := meta.RESTScopeNamespace
@@ -175,19 +175,17 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 // initialization of the RESTMapper until the first mapping is
 // requested.
 type DeferredDiscoveryRESTMapper struct {
-	initMu           sync.Mutex
+	initMu   sync.Mutex
-	delegate         meta.RESTMapper
+	delegate meta.RESTMapper
-	cl               CachedDiscoveryInterface
+	cl       CachedDiscoveryInterface
-	versionInterface meta.VersionInterfacesFunc
 }
 
 // NewDeferredDiscoveryRESTMapper returns a
 // DeferredDiscoveryRESTMapper that will lazily query the provided
 // client for discovery information to do REST mappings.
-func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
+func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface) *DeferredDiscoveryRESTMapper {
 	return &DeferredDiscoveryRESTMapper{
-		cl:               cl,
+		cl: cl,
-		versionInterface: versionInterface,
 	}
 }
 
@@ -204,7 +202,7 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
 		return nil, err
 	}
 
-	d.delegate = NewRESTMapper(groupResources, d.versionInterface)
+	d.delegate = NewRESTMapper(groupResources)
 	return d.delegate, err
 }
 

staging/src/k8s.io/client-go/discovery/restmapper_test.go

@@ -94,7 +94,7 @@ func TestRESTMapper(t *testing.T) {
 		},
 	}
 
-	restMapper := NewRESTMapper(resources, nil)
+	restMapper := NewRESTMapper(resources)
 
 	kindTCs := []struct {
 		input schema.GroupVersionResource
@@ -243,7 +243,7 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert := assert.New(t)
 
 	cdc := fakeCachedDiscoveryInterface{fresh: false}
-	m := NewDeferredDiscoveryRESTMapper(&cdc, nil)
+	m := NewDeferredDiscoveryRESTMapper(&cdc)
 	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
 	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")
 

staging/src/k8s.io/client-go/dynamic/BUILD

@@ -14,7 +14,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",

staging/src/k8s.io/client-go/dynamic/dynamic_util.go

@@ -27,8 +27,8 @@ import (
 )
 
 // NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
-func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList) (*meta.DefaultRESTMapper, error) {
-	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
+	rm := meta.NewDefaultRESTMapper(nil)
 	for _, resourceList := range resources {
 		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {

staging/src/k8s.io/client-go/dynamic/dynamic_util_test.go

@@ -19,9 +19,7 @@ package dynamic
 import (
 	"testing"
 
-	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
@@ -45,7 +43,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		Kind:    "test_kind",
 	}
 
-	mapper, err := NewDiscoveryRESTMapper(resources, versionInterfaces)
+	mapper, err := NewDiscoveryRESTMapper(resources)
 	if err != nil {
 		t.Fatalf("unexpected error creating mapper: %s", err)
 	}
@@ -79,11 +77,3 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		}
 	}
 }
-
-// VersionInterfaces provides an object converter and metadata
-// accessor appropriate for use with unstructured objects.
-func versionInterfaces(schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	return &meta.VersionInterfaces{
-		ObjectConvertor: &unstructured.UnstructuredObjectConverter{},
-	}, nil
-}

staging/src/k8s.io/client-go/scale/BUILD

@@ -43,7 +43,6 @@ go_test(
         "//vendor/k8s.io/api/autoscaling/v1:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/testing/roundtrip:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",

staging/src/k8s.io/client-go/scale/client_test.go

@@ -40,7 +40,6 @@ import (
 	autoscalingv1 "k8s.io/api/autoscaling/v1"
 	corev1 "k8s.io/api/core/v1"
 	extv1beta1 "k8s.io/api/extensions/v1beta1"
-	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	coretesting "k8s.io/client-go/testing"
 )
 
@@ -101,7 +100,7 @@ func fakeScaleClient(t *testing.T) (ScalesGetter, []schema.GroupResource) {
 	if err != nil {
 		t.Fatalf("unexpected error while constructing resource list from fake discovery client: %v", err)
 	}
-	restMapper := discovery.NewRESTMapper(restMapperRes, apimeta.InterfacesForUnstructured)
+	restMapper := discovery.NewRESTMapper(restMapperRes)
 
 	autoscalingScale := &autoscalingv1.Scale{
 		TypeMeta: metav1.TypeMeta{

staging/src/k8s.io/metrics/Godeps/Godeps.json

@@ -274,10 +274,6 @@
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
 			"Rev": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

test/e2e/framework/BUILD

@@ -116,7 +116,6 @@ go_library(
         "//vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset:go_default_library",
         "//vendor/k8s.io/apiextensions-apiserver/test/integration/testserver:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",

test/e2e/framework/framework.go

@@ -28,7 +28,6 @@ import (
 
 	"k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -182,7 +181,7 @@ func (f *Framework) BeforeEach() {
 		discoClient, err := discovery.NewDiscoveryClientForConfig(config)
 		Expect(err).NotTo(HaveOccurred())
 		cachedDiscoClient := cacheddiscovery.NewMemCacheClient(discoClient)
-		restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscoClient, meta.InterfacesForUnstructured)
+		restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscoClient)
 		restMapper.Reset()
 		resolver := scaleclient.NewDiscoveryScaleKindResolver(cachedDiscoClient)
 		f.ScalesGetter = scaleclient.New(restClient, restMapper, dynamic.LegacyAPIPathResolverFunc, resolver)

test/e2e/scalability/BUILD

@@ -23,7 +23,6 @@ go_library(
         "//vendor/github.com/onsi/ginkgo:go_default_library",
         "//vendor/github.com/onsi/gomega:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",

test/e2e/scalability/load.go

@@ -28,7 +28,6 @@ import (
 	"time"
 
 	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
@@ -410,7 +409,7 @@ func createClients(numberOfClients int) ([]clientset.Interface, []internalclient
 			return nil, nil, nil, err
 		}
 		cachedDiscoClient := cacheddiscovery.NewMemCacheClient(discoClient)
-		restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscoClient, meta.InterfacesForUnstructured)
+		restMapper := discovery.NewDeferredDiscoveryRESTMapper(cachedDiscoClient)
 		restMapper.Reset()
 		resolver := scaleclient.NewDiscoveryScaleKindResolver(cachedDiscoClient)
 		scalesClients[i] = scaleclient.New(restClient, restMapper, dynamic.LegacyAPIPathResolverFunc, resolver)

test/integration/garbagecollector/garbage_collector_test.go

@@ -219,7 +219,7 @@ func setupWithServer(t *testing.T, result *kubeapiservertesting.TestServer, work
 	createNamespaceOrDie("aval", clientSet, t)
 
 	discoveryClient := cacheddiscovery.NewMemCacheClient(clientSet.Discovery())
-	restMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.InterfacesForUnstructured)
+	restMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient)
 	restMapper.Reset()
 	deletableResources := garbagecollector.GetDeletableResources(discoveryClient)
 	config := *result.ClientConfig