Chain of delegates in Swift

Question

TDLR; I have three classes, when Class A object is updated, it's calling on its delegate (Class B) which is calling on its delegate (Class C) without doing anything else. Class C will use Class B in different ways depending on the values in Class A. Class B need to know of its Class A at touch events. Is this acceptable?

classA { var information: String }
classB { var thing: ClassA thing.delegate = self }
classC { var things: [ClassB] for thing in things { thing.delegate = self } } 

My real example

I have three classes: A mapViewController, a mapMarker and a place (model). The map holds multiple mapMarkers, and every mapMarker has a property place, which contains information of what the marker should look like (like place type, "bar", "restaurant" etc). The place might receive new information via a silent push notification, and hence being updated. When the place is updated, I need to notify the mapViewController that the marker needs to be redrawn (I'm using MapBox and their annotations doesn't support redrawing in any way but removing and adding the marker again, since the imageForAnnotation method is a delegate one.)

My first thought was to make two protocols placeDelegate and mapMarkerDelegate.

Place:

protocol PlaceDelegate: class
{
  func placeUpdated()
}

class Place {
    weak var delegate: PlaceDelegate?

    var propertyThatCanBeUpdate: String {
        didSet { 
        //Checking if the newValue == oldValue 
        delegate.placeUpdated()
        }
}

MapMarker

protocol MapMarkerDelegate: class
{
    markerShouldReDraw(mapMarker: MapMarker)
}

class MapMarker: PlaceDelegate {
    var place: Place!
    weak var delegate: MapMarkerDelegate?
    init(place: Place) {
        self.place = place
        place.delegate = place
    }

    func placeUpdate()
    {
        delegate.markerShouldReDraw(self)
    }

} 

MapViewController

class MapViewController {
//I could easily set the marker.delegate = self when adding the markers

func markerShouldReDraw(mapMarker: MapMarker)
    functionForRedrawingMarker()
}

This feels a bit ugly, and a bit weird that the MapMarker is just passing the "my place has been updated" information forward. Is this acceptable as far as performance goes? Should I use some kind of NSNotification instead? Should I make the MapViewController the delegate of place and search my array of mapMarker for the one holding the correct place?