     }
 
     func on(event: Event<E>) {
-        // Do we need lock here?
-        _parent.lock.performLocked {
-            switch event {
-            case .Next:
+        switch event {
+        case .Next:
+            _parent._lock.performLocked {
                 _parent._forwardElements = true
                 _singleAssignmentDisposable.dispose()
-            case .Error(let e):
+            }
+        case .Error(let e):
+            _parent._lock.performLocked {
                 _parent._observer?.onError(e)
                 _parent.dispose()
-            case .Completed:
-                _singleAssignmentDisposable.dispose()
             }
+        case .Completed:
+            _singleAssignmentDisposable.dispose()
         }
     }
     

    typealias E = ElementType
    typealias Parent = SkipUntil<E, Other>
    
    let lock = NSRecursiveLock()
    private let _parent: Parent
    private var _forwardElements = false
    

    }
    
    func on(event: Event<E>) {
        _lock.performLocked {
            switch event {
            case .Next:
                if _forwardElements {
                    _observer?.on(event)
                }
            case .Error:
                observer?.on(event)
                dispose()
            case .Completed:
                if _forwardElements {
                    _observer?.on(event)
                }
                _singleAssignmentDisposable.dispose()
            }
        }
    }
    
