// Do not pass the pBreakpoint parameter as ICorDebugBreakpoint - marshaling of it fails in .NET 1.1
		public void Breakpoint(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, IntPtr pBreakpoint)
		{
			ManagedCallback managedCallback = GetProcessCallbackInterface(pAppDomain);
			if (managedCallback != null) {
				managedCallback.Breakpoint(pAppDomain, pThread, pBreakpoint);
			}
		}

 public virtual void Breakpoint(
     ICorDebugAppDomain appDomain, 
     ICorDebugThread thread, 
     ICorDebugBreakpoint breakpoint)
 {
     this.DefaultHandler(appDomain);
 }

        public void Break(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread)
        {
            EnterCallback(PausedReason.Break, "Break", pThread);

            pauseOnNextExit = true;
            ExitCallback();
        }

		public void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
		{
			ManagedCallback managedCallback = GetProcessCallbackInterface(pAppDomain);
			if (managedCallback != null) {
				managedCallback.StepComplete(pAppDomain, pThread, pStepper, reason);
			}
		}

 public CorDebugThread(ICorDebugThread _thread)
 {
     m_corThread = _thread;
     uint id;
     m_corThread.GetID(out id);
     ID = id;
 }

 public virtual void EditAndContinueRemap(
     ICorDebugAppDomain appDomain, 
     ICorDebugThread thread, 
     ICorDebugFunction function, 
     bool accurate)
 {
     this.DefaultHandler(appDomain);
 }

 public void Breakpoint(
     ICorDebugAppDomain pAppDomain, 
     ICorDebugThread pThread, 
     ICorDebugBreakpoint pBreakpoint)
 {
     m_listner.PostBreakPoint(new CorThread(pThread));
     //controller.Continue(0);
 }

        public void Breakpoint(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugBreakpoint pBreakpoint)
        {
            var handler = OnBreakpoint;
            if (handler != null)
            {
                handler(this, new DebuggerBreakpointEventArgs(pThread, pBreakpoint));
            }

            pAppDomain.Continue(0);
        }

		internal void AddThread(ICorDebugThread corThread)
		{
			Thread thread = new Thread(this, corThread);
			threadCollection.Add(thread);
			OnThreadStarted(thread);
			
			thread.NativeThreadExited += delegate {
				threadCollection.Remove(thread);
			};
		}

		internal Thread GetThread(ICorDebugThread corThread)
		{
			foreach(Thread thread in threadCollection) {
				if (thread.CorThread == corThread) {
					return thread;
				}
			}
			
			throw new DebuggerException("Thread is not in collection");
		}

        private void HandleEvalEvent(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugEval pEval)
        {
            var domain = GetProcessWrapper(pAppDomain).GetAppDomain(pAppDomain);
            var thread = domain.GetThread(pThread);
            var eval = Session.ComInstanceCollector.GetWrapper<RuntimeEvaluation>(pEval);

            var eventArgs = new DebuggerEventArgs(domain, true);
            eval.DispatchEvaluationCompleted(eventArgs);
            FinalizeEvent(eventArgs);
        }

		public ManagedCallback GetProcessCallbackInterface(string name, ICorDebugThread pThread)
		{
			ICorDebugProcess pProcess;
			try {
				pProcess = pThread.Process;
			} catch (COMException e) {
				debugger.TraceMessage("Ignoring callback \"" + name + "\": " + e.Message);
				return null;
			}
			return GetProcessCallbackInterface(name, pProcess);
		}

        //
        // IEnumerator interface
        //

        #region IEnumerator Members

        public bool MoveNext()
        {
            var a = new ICorDebugThread[1];
            uint c = 0;
            int r = m_enum.Next((uint) a.Length, a, out c);
            if (r == 0 && c == 1) // S_OK && we got 1 new element
                m_th = new CorThread(a[0]);
            else
                m_th = null;
            return m_th != null;
        }

        // Warning! Marshaing of ICorBreakpoint fails in .NET 1.1
        public void Breakpoint(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugBreakpoint corBreakpoint)
        {
            EnterCallback(PausedReason.Breakpoint, "Breakpoint", pThread);

            Breakpoint breakpoint = process.Debugger.Breakpoints[corBreakpoint];
            // The event will be risen outside the callback
            process.BreakpointHitEventQueue.Enqueue(breakpoint);

            pauseOnNextExit = true;

            ExitCallback();
        }

        /// <summary>
        /// Finds appropriete SequncePointMap instances and builds SequencePointRemapper, gets new IL offset and call RemapFunction.
        /// </summary>
        public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset)
        {
            ICorDebugILFrame2 frame = (ICorDebugILFrame2) pThread.GetActiveFrame();

            uint nToken = pOldFunction.GetToken();

            SequencePointRemapper remapper;
            if(!remappers.TryGetValue(nToken,out remapper)){
                throw new KeyNotFoundException("Methods sequence points not found.");
            }
            frame.__RemapFunction(remapper.TranslateILOffset(oldILOffset));
        }

 void ICorDebugManagedCallback2.FunctionRemapComplete(ICorDebugAppDomain appDomain,
                                                      ICorDebugThread thread,
                                                      ICorDebugFunction managedFunction)
 {
     HandleEvent(ManagedCallbackType.OnFunctionRemapComplete,
                        new CorFunctionRemapCompleteEventArgs(appDomain == null ? null : new CorAppDomain(appDomain),
                                               thread == null ? null : new CorThread(thread),
                                               managedFunction == null ? null : new CorFunction(managedFunction),
                                               ManagedCallbackType.OnFunctionRemapComplete));
 }

 void ICorDebugManagedCallback2.Exception(ICorDebugAppDomain ad, ICorDebugThread thread,
                                          ICorDebugFrame frame, uint offset,
                                          CorDebugExceptionCallbackType eventType, uint flags) 
 {
     HandleEvent(ManagedCallbackType.OnException2,
                               new CorException2EventArgs(ad == null ? null : new CorAppDomain(ad),
                                                 thread == null ? null : new CorThread(thread),
                                                 frame == null ? null : new CorFrame(frame),
                                                 (int)offset,
                                                 eventType,
                                                 (int)flags,
                                                 ManagedCallbackType.OnException2));
 }

 void ICorDebugManagedCallback.BreakpointSetError(
                                ICorDebugAppDomain appDomain,
                                ICorDebugThread thread,
                                ICorDebugBreakpoint breakpoint,
                                UInt32 errorCode)
 {
     HandleEvent(ManagedCallbackType.OnBreakpointSetError,
                       new CorBreakpointSetErrorEventArgs(appDomain == null ? null : new CorAppDomain(appDomain),
                                                 thread == null ? null : new CorThread(thread),
                                                 null, 
                                                 (int)errorCode,
                                                 ManagedCallbackType.OnBreakpointSetError));
 }

 void ICorDebugManagedCallback2.FunctionRemapOpportunity(ICorDebugAppDomain appDomain,
                                                                ICorDebugThread thread,
                                                                ICorDebugFunction oldFunction,
                                                                ICorDebugFunction newFunction,
                                                                uint oldILoffset)
 {
     HandleEvent(ManagedCallbackType.OnFunctionRemapOpportunity,
                               new CorFunctionRemapOpportunityEventArgs(appDomain == null ? null : new CorAppDomain(appDomain),
                                                                        thread == null ? null : new CorThread(thread),
                                                                        oldFunction == null ? null : new CorFunction(oldFunction),
                                                                        newFunction == null ? null : new CorFunction(newFunction),
                                                                        (int)oldILoffset,
                                                                        ManagedCallbackType.OnFunctionRemapOpportunity));
 }

 void ICorDebugManagedCallback.NameChange(
                         ICorDebugAppDomain appDomain,
                         ICorDebugThread thread)
 {
     HandleEvent(ManagedCallbackType.OnNameChange,
                       new CorThreadEventArgs( appDomain == null ? null : new CorAppDomain(appDomain),
                                               thread == null ? null : new CorThread(thread),
                                               ManagedCallbackType.OnNameChange));
 }