internal SbWatchpointImpl(
GrpcConnection connection, GrpcSbWatchpoint grpcSbWatchpoint) :
this(connection,
new SbWatchpointRpcService.SbWatchpointRpcServiceClient(connection.CallInvoker),
grpcSbWatchpoint)
{
}
public RemoteTargetProxy(GrpcConnection connection, GrpcSbTarget grpcSbTarget) : this(
connection, grpcSbTarget,
new RemoteTargetRpcService.RemoteTargetRpcServiceClient(connection.CallInvoker),
new GrpcBreakpointFactory(), new GrpcErrorFactory(), new GrpcProcessFactory(),
new GrpcModuleFactory(), new GrpcWatchpointFactory(), new GrpcAddressFactory())
{
}
internal RemoteFrameProxy(GrpcConnection connection, GrpcSbFrame grpcSbFrame)
: this(connection, grpcSbFrame,
new RemoteFrameRpcService.RemoteFrameRpcServiceClient(connection.CallInvoker),
new GrpcModuleFactory(), new GrpcThreadFactory(), new GrpcValueFactory(),
new GrpcFunctionFactory(), new GrpcSymbolFactory())
{
}
internal RemoteThreadProxy(GrpcConnection connection, GrpcSbThread grpcSbThead)
: this(connection, grpcSbThead,
new RemoteThreadRpcService.RemoteThreadRpcServiceClient(connection.CallInvoker),
new RemoteFrameProxyFactory(), new GrpcProcessFactory(),
new GrpcErrorFactory(), new GrpcModuleFactory())
{
}
// 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 RemoteValueProxy(GrpcConnection connection, GrpcSbValue grpcSbValue)
: this(connection,
new RemoteValueRpcServiceClient(connection.CallInvoker), grpcSbValue,
new GrpcValueFactory(), new GrpcErrorFactory(), new GrpcTypeFactory(),
new CachedValueFactory())
{
}
internal SbCommandReturnObjectImpl(GrpcConnection connection,
GrpcSbCommandReturnObject grpcSbReturnObject)
: this(connection,
new SbCommandReturnObjectRpcServiceClient(connection.CallInvoker),
grpcSbReturnObject,
new GrpcSbCommandReturnObjectFactory())
{
}
public virtual RemoteThread Create(GrpcConnection connection, GrpcSbThread grpcSbThread)
{
if (grpcSbThread == null || grpcSbThread.Id == 0)
{
return(null);
}
return(new RemoteThreadProxy(connection, grpcSbThread));
}
internal SbBreakpointLocationImpl(
GrpcConnection connection, GrpcSbBreakpointLocation grpcSbBreakpointLocation)
: this(connection,
new SbBreakpointLocationRpcService.SbBreakpointLocationRpcServiceClient(
connection.CallInvoker),
grpcSbBreakpointLocation, new GrpcBreakpointFactory(), new GrpcAddressFactory())
{
}
internal SbCommandInterpreterImpl(GrpcConnection connection,
GrpcSbCommandInterpreter grpcSbInterpreter)
: this(connection,
new SbCommandInterpreterRpcServiceClient(connection.CallInvoker),
grpcSbInterpreter, new GrpcSbCommandInterpreterFactory(),
new GrpcSbCommandReturnObjectFactory())
{
}
public virtual RemoteFrame Create(GrpcConnection connection, GrpcSbFrame grpcSbFrame)
{
if (grpcSbFrame == null)
{
return(null);
}
return(new RemoteFrameProxy(connection, grpcSbFrame));
}
internal SbProcessImpl(GrpcConnection connection, GrpcSbProcess grpcSbProcess)
: this(connection, grpcSbProcess,
new GrpcThreadFactory(),
new GrpcTargetFactory(),
new GrpcUnixSignalsFactory(), new GrpcErrorFactory(),
new SbProcessRpcService.SbProcessRpcServiceClient(connection.CallInvoker))
{
}
internal SbWatchpointImpl(
GrpcConnection connection, SbWatchpointRpcService.SbWatchpointRpcServiceClient client,
GrpcSbWatchpoint grpcSbWatchpoint)
{
this.connection = connection;
this.client = client;
this.grpcSbWatchpoint = grpcSbWatchpoint;
}
// Constructor that can be used by tests to pass in mock objects.
internal SbListenerImpl(
GrpcConnection connection,
SbListenerRpcService.SbListenerRpcServiceClient client,
GrpcEventFactory eventFactory)
{
this.connection = connection;
this.client = client;
this.eventFactory = eventFactory;
}
public virtual SbPlatform Create(string platformName, GrpcConnection grpcConnection)
{
var instance = new SbPlatformImpl(grpcConnection);
if (instance.Create(platformName))
{
return(instance);
}
return(null);
}
internal RemoteBreakpointProxy(
GrpcConnection connection, RemoteBreakpointRpcServiceClient client,
GrpcSbBreakpoint grpcSbBreakpoint,
GrpcBreakpointLocationFactory breakpointLocationFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbBreakpoint = grpcSbBreakpoint;
this.breakpointLocationFactory = breakpointLocationFactory;
}
public virtual SbListener Create(GrpcConnection connection, string name)
{
var instance = new SbListenerImpl(connection);
if (instance.Create(name))
{
return(instance);
}
return(null);
}
internal SbUnixSignalsImpl(GrpcConnection connection, GrpcSbUnixSignals grpcSbUnixSignals)
{
this.connection = connection;
client = new SbUnixSignalsRpcServiceClient(connection.CallInvoker);
this.grpcSbUnixSignals = grpcSbUnixSignals;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, SbUnixSignalsRpcServiceClient, GrpcSbUnixSignals>(
connection, client, grpcSbUnixSignals));
}
internal SbSectionImpl(
GrpcConnection connection, SbSectionRpcServiceClient client,
GrpcSbSection grpcSbSection)
{
this.connection = connection;
this.client = client;
this.grpcSbSection = grpcSbSection;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(Tuple.Create(connection, client, grpcSbSection));
}
// Constructor that can be used by tests to pass in mock objects.
internal SbDebuggerImpl(GrpcConnection connection, GrpcTargetFactory sbTargetFactory,
GrpcPlatformFactory sbPlatformFactory,
GrpcSbCommandInterpreterFactory sbCommandInterpreterFactory,
SbDebuggerRpcService.SbDebuggerRpcServiceClient client)
{
this.connection = connection;
this.sbTargetFactory = sbTargetFactory;
this.sbPlatformFactory = sbPlatformFactory;
this.sbCommandInterpreterFactory = sbCommandInterpreterFactory;
this.client = client;
}
internal SbBreakpointLocationImpl(
GrpcConnection connection,
SbBreakpointLocationRpcService.SbBreakpointLocationRpcServiceClient client,
GrpcSbBreakpointLocation grpcSbBreakpointLocation,
GrpcBreakpointFactory breakpointFactory, GrpcAddressFactory addressFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbBreakpointLocation = grpcSbBreakpointLocation;
this.breakpointFactory = breakpointFactory;
this.addressFactory = addressFactory;
}
internal SbTypeMemberImpl(
GrpcConnection connection, SbTypeMemberRpcServiceClient client,
GrpcSbTypeMember grpcSbTypeMember, GrpcTypeFactory typeFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbTypeMember = grpcSbTypeMember;
this.typeFactory = typeFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, SbTypeMemberRpcServiceClient, GrpcSbTypeMember>(
connection, client, grpcSbTypeMember));
}
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;
}
internal SbSymbolImpl(
GrpcConnection connection, SbSymbolRpcServiceClient client,
GrpcSbSymbol grpcSbSymbol, GrpcAddressFactory addressFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbSymbol = grpcSbSymbol;
this.addressFactory = addressFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, SbSymbolRpcServiceClient, GrpcSbSymbol>(
connection, client, grpcSbSymbol));
}
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 SbAddressImpl(
GrpcConnection connection, SbAddressRpcServiceClient client,
GrpcSbAddress grpcSbAddress,
GrpcFunctionFactory functionFactory,
GrpcSymbolFactory symbolFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbAddress = grpcSbAddress;
this.functionFactory = functionFactory;
this.symbolFactory = symbolFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, SbAddressRpcServiceClient, GrpcSbAddress>(
connection, client, grpcSbAddress));
}
// <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));
}
public virtual void Delete(GrpcConnection connection, GrpcSbFrame grpcSbFrame)
{
var client = new RemoteFrameRpcService.RemoteFrameRpcServiceClient(
connection.CallInvoker);
connection
.GetOrCreateBulkDeleter <GrpcSbFrame>()
.QueueForDeletion(grpcSbFrame, (List <GrpcSbFrame> frames) =>
{
var request = new BulkDeleteRequest();
request.Frames.AddRange(frames);
connection.InvokeRpc(() =>
{
client.BulkDelete(request);
});
});
}
internal SbCommandReturnObjectImpl(
GrpcConnection connection, SbCommandReturnObjectRpcServiceClient client,
GrpcSbCommandReturnObject grpcSbReturnObject,
GrpcSbCommandReturnObjectFactory returnObjectFactory)
{
this.connection = connection;
this.client = client;
this.grpcSbReturnObject = grpcSbReturnObject;
this.returnObjectFactory = returnObjectFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection,
SbCommandReturnObjectRpcServiceClient,
GrpcSbCommandReturnObject>(
connection, client, grpcSbReturnObject));
}
internal SbModuleImpl(GrpcConnection connection, GrpcSbModule grpcSbModule,
SbModuleRpcServiceClient client, GrpcAddressFactory addressFactory,
GrpcFileSpecFactory fileSpecFactory,
GrpcSectionFactory sectionFactory)
{
this.connection = connection;
this.grpcSbModule = grpcSbModule;
this.client = client;
this.addressFactory = addressFactory;
this.fileSpecFactory = fileSpecFactory;
this.sectionFactory = sectionFactory;
// Keep a handle to objects we need in the destructor.
gcHandle = GCHandle.Alloc(
new Tuple <GrpcConnection, SbModuleRpcServiceClient, GrpcSbModule>(
connection, client, grpcSbModule));
}
