// Constructor that can be used by tests to pass in mock objects.
internal SbPlatformImpl(GrpcConnection connection, GrpcErrorFactory sbErrorFactory,
SbPlatformRpcService.SbPlatformRpcServiceClient client)
{
this.sbErrorFactory = sbErrorFactory;
this.client = client;
this.connection = connection;
}
internal SbProcessImpl(GrpcConnection connection, GrpcSbProcess grpcSbProcess,
GrpcThreadFactory threadFactory, GrpcTargetFactory targetFactory,
GrpcUnixSignalsFactory unixSignalsFactory,
GrpcErrorFactory errorFactory,
SbProcessRpcService.SbProcessRpcServiceClient client)
{
this.connection = connection;
this.grpcSbProcess = grpcSbProcess;
this.client = client;
this.threadFactory = threadFactory;
this.targetFactory = targetFactory;
this.unixSignalsFactory = unixSignalsFactory;
this.errorFactory = errorFactory;
}
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;
}
// <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 RemoteValueProxy(
GrpcConnection connection, RemoteValueRpcServiceClient client,
GrpcSbValue grpcSbValue, GrpcValueFactory valueFactory, GrpcErrorFactory errorFactory,
GrpcTypeFactory typeFactory, CachedValueFactory cachedValueFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbValue = grpcSbValue;
this.valueFactory = valueFactory;
this.errorFactory = errorFactory;
this.typeFactory = typeFactory;
this.cachedValueFactory = cachedValueFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, RemoteValueRpcServiceClient, GrpcSbValue>(
connection, client, grpcSbValue));
}