public RemoteTargetProxy(GrpcConnection connection, GrpcSbTarget grpcSbTarget,
RemoteTargetRpcService.RemoteTargetRpcServiceClient client,
GrpcBreakpointFactory breakpointFactory, GrpcErrorFactory errorFactory,
GrpcProcessFactory processFactory, GrpcModuleFactory moduleFactory,
GrpcWatchpointFactory watchpointFactory, GrpcAddressFactory addressFactory)
{
this.connection = connection;
this.grpcSbTarget = grpcSbTarget;
this.client = client;
this.breakpointFactory = breakpointFactory;
this.errorFactory = errorFactory;
this.processFactory = processFactory;
this.moduleFactory = moduleFactory;
this.watchpointFactory = watchpointFactory;
this.addressFactory = addressFactory;
}
internal static FrameInfo <SbModule> CreateFrameInfo(GrpcFrameInfo info,
GrpcModuleFactory moduleFactory, GrpcConnection connection) =>
new FrameInfo <SbModule>
{
AddrMax = info.AddrMax,
AddrMin = info.AddrMin,
Args = info.Args,
FuncName = info.FuncName,
Language = info.Language,
ModuleName = info.ModuleName,
ReturnType = info.ReturnType,
Flags = info.Flags,
ValidFields = (FrameInfoFlags)info.ValidFields,
HasDebugInfo = info.HasDebugInfo,
StaleCode = info.StaleCode,
Module = info.Module != null?moduleFactory.Create(connection, info.Module) : null
};
// <summary>
// Used by tests to pass in mock objects.
// </summary>
internal RemoteThreadProxy(GrpcConnection connection, GrpcSbThread grpcSbThread,
RemoteThreadRpcService.RemoteThreadRpcServiceClient client,
RemoteFrameProxyFactory frameFactory, GrpcProcessFactory processFactory,
GrpcErrorFactory errorFactory, GrpcModuleFactory moduleFactory)
{
this.connection = connection;
this.grpcSbThread = grpcSbThread;
this.client = client;
this.frameFactory = frameFactory;
this.processFactory = processFactory;
this.errorFactory = errorFactory;
this.moduleFactory = moduleFactory;
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, RemoteThreadRpcService.RemoteThreadRpcServiceClient,
GrpcSbThread>(connection, client, grpcSbThread));
}
internal RemoteFrameProxy(GrpcConnection connection, GrpcSbFrame grpcSbFrame,
RemoteFrameRpcService.RemoteFrameRpcServiceClient client,
GrpcModuleFactory moduleFactory, GrpcThreadFactory threadFactory,
GrpcValueFactory valueFactory,
GrpcFunctionFactory functionFactory,
GrpcSymbolFactory symbolFactory)
{
this.connection = connection;
this.grpcSbFrame = grpcSbFrame;
this.client = client;
this.moduleFactory = moduleFactory;
this.threadFactory = threadFactory;
this.valueFactory = valueFactory;
this.functionFactory = functionFactory;
this.symbolFactory = symbolFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <
GrpcConnection, RemoteFrameRpcService.RemoteFrameRpcServiceClient, GrpcSbFrame>
(connection, client, grpcSbFrame));
}