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

            pauseOnNextExit = true;
            ExitCallback();
        }

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

		// 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 void StepComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugStepper pStepper, CorDebugStepReason reason)
		{
			ManagedCallback managedCallback = GetProcessCallbackInterface(pAppDomain);
			if (managedCallback != null) {
				managedCallback.StepComplete(pAppDomain, pThread, pStepper, reason);
			}
		}

        private DebuggeeProcess GetProcessWrapper(ICorDebugAppDomain appDomain)
        {
            ICorDebugProcess process;
            appDomain.GetProcess(out process);
            return GetProcessWrapper(process);

        }

		internal DnAppDomain(DnProcess ownerProcess, ICorDebugAppDomain appDomain, int incrementedId) {
			this.ownerProcess = ownerProcess;
			this.assemblies = new DebuggerCollection<ICorDebugAssembly, DnAssembly>(CreateAssembly);
			this.appDomain = new CorAppDomain(appDomain);
			this.incrementedId = incrementedId;
			NameChanged();
		}

 public CorDebugAppDomain(ICorDebugAppDomain _appdomain) {
     m_appdomain = _appdomain;
     uint size = 0;
     m_appdomain.GetName(0, out size, null);
     StringBuilder name = new StringBuilder((int)size);
     _appdomain.GetName((uint)name.Capacity, out size, name);
     Name = name.ToString();
 }

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

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

		internal DnAppDomain(DnProcess ownerProcess, ICorDebugAppDomain appDomain, int uniqueId, int uniqueIdProcess) {
			Process = ownerProcess;
			assemblies = new DebuggerCollection<ICorDebugAssembly, DnAssembly>(CreateAssembly);
			CorAppDomain = new CorAppDomain(appDomain);
			UniqueId = uniqueId;
			UniqueIdProcess = uniqueIdProcess;
			NameChanged();
		}

        public void CreateAppDomain(ICorDebugProcess pProcess, ICorDebugAppDomain pAppDomain)
        {
            var domain = new DebugDomain(null, pAppDomain);
            Logger.WriteLine("App domain {0} created", domain.Name);

            pAppDomain.Attach();

            pProcess.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);
        }

        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);
        }

        //
        // IEnumerator interface
        //

        #region IEnumerator Members

        public bool MoveNext()
        {
            var a = new ICorDebugAppDomain[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_ad = new CorAppDomain(a[0]);
            else
                m_ad = null;
            return m_ad != null;
        }

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

        /// <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));
        }

        // 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();
        }

        private IList<DebugDomain> LoadDomains()
        {
            ICorDebugAppDomainEnum domainsEnum;
            _debugProcess.EnumerateAppDomains(out domainsEnum);

            uint domainsCount;
            domainsEnum.GetCount(out domainsCount);

            ICorDebugAppDomain[] domains = new ICorDebugAppDomain[domainsCount];
            uint domainsFetched;
            domainsEnum.Next(domainsCount, domains, out domainsFetched);

            var list = new List<DebugDomain>((int)domainsFetched);

            for (int i = 0; i < domainsFetched; i++)
            {
                list.Add(new DebugDomain(_debugEngine, domains[i]));
            }

            return list;
        }

 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 ICorDebugManagedCallback.EditAndContinueRemap(
                                  ICorDebugAppDomain appDomain,
                                  ICorDebugThread thread,
                                  ICorDebugFunction managedFunction,
                                  int isAccurate)
 {
     Debug.Assert(false); //OBSOLETE callback
 }