Remove ResolveCapture from rpc interface

Change-Id: Ic7b7b804d8185f6b27eeb38f5bbca65a2a41d433

6 files changed, 0 insertions, 139 deletions

diff --git a/service/service_binary.go b/service/service_binary.go
index 5f6f68ea0..a9a5b064d 100644
--- a/service/service_binary.go
+++ b/service/service_binary.go
@@ -48,7 +48,6 @@ func init() {
 	Namespace.Add((*callPrerenderFramebuffers)(nil).Class())
 	Namespace.Add((*callResolveAtomStream)(nil).Class())
 	Namespace.Add((*callResolveBinary)(nil).Class())
-	Namespace.Add((*callResolveCapture)(nil).Class())
 	Namespace.Add((*callResolveDevice)(nil).Class())
 	Namespace.Add((*callResolveImageInfo)(nil).Class())
 	Namespace.Add((*callResolveMemoryInfo)(nil).Class())
@@ -67,7 +66,6 @@ func init() {
 	Namespace.Add((*resultPrerenderFramebuffers)(nil).Class())
 	Namespace.Add((*resultResolveAtomStream)(nil).Class())
 	Namespace.Add((*resultResolveBinary)(nil).Class())
-	Namespace.Add((*resultResolveCapture)(nil).Class())
 	Namespace.Add((*resultResolveDevice)(nil).Class())
 	Namespace.Add((*resultResolveImageInfo)(nil).Class())
 	Namespace.Add((*resultResolveMemoryInfo)(nil).Class())
@@ -102,7 +100,6 @@ var (
 	binaryIDcallPrerenderFramebuffers   = binary.ID{0xce, 0xd0, 0x43, 0x9a, 0x0a, 0x96, 0xbd, 0x47, 0xe1, 0x4e, 0x08, 0xf0, 0x67, 0x37, 0x96, 0x84, 0x1a, 0x06, 0xb0, 0xfc}
 	binaryIDcallResolveAtomStream       = binary.ID{0xf6, 0x44, 0x79, 0x4e, 0x89, 0x71, 0x7b, 0x54, 0x13, 0xbc, 0xa7, 0x18, 0x32, 0xb0, 0xa7, 0x34, 0xa9, 0x4a, 0x7f, 0xe7}
 	binaryIDcallResolveBinary           = binary.ID{0x66, 0x2b, 0x48, 0xb6, 0x65, 0x55, 0xc3, 0x76, 0x0b, 0x74, 0x40, 0x50, 0xd3, 0xbd, 0xfd, 0x65, 0x8b, 0x61, 0x2a, 0x77}
-	binaryIDcallResolveCapture          = binary.ID{0x5c, 0x66, 0xb4, 0x71, 0xfa, 0x2f, 0xa1, 0x8f, 0x10, 0xc8, 0xea, 0xc0, 0x5f, 0x8b, 0x2c, 0xf9, 0xcf, 0x8b, 0x7d, 0xa7}
 	binaryIDcallResolveDevice           = binary.ID{0x48, 0xf3, 0xd3, 0xbd, 0x29, 0x59, 0x29, 0xf6, 0xf2, 0xce, 0xa3, 0x87, 0xcb, 0xb2, 0xe9, 0xd4, 0xd3, 0xfc, 0xf0, 0x21}
 	binaryIDcallResolveImageInfo        = binary.ID{0x77, 0xdf, 0xf2, 0x6b, 0xf5, 0x1a, 0xa3, 0x65, 0x46, 0xac, 0xe4, 0x2d, 0x97, 0x22, 0x47, 0x5b, 0x8f, 0xa0, 0x52, 0xc9}
 	binaryIDcallResolveMemoryInfo       = binary.ID{0xb6, 0xd6, 0x5f, 0x4e, 0xd9, 0xdc, 0x07, 0x08, 0x4c, 0x8e, 0x3f, 0x8d, 0x80, 0x41, 0x85, 0x29, 0xf9, 0x27, 0xd5, 0x28}
@@ -121,7 +118,6 @@ var (
 	binaryIDresultPrerenderFramebuffers = binary.ID{0xb3, 0x13, 0x48, 0x75, 0x2a, 0xf4, 0xab, 0xf7, 0x59, 0x96, 0x1b, 0x20, 0x61, 0xfe, 0x3d, 0x4c, 0xc5, 0x47, 0x4c, 0xf9}
 	binaryIDresultResolveAtomStream     = binary.ID{0x05, 0xb9, 0x98, 0x3d, 0x6f, 0x5f, 0xc0, 0x23, 0xb2, 0xe1, 0x2e, 0x55, 0xf4, 0x37, 0x71, 0xe6, 0xd3, 0x98, 0xbf, 0x52}
 	binaryIDresultResolveBinary         = binary.ID{0xa4, 0x6a, 0xe4, 0xfe, 0x13, 0x16, 0xb3, 0x2a, 0x70, 0x6e, 0x71, 0xea, 0x47, 0xf0, 0x4c, 0xe6, 0x47, 0xc9, 0xb0, 0x42}
-	binaryIDresultResolveCapture        = binary.ID{0xb3, 0x47, 0xd0, 0x3f, 0x28, 0x63, 0xfe, 0xa4, 0x32, 0xc6, 0xf0, 0x2c, 0xec, 0x6d, 0x33, 0x8a, 0xb2, 0x38, 0xf7, 0x37}
 	binaryIDresultResolveDevice         = binary.ID{0x7f, 0xd2, 0x9f, 0x67, 0xe3, 0xbe, 0x0e, 0x46, 0x07, 0xdf, 0x8f, 0x6e, 0x6e, 0x85, 0x6d, 0x26, 0xcf, 0xd1, 0xa6, 0xa3}
 	binaryIDresultResolveImageInfo      = binary.ID{0xdf, 0x45, 0x26, 0xc3, 0xec, 0x36, 0x2c, 0x5a, 0x08, 0xe3, 0x0f, 0x8e, 0x58, 0x52, 0xbd, 0xb2, 0xf3, 0x26, 0x69, 0x9f}
 	binaryIDresultResolveMemoryInfo     = binary.ID{0x1f, 0xcf, 0x9a, 0x85, 0x99, 0x82, 0x5f, 0xa8, 0x46, 0x93, 0x60, 0xa5, 0x17, 0xda, 0x9e, 0x11, 0x34, 0xe8, 0x3d, 0x22}
@@ -2138,55 +2134,6 @@ var schemacallResolveBinary = &schema.Class{
 	},
 }
 
-type binaryClasscallResolveCapture struct{}
-
-func (*callResolveCapture) Class() binary.Class {
-	return (*binaryClasscallResolveCapture)(nil)
-}
-func doEncodecallResolveCapture(e binary.Encoder, o *callResolveCapture) error {
-	if err := e.ID(binary.ID(o.id)); err != nil {
-		return err
-	}
-	return nil
-}
-func doDecodecallResolveCapture(d binary.Decoder, o *callResolveCapture) error {
-	if obj, err := d.ID(); err != nil {
-		return err
-	} else {
-		o.id = CaptureID(obj)
-	}
-	return nil
-}
-func doSkipcallResolveCapture(d binary.Decoder) error {
-	if err := d.SkipID(); err != nil {
-		return err
-	}
-	return nil
-}
-func (*binaryClasscallResolveCapture) ID() binary.ID      { return binaryIDcallResolveCapture }
-func (*binaryClasscallResolveCapture) New() binary.Object { return &callResolveCapture{} }
-func (*binaryClasscallResolveCapture) Encode(e binary.Encoder, obj binary.Object) error {
-	return doEncodecallResolveCapture(e, obj.(*callResolveCapture))
-}
-func (*binaryClasscallResolveCapture) Decode(d binary.Decoder) (binary.Object, error) {
-	obj := &callResolveCapture{}
-	return obj, doDecodecallResolveCapture(d, obj)
-}
-func (*binaryClasscallResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
-	return doDecodecallResolveCapture(d, obj.(*callResolveCapture))
-}
-func (*binaryClasscallResolveCapture) Skip(d binary.Decoder) error { return doSkipcallResolveCapture(d) }
-func (*binaryClasscallResolveCapture) Schema() *schema.Class       { return schemacallResolveCapture }
-
-var schemacallResolveCapture = &schema.Class{
-	TypeID:  binaryIDcallResolveCapture,
-	Package: "service",
-	Name:    "callResolveCapture",
-	Fields: []schema.Field{
-		{Declared: "id", Type: &schema.Primitive{Name: "CaptureID", Method: schema.ID}},
-	},
-}
-
 type binaryClasscallResolveDevice struct{}
 
 func (*callResolveDevice) Class() binary.Class {
@@ -3193,55 +3140,6 @@ var schemaresultResolveBinary = &schema.Class{
 	},
 }
 
-type binaryClassresultResolveCapture struct{}
-
-func (*resultResolveCapture) Class() binary.Class {
-	return (*binaryClassresultResolveCapture)(nil)
-}
-func doEncoderesultResolveCapture(e binary.Encoder, o *resultResolveCapture) error {
-	if err := e.Value(&o.value); err != nil {
-		return err
-	}
-	return nil
-}
-func doDecoderesultResolveCapture(d binary.Decoder, o *resultResolveCapture) error {
-	if err := d.Value(&o.value); err != nil {
-		return err
-	}
-	return nil
-}
-func doSkipresultResolveCapture(d binary.Decoder) error {
-	if err := d.SkipValue((*Capture)(nil)); err != nil {
-		return err
-	}
-	return nil
-}
-func (*binaryClassresultResolveCapture) ID() binary.ID      { return binaryIDresultResolveCapture }
-func (*binaryClassresultResolveCapture) New() binary.Object { return &resultResolveCapture{} }
-func (*binaryClassresultResolveCapture) Encode(e binary.Encoder, obj binary.Object) error {
-	return doEncoderesultResolveCapture(e, obj.(*resultResolveCapture))
-}
-func (*binaryClassresultResolveCapture) Decode(d binary.Decoder) (binary.Object, error) {
-	obj := &resultResolveCapture{}
-	return obj, doDecoderesultResolveCapture(d, obj)
-}
-func (*binaryClassresultResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
-	return doDecoderesultResolveCapture(d, obj.(*resultResolveCapture))
-}
-func (*binaryClassresultResolveCapture) Skip(d binary.Decoder) error {
-	return doSkipresultResolveCapture(d)
-}
-func (*binaryClassresultResolveCapture) Schema() *schema.Class { return schemaresultResolveCapture }
-
-var schemaresultResolveCapture = &schema.Class{
-	TypeID:  binaryIDresultResolveCapture,
-	Package: "service",
-	Name:    "resultResolveCapture",
-	Fields: []schema.Field{
-		{Declared: "value", Type: &schema.Struct{Name: "Capture", ID: (*Capture)(nil).Class().ID()}},
-	},
-}
-
 type binaryClassresultResolveDevice struct{}
 
 func (*resultResolveDevice) Class() binary.Class {
diff --git a/service/service_client.go b/service/service_client.go
index 49f2f4c78..d710bafd8 100644
--- a/service/service_client.go
+++ b/service/service_client.go
@@ -164,16 +164,6 @@ func (c client) ResolveBinary(id BinaryID, l log.Logger) (res []uint8, err error
 	return
 }
 
-func (c client) ResolveCapture(id CaptureID, l log.Logger) (res Capture, err error) {
-	var val interface{}
-	if val, err = c.Send(&callResolveCapture{id: id}); err == nil {
-		res = val.(*resultResolveCapture).value
-	} else {
-		log.Errorf(l, "RPC ResolveCapture failed with error: %v", err)
-	}
-	return
-}
-
 func (c client) ResolveDevice(id DeviceID, l log.Logger) (res Device, err error) {
 	var val interface{}
 	if val, err = c.Send(&callResolveDevice{id: id}); err == nil {
diff --git a/service/service_extra.go b/service/service_extra.go
index bb3c136fe..ea7e4381d 100644
--- a/service/service_extra.go
+++ b/service/service_extra.go
@@ -176,18 +176,6 @@ type resultResolveBinary struct {
 	value []uint8
 }
 
-// Call ResolveCapture
-type callResolveCapture struct {
-	binary.Generate
-	id CaptureID
-}
-
-// Result ResolveCapture
-type resultResolveCapture struct {
-	binary.Generate
-	value Capture
-}
-
 // Call ResolveDevice
 type callResolveDevice struct {
 	binary.Generate
diff --git a/service/service_helpers.go b/service/service_helpers.go
index f4655b816..46e26b9a5 100644
--- a/service/service_helpers.go
+++ b/service/service_helpers.go
@@ -105,14 +105,6 @@ func (c callResolveBinary) Format(f fmt.State, r rune) {
 func (r resultResolveBinary) Format(f fmt.State, c rune) {
 	fmt.Fprintf(f, "res: %#v", r.value)
 }
-func (c callResolveCapture) Format(f fmt.State, r rune) {
-	fmt.Fprintf(f, "ResolveCapture(id: %v)",
-		c.id,
-	)
-}
-func (r resultResolveCapture) Format(f fmt.State, c rune) {
-	fmt.Fprintf(f, "res: %#v", r.value)
-}
 func (c callResolveDevice) Format(f fmt.State, r rune) {
 	fmt.Fprintf(f, "ResolveDevice(id: %v)",
 		c.id,
diff --git a/service/service_rpc.go b/service/service_rpc.go
index 409e5f72e..9edc774af 100644
--- a/service/service_rpc.go
+++ b/service/service_rpc.go
@@ -86,7 +86,6 @@ type RPC interface {
 
 	ResolveAtomStream(id AtomStreamID, l log.Logger) (AtomStream, error)
 	ResolveBinary(id BinaryID, l log.Logger) ([]uint8, error)
-	ResolveCapture(id CaptureID, l log.Logger) (Capture, error)
 	ResolveDevice(id DeviceID, l log.Logger) (Device, error)
 	ResolveImageInfo(id ImageInfoID, l log.Logger) (ImageInfo, error)
 	ResolveMemoryInfo(id MemoryInfoID, l log.Logger) (MemoryInfo, error)
diff --git a/service/service_server.go b/service/service_server.go
index 1f2057aac..280c7341b 100644
--- a/service/service_server.go
+++ b/service/service_server.go
@@ -109,12 +109,6 @@ func BindServer(r io.Reader, w io.Writer, mtu int, l log.Logger, server RPC) {
 			} else {
 				return rpc.NewError(err.Error())
 			}
-		case *callResolveCapture:
-			if res, err := server.ResolveCapture(call.id, l); err == nil {
-				return &resultResolveCapture{value: res}
-			} else {
-				return rpc.NewError(err.Error())
-			}
 		case *callResolveDevice:
 			if res, err := server.ResolveDevice(call.id, l); err == nil {
 				return &resultResolveDevice{value: res}