1 files changed, 0 insertions, 342 deletions
diff --git a/vendor/github.com/godbus/dbus/v5/default_handler.go b/vendor/github.com/godbus/dbus/v5/default_handler.go
deleted file mode 100644
index 13132c6b4..000000000
--- a/vendor/github.com/godbus/dbus/v5/default_handler.go
+++ /dev/null
@@ -1,342 +0,0 @@
-package dbus
-
-import (
-	"bytes"
-	"reflect"
-	"strings"
-	"sync"
-)
-
-func newIntrospectIntf(h *defaultHandler) *exportedIntf {
-	methods := make(map[string]Method)
-	methods["Introspect"] = exportedMethod{
-		reflect.ValueOf(func(msg Message) (string, *Error) {
-			path := msg.Headers[FieldPath].value.(ObjectPath)
-			return h.introspectPath(path), nil
-		}),
-	}
-	return newExportedIntf(methods, true)
-}
-
-//NewDefaultHandler returns an instance of the default
-//call handler. This is useful if you want to implement only
-//one of the two handlers but not both.
-//
-// Deprecated: this is the default value, don't use it, it will be unexported.
-func NewDefaultHandler() *defaultHandler {
-	h := &defaultHandler{
-		objects:     make(map[ObjectPath]*exportedObj),
-		defaultIntf: make(map[string]*exportedIntf),
-	}
-	h.defaultIntf["org.freedesktop.DBus.Introspectable"] = newIntrospectIntf(h)
-	return h
-}
-
-type defaultHandler struct {
-	sync.RWMutex
-	objects     map[ObjectPath]*exportedObj
-	defaultIntf map[string]*exportedIntf
-}
-
-func (h *defaultHandler) PathExists(path ObjectPath) bool {
-	_, ok := h.objects[path]
-	return ok
-}
-
-func (h *defaultHandler) introspectPath(path ObjectPath) string {
-	subpath := make(map[string]struct{})
-	var xml bytes.Buffer
-	xml.WriteString("<node>")
-	for obj := range h.objects {
-		p := string(path)
-		if p != "/" {
-			p += "/"
-		}
-		if strings.HasPrefix(string(obj), p) {
-			node_name := strings.Split(string(obj[len(p):]), "/")[0]
-			subpath[node_name] = struct{}{}
-		}
-	}
-	for s := range subpath {
-		xml.WriteString("\n\t<node name=\"" + s + "\"/>")
-	}
-	xml.WriteString("\n</node>")
-	return xml.String()
-}
-
-func (h *defaultHandler) LookupObject(path ObjectPath) (ServerObject, bool) {
-	h.RLock()
-	defer h.RUnlock()
-	object, ok := h.objects[path]
-	if ok {
-		return object, ok
-	}
-
-	// If an object wasn't found for this exact path,
-	// look for a matching subtree registration
-	subtreeObject := newExportedObject()
-	path = path[:strings.LastIndex(string(path), "/")]
-	for len(path) > 0 {
-		object, ok = h.objects[path]
-		if ok {
-			for name, iface := range object.interfaces {
-				// Only include this handler if it registered for the subtree
-				if iface.isFallbackInterface() {
-					subtreeObject.interfaces[name] = iface
-				}
-			}
-			break
-		}
-
-		path = path[:strings.LastIndex(string(path), "/")]
-	}
-
-	for name, intf := range h.defaultIntf {
-		if _, exists := subtreeObject.interfaces[name]; exists {
-			continue
-		}
-		subtreeObject.interfaces[name] = intf
-	}
-
-	return subtreeObject, true
-}
-
-func (h *defaultHandler) AddObject(path ObjectPath, object *exportedObj) {
-	h.Lock()
-	h.objects[path] = object
-	h.Unlock()
-}
-
-func (h *defaultHandler) DeleteObject(path ObjectPath) {
-	h.Lock()
-	delete(h.objects, path)
-	h.Unlock()
-}
-
-type exportedMethod struct {
-	reflect.Value
-}
-
-func (m exportedMethod) Call(args ...interface{}) ([]interface{}, error) {
-	t := m.Type()
-
-	params := make([]reflect.Value, len(args))
-	for i := 0; i < len(args); i++ {
-		params[i] = reflect.ValueOf(args[i]).Elem()
-	}
-
-	ret := m.Value.Call(params)
-	var err error
-	nilErr := false // The reflection will find almost-nils, let's only pass back clean ones!
-	if t.NumOut() > 0 {
-		if e, ok := ret[t.NumOut()-1].Interface().(*Error); ok { // godbus *Error
-			nilErr = ret[t.NumOut()-1].IsNil()
-			ret = ret[:t.NumOut()-1]
-			err = e
-		} else if ret[t.NumOut()-1].Type().Implements(errType) { // Go error
-			i := ret[t.NumOut()-1].Interface()
-			if i == nil {
-				nilErr = ret[t.NumOut()-1].IsNil()
-			} else {
-				err = i.(error)
-			}
-			ret = ret[:t.NumOut()-1]
-		}
-	}
-	out := make([]interface{}, len(ret))
-	for i, val := range ret {
-		out[i] = val.Interface()
-	}
-	if nilErr || err == nil {
-		//concrete type to interface nil is a special case
-		return out, nil
-	}
-	return out, err
-}
-
-func (m exportedMethod) NumArguments() int {
-	return m.Value.Type().NumIn()
-}
-
-func (m exportedMethod) ArgumentValue(i int) interface{} {
-	return reflect.Zero(m.Type().In(i)).Interface()
-}
-
-func (m exportedMethod) NumReturns() int {
-	return m.Value.Type().NumOut()
-}
-
-func (m exportedMethod) ReturnValue(i int) interface{} {
-	return reflect.Zero(m.Type().Out(i)).Interface()
-}
-
-func newExportedObject() *exportedObj {
-	return &exportedObj{
-		interfaces: make(map[string]*exportedIntf),
-	}
-}
-
-type exportedObj struct {
-	mu         sync.RWMutex
-	interfaces map[string]*exportedIntf
-}
-
-func (obj *exportedObj) LookupInterface(name string) (Interface, bool) {
-	if name == "" {
-		return obj, true
-	}
-	obj.mu.RLock()
-	defer obj.mu.RUnlock()
-	intf, exists := obj.interfaces[name]
-	return intf, exists
-}
-
-func (obj *exportedObj) AddInterface(name string, iface *exportedIntf) {
-	obj.mu.Lock()
-	defer obj.mu.Unlock()
-	obj.interfaces[name] = iface
-}
-
-func (obj *exportedObj) DeleteInterface(name string) {
-	obj.mu.Lock()
-	defer obj.mu.Unlock()
-	delete(obj.interfaces, name)
-}
-
-func (obj *exportedObj) LookupMethod(name string) (Method, bool) {
-	obj.mu.RLock()
-	defer obj.mu.RUnlock()
-	for _, intf := range obj.interfaces {
-		method, exists := intf.LookupMethod(name)
-		if exists {
-			return method, exists
-		}
-	}
-	return nil, false
-}
-
-func (obj *exportedObj) isFallbackInterface() bool {
-	return false
-}
-
-func newExportedIntf(methods map[string]Method, includeSubtree bool) *exportedIntf {
-	return &exportedIntf{
-		methods:        methods,
-		includeSubtree: includeSubtree,
-	}
-}
-
-type exportedIntf struct {
-	methods map[string]Method
-
-	// Whether or not this export is for the entire subtree
-	includeSubtree bool
-}
-
-func (obj *exportedIntf) LookupMethod(name string) (Method, bool) {
-	out, exists := obj.methods[name]
-	return out, exists
-}
-
-func (obj *exportedIntf) isFallbackInterface() bool {
-	return obj.includeSubtree
-}
-
-//NewDefaultSignalHandler returns an instance of the default
-//signal handler. This is useful if you want to implement only
-//one of the two handlers but not both.
-//
-// Deprecated: this is the default value, don't use it, it will be unexported.
-func NewDefaultSignalHandler() *defaultSignalHandler {
-	return &defaultSignalHandler{}
-}
-
-type defaultSignalHandler struct {
-	mu      sync.RWMutex
-	closed  bool
-	signals []*signalChannelData
-}
-
-func (sh *defaultSignalHandler) DeliverSignal(intf, name string, signal *Signal) {
-	sh.mu.RLock()
-	defer sh.mu.RUnlock()
-	if sh.closed {
-		return
-	}
-	for _, scd := range sh.signals {
-		scd.deliver(signal)
-	}
-}
-
-func (sh *defaultSignalHandler) Terminate() {
-	sh.mu.Lock()
-	defer sh.mu.Unlock()
-	if sh.closed {
-		return
-	}
-
-	for _, scd := range sh.signals {
-		scd.close()
-		close(scd.ch)
-	}
-	sh.closed = true
-	sh.signals = nil
-}
-
-func (sh *defaultSignalHandler) AddSignal(ch chan<- *Signal) {
-	sh.mu.Lock()
-	defer sh.mu.Unlock()
-	if sh.closed {
-		return
-	}
-	sh.signals = append(sh.signals, &signalChannelData{
-		ch:   ch,
-		done: make(chan struct{}),
-	})
-}
-
-func (sh *defaultSignalHandler) RemoveSignal(ch chan<- *Signal) {
-	sh.mu.Lock()
-	defer sh.mu.Unlock()
-	if sh.closed {
-		return
-	}
-	for i := len(sh.signals) - 1; i >= 0; i-- {
-		if ch == sh.signals[i].ch {
-			sh.signals[i].close()
-			copy(sh.signals[i:], sh.signals[i+1:])
-			sh.signals[len(sh.signals)-1] = nil
-			sh.signals = sh.signals[:len(sh.signals)-1]
-		}
-	}
-}
-
-type signalChannelData struct {
-	wg   sync.WaitGroup
-	ch   chan<- *Signal
-	done chan struct{}
-}
-
-func (scd *signalChannelData) deliver(signal *Signal) {
-	select {
-	case scd.ch <- signal:
-	case <-scd.done:
-		return
-	default:
-		scd.wg.Add(1)
-		go scd.deferredDeliver(signal)
-	}
-}
-
-func (scd *signalChannelData) deferredDeliver(signal *Signal) {
-	select {
-	case scd.ch <- signal:
-	case <-scd.done:
-	}
-	scd.wg.Done()
-}
-
-func (scd *signalChannelData) close() {
-	close(scd.done)
-	scd.wg.Wait() // wait until all spawned goroutines return
-}