// Function to complusively shut down the system with a given mode.
static void
QuitHard(hal::ShutdownMode aMode)
{
switch (aMode)
{
case hal::eHalShutdownMode_PowerOff:
PowerOff();
break;
case hal::eHalShutdownMode_Reboot:
Reboot();
break;
case hal::eHalShutdownMode_Restart:
// Don't let signal handlers affect forced shutdown.
kill(0, SIGKILL);
// If we can't SIGKILL our process group, something is badly
// wrong. Trying to deliver a catch-able signal to ourselves can
// invoke signal handlers and might cause problems. So try
// _exit() and hope we go away.
_exit(1);
break;
default:
MOZ_NOT_REACHED();
break;
}
MOZ_NOT_REACHED();
}
bool
SmsParent::RecvPSmsRequestConstructor(PSmsRequestParent* aActor,
const IPCSmsRequest& aRequest)
{
SmsRequestParent* actor = static_cast<SmsRequestParent*>(aActor);
switch (aRequest.type()) {
case IPCSmsRequest::TCreateMessageListRequest:
return actor->DoRequest(aRequest.get_CreateMessageListRequest());
case IPCSmsRequest::TSendMessageRequest:
return actor->DoRequest(aRequest.get_SendMessageRequest());
case IPCSmsRequest::TGetMessageRequest:
return actor->DoRequest(aRequest.get_GetMessageRequest());
case IPCSmsRequest::TDeleteMessageRequest:
return actor->DoRequest(aRequest.get_DeleteMessageRequest());
case IPCSmsRequest::TGetNextMessageInListRequest:
return actor->DoRequest(aRequest.get_GetNextMessageInListRequest());
case IPCSmsRequest::TMarkMessageReadRequest:
return actor->DoRequest(aRequest.get_MarkMessageReadRequest());
case IPCSmsRequest::TGetThreadListRequest:
return actor->DoRequest(aRequest.get_GetThreadListRequest());
default:
MOZ_NOT_REACHED("Unknown type!");
return false;
}
MOZ_NOT_REACHED("Should never get here!");
return false;
}
bool
BluetoothServiceChildProcess::CloseSocket(int aFd,
BluetoothReplyRunnable* aRunnable)
{
MOZ_NOT_REACHED("Implement me!");
return false;
}
/* static */ TemporaryRef<ImageClient>
ImageClient::CreateImageClient(LayersBackend aParentBackend,
CompositableType aCompositableHostType,
CompositableForwarder* aForwarder,
TextureFlags aFlags)
{
RefPtr<ImageClient> result = nullptr;
switch (aCompositableHostType) {
case BUFFER_IMAGE_SINGLE:
if (aParentBackend == LAYERS_OPENGL) {
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_SINGLE);
}
break;
case BUFFER_IMAGE_BUFFERED:
if (aParentBackend == LAYERS_OPENGL) {
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_BUFFERED);
}
break;
case BUFFER_BRIDGE:
if (aParentBackend == LAYERS_OPENGL) {
result = new ImageClientBridge(aForwarder, aFlags);
}
break;
case BUFFER_UNKNOWN:
result = nullptr;
break;
default:
MOZ_NOT_REACHED("unhandled program type");
}
NS_ASSERTION(result, "Failed to create ImageClient");
return result.forget();
}
bool
nsJARProtocolHandler::RemoteOpenFileInProgress(
nsIHashable *aRemoteFile,
nsIRemoteOpenFileListener *aListener)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aRemoteFile);
MOZ_ASSERT(aListener);
if (IsMainProcess()) {
MOZ_NOT_REACHED("Shouldn't be called in the main process!");
return false;
}
RemoteFileListenerArray *listeners;
if (mRemoteFileListeners.Get(aRemoteFile, &listeners)) {
listeners->AppendElement(aListener);
return true;
}
// We deliberately don't put the listener in the new array since the first
// load is handled differently.
mRemoteFileListeners.Put(aRemoteFile, new RemoteFileListenerArray());
return false;
}
void
ReadBuffer::Attach(SharedSurface_GL* surf)
{
MOZ_ASSERT(surf && mSurf);
MOZ_ASSERT(surf->AttachType() == mSurf->AttachType());
MOZ_ASSERT(surf->Size() == mSurf->Size());
// Nothing else is needed for AttachType Screen.
if (surf->AttachType() != AttachmentType::Screen) {
GLuint colorTex = 0;
GLuint colorRB = 0;
switch (surf->AttachType()) {
case AttachmentType::GLTexture:
colorTex = surf->Texture();
break;
case AttachmentType::GLRenderbuffer:
colorRB = surf->Renderbuffer();
break;
default:
MOZ_NOT_REACHED("Unknown attachment type?");
return;
}
mGL->AttachBuffersToFB(colorTex, colorRB, 0, 0, mFB);
MOZ_ASSERT(mGL->IsFramebufferComplete(mFB));
}
mSurf = surf;
}
/* static */ TemporaryRef<TextureHost>
TextureHost::CreateTextureHost(SurfaceDescriptorType aDescriptorType,
uint32_t aTextureHostFlags,
uint32_t aTextureFlags)
{
switch (Compositor::GetBackend()) {
case LAYERS_OPENGL:
return CreateTextureHostOGL(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
case LAYERS_D3D9:
return CreateTextureHostD3D9(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
#ifdef XP_WIN
case LAYERS_D3D11:
return CreateTextureHostD3D11(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
#endif
case LAYERS_BASIC:
return CreateBasicTextureHost(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
default:
MOZ_NOT_REACHED("Couldn't create texture host");
return nullptr;
}
}
void
nsJARProtocolHandler::RemoteOpenFileComplete(nsIHashable *aRemoteFile,
nsresult aStatus)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aRemoteFile);
if (IsMainProcess()) {
MOZ_NOT_REACHED("Shouldn't be called in the main process!");
return;
}
RemoteFileListenerArray *tempListeners;
if (!mRemoteFileListeners.Get(aRemoteFile, &tempListeners)) {
return;
}
// Save the listeners in a stack array. The call to Remove() below will
// delete the tempListeners array.
RemoteFileListenerArray listeners;
tempListeners->SwapElements(listeners);
mRemoteFileListeners.Remove(aRemoteFile);
// Technically we must fail OnRemoteFileComplete() since OpenNSPRFileDesc()
// won't succeed here. We've trained nsJARChannel to recognize
// NS_ERROR_ALREADY_OPENED in this case as "proceed to JAR cache hit."
nsresult status = NS_SUCCEEDED(aStatus) ? NS_ERROR_ALREADY_OPENED : aStatus;
uint32_t count = listeners.Length();
for (uint32_t index = 0; index < count; index++) {
listeners[index]->OnRemoteFileOpenComplete(status);
}
}
bool
TCPSocketParent::RecvData(const SendableData& aData)
{
NS_ENSURE_TRUE(mIntermediary, true);
nsresult rv;
switch (aData.type()) {
case SendableData::TArrayOfuint8_t: {
AutoSafeJSContext cx;
JS::Rooted<JS::Value> val(cx);
JS::Rooted<JSObject*> obj(cx, mIntermediaryObj);
IPC::DeserializeArrayBuffer(obj, aData.get_ArrayOfuint8_t(), &val);
rv = mIntermediary->SendArrayBuffer(val);
NS_ENSURE_SUCCESS(rv, true);
break;
}
case SendableData::TnsString:
rv = mIntermediary->SendString(aData.get_nsString());
NS_ENSURE_SUCCESS(rv, true);
break;
default:
MOZ_NOT_REACHED("unexpected SendableData type");
return false;
}
return true;
}
/* static */ TemporaryRef<CompositableHost>
CompositableHost::Create(CompositableType aType, Compositor* aCompositor)
{
RefPtr<CompositableHost> result;
switch (aType) {
case BUFFER_IMAGE_BUFFERED:
result = new ImageHostBuffered(aCompositor, aType);
return result;
case BUFFER_IMAGE_SINGLE:
result = new ImageHostSingle(aCompositor, aType);
return result;
case BUFFER_TILED:
result = new TiledContentHost(aCompositor);
return result;
case BUFFER_CONTENT:
result = new ContentHostSingleBuffered(aCompositor);
return result;
case BUFFER_CONTENT_DIRECT:
result = new ContentHostDoubleBuffered(aCompositor);
return result;
default:
MOZ_NOT_REACHED("Unknown CompositableType");
return nullptr;
}
}
gfxMatrix
ComputeTransformForRotation(const nsIntRect& aBounds,
ScreenRotation aRotation)
{
gfxMatrix transform;
switch (aRotation) {
case ROTATION_0:
break;
case ROTATION_90:
transform.Translate(gfxPoint(aBounds.width, 0));
transform.Rotate(M_PI / 2);
break;
case ROTATION_180:
transform.Translate(gfxPoint(aBounds.width, aBounds.height));
transform.Rotate(M_PI);
break;
case ROTATION_270:
transform.Translate(gfxPoint(0, aBounds.height));
transform.Rotate(M_PI * 3 / 2);
break;
default:
MOZ_NOT_REACHED("Unknown rotation");
break;
}
return transform;
}
/* static */ TemporaryRef<CompositableHost>
CompositableHost::Create(const TextureInfo& aTextureInfo)
{
RefPtr<CompositableHost> result;
switch (aTextureInfo.mCompositableType) {
case BUFFER_IMAGE_BUFFERED:
result = new ImageHostBuffered(aTextureInfo);
return result;
case BUFFER_IMAGE_SINGLE:
result = new ImageHostSingle(aTextureInfo);
return result;
case BUFFER_TILED:
result = new TiledContentHost(aTextureInfo);
return result;
case BUFFER_CONTENT:
result = new ContentHostSingleBuffered(aTextureInfo);
return result;
case BUFFER_CONTENT_DIRECT:
result = new ContentHostDoubleBuffered(aTextureInfo);
return result;
case BUFFER_CONTENT_INC:
result = new ContentHostIncremental(aTextureInfo);
return result;
default:
MOZ_NOT_REACHED("Unknown CompositableType");
return nullptr;
}
}
nsresult
BluetoothServiceChildProcess::GetDevicePropertiesInternal(
const BluetoothSignal& aSignal)
{
MOZ_NOT_REACHED("Should never be called from child");
return NS_ERROR_NOT_IMPLEMENTED;
}
bool
TCPSocketParent::RecvData(const SendableData& aData)
{
NS_ENSURE_TRUE(mIntermediary, true);
nsresult rv;
switch (aData.type()) {
case SendableData::TArrayOfuint8_t: {
jsval val;
IPC::DeserializeUint8Array(mIntermediaryObj, aData.get_ArrayOfuint8_t(), &val);
rv = mIntermediary->SendArrayBuffer(val);
NS_ENSURE_SUCCESS(rv, true);
break;
}
case SendableData::TnsString:
rv = mIntermediary->SendString(aData.get_nsString());
NS_ENSURE_SUCCESS(rv, true);
break;
default:
MOZ_NOT_REACHED();
return false;
}
return true;
}
bool
BluetoothServiceChildProcess::UpdateSdpRecords(const nsAString& aDeviceAddress,
BluetoothProfileManagerBase* aManager)
{
MOZ_NOT_REACHED("This should never be called!");
return false;
}
JSBool
JSHistogram_Snapshot(JSContext *cx, unsigned argc, jsval *vp)
{
JSObject *obj = JS_THIS_OBJECT(cx, vp);
if (!obj) {
return JS_FALSE;
}
Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
JSObject *snapshot = JS_NewObject(cx, nullptr, nullptr, nullptr);
if (!snapshot)
return JS_FALSE;
JS::AutoObjectRooter sroot(cx, snapshot);
switch (ReflectHistogramSnapshot(cx, snapshot, h)) {
case REFLECT_FAILURE:
return JS_FALSE;
case REFLECT_CORRUPT:
JS_ReportError(cx, "Histogram is corrupt");
return JS_FALSE;
case REFLECT_OK:
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(snapshot));
return JS_TRUE;
default:
MOZ_NOT_REACHED("unhandled reflection status");
return JS_FALSE;
}
}
bool
SmsRequestParent::DoRequest(const SendMessageRequest& aRequest)
{
switch(aRequest.type()) {
case SendMessageRequest::TSendSmsMessageRequest: {
nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
NS_ENSURE_TRUE(smsService, true);
const SendSmsMessageRequest &data = aRequest.get_SendSmsMessageRequest();
smsService->Send(data.number(), data.message(), this);
}
break;
case SendMessageRequest::TSendMmsMessageRequest: {
nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
NS_ENSURE_TRUE(mmsService, true);
JS::Value params;
JSContext* cx = nsContentUtils::GetSafeJSContext();
if (!GetParamsFromSendMmsMessageRequest(
cx,
aRequest.get_SendMmsMessageRequest(),
¶ms)) {
NS_WARNING("SmsRequestParent: Fail to build MMS params.");
return true;
}
mmsService->Send(params, this);
}
break;
default:
MOZ_NOT_REACHED("Unknown type of SendMessageRequest!");
return false;
}
return true;
}
nsresult
BluetoothServiceChildProcess::GetServiceChannel(const nsAString& aDeviceAddress,
const nsAString& aServiceUuid,
BluetoothProfileManagerBase* aManager)
{
MOZ_NOT_REACHED("This should never be called!");
return NS_ERROR_FAILURE;
}
void
SerializeInputStream(nsIInputStream* aInputStream,
InputStreamParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aInputStream);
nsCOMPtr<nsIIPCSerializableInputStream> serializable =
do_QueryInterface(aInputStream);
if (!serializable) {
MOZ_NOT_REACHED("Input stream is not serializable!");
}
serializable->Serialize(aParams);
if (aParams.type() == InputStreamParams::T__None) {
MOZ_NOT_REACHED("Serialize failed!");
}
}
nsresult
BluetoothServiceChildProcess::GetScoSocket(
const nsAString& aObjectPath,
bool aAuth,
bool aEncrypt,
mozilla::ipc::UnixSocketConsumer* aConsumer)
{
MOZ_NOT_REACHED("This should never be called!");
return NS_ERROR_FAILURE;
}
nsresult
BluetoothServiceChildProcess::ListenSocketViaService(
int aChannel,
BluetoothSocketType aType,
bool aAuth,
bool aEncrypt,
mozilla::ipc::UnixSocketConsumer* aConsumer)
{
MOZ_NOT_REACHED("This should never be called!");
return NS_ERROR_FAILURE;
}
nsresult
BluetoothServiceChildProcess::GetSocketViaService(
const nsAString& aObjectPath,
const nsAString& aService,
int aType,
bool aAuth,
bool aEncrypt,
BluetoothReplyRunnable* aRunnable)
{
MOZ_NOT_REACHED("Implement me!");
return NS_ERROR_NOT_IMPLEMENTED;
}
void
MappableSeekableZStream::munmap(void *addr, size_t length)
{
std::vector<LazyMap>::iterator it;
for (it = lazyMaps.begin(); it < lazyMaps.end(); ++it)
if ((it->addr = addr) && (it->length == length)) {
lazyMaps.erase(it);
::munmap(addr, length);
return;
}
MOZ_NOT_REACHED("munmap called with unknown mapping");
}
nsresult
BluetoothServiceChildProcess::GetSocketViaService(
const nsAString& aObjectPath,
const nsAString& aService,
BluetoothSocketType aType,
bool aAuth,
bool aEncrypt,
mozilla::ipc::UnixSocketConsumer* aConsumer,
BluetoothReplyRunnable* aRunnable)
{
MOZ_NOT_REACHED("This should never be called!");
return NS_ERROR_FAILURE;
}
ReadBuffer*
ReadBuffer::Create(GLContext* gl,
const SurfaceCaps& caps,
const GLFormats& formats,
SharedSurface_GL* surf)
{
MOZ_ASSERT(surf);
if (surf->AttachType() == AttachmentType::Screen) {
// Don't need anything. Our read buffer will be the 'screen'.
return new ReadBuffer(gl,
0, 0, 0,
surf);
}
GLuint depthRB = 0;
GLuint stencilRB = 0;
GLuint* pDepthRB = caps.depth ? &depthRB : nullptr;
GLuint* pStencilRB = caps.stencil ? &stencilRB : nullptr;
gl->CreateRenderbuffersForOffscreen(formats, surf->Size(), caps.antialias,
nullptr, pDepthRB, pStencilRB);
GLuint colorTex = 0;
GLuint colorRB = 0;
switch (surf->AttachType()) {
case AttachmentType::GLTexture:
colorTex = surf->Texture();
break;
case AttachmentType::GLRenderbuffer:
colorRB = surf->Renderbuffer();
break;
default:
MOZ_NOT_REACHED("Unknown attachment type?");
return nullptr;
}
MOZ_ASSERT(colorTex || colorRB);
GLuint fb = 0;
gl->fGenFramebuffers(1, &fb);
gl->AttachBuffersToFB(colorTex, colorRB, depthRB, stencilRB, fb);
MOZ_ASSERT(gl->IsFramebufferComplete(fb));
return new ReadBuffer(gl,
fb, depthRB, stencilRB,
surf);
}
SurfaceStream*
SurfaceStream::CreateForType(SurfaceStreamType type, SurfaceStream* prevStream)
{
switch (type) {
case SurfaceStreamType::SingleBuffer:
return new SurfaceStream_SingleBuffer(prevStream);
case SurfaceStreamType::TripleBuffer_Copy:
return new SurfaceStream_TripleBuffer_Copy(prevStream);
case SurfaceStreamType::TripleBuffer:
return new SurfaceStream_TripleBuffer(prevStream);
default:
MOZ_NOT_REACHED("Invalid Type.");
return nullptr;
}
}
static android::PixelFormat
PixelFormatForImageFormat(gfxASurface::gfxImageFormat aFormat)
{
switch (aFormat) {
case gfxASurface::ImageFormatARGB32:
return android::PIXEL_FORMAT_RGBA_8888;
case gfxASurface::ImageFormatRGB24:
return android::PIXEL_FORMAT_RGBX_8888;
case gfxASurface::ImageFormatRGB16_565:
return android::PIXEL_FORMAT_RGB_565;
case gfxASurface::ImageFormatA8:
return android::PIXEL_FORMAT_A_8;
default:
MOZ_NOT_REACHED("Unknown gralloc pixel format");
}
return gfxASurface::ImageFormatARGB32;
}
bool
SmsParent::RecvPMobileMessageCursorConstructor(PMobileMessageCursorParent* aActor,
const IPCMobileMessageCursor& aRequest)
{
MobileMessageCursorParent* actor =
static_cast<MobileMessageCursorParent*>(aActor);
switch (aRequest.type()) {
case IPCMobileMessageCursor::TCreateMessageCursorRequest:
return actor->DoRequest(aRequest.get_CreateMessageCursorRequest());
case IPCMobileMessageCursor::TCreateThreadCursorRequest:
return actor->DoRequest(aRequest.get_CreateThreadCursorRequest());
default:
MOZ_NOT_REACHED("Unknown type!");
break;
}
return false;
}
JSContext*
DOMBindingBase::GetJSContextFromContextStack() const
{
AssertIsOnMainThread();
MOZ_ASSERT(!mJSContext);
if (!mContextStack) {
mContextStack = nsContentUtils::ThreadJSContextStack();
MOZ_ASSERT(mContextStack);
}
JSContext* cx;
if (NS_FAILED(mContextStack->Peek(&cx))) {
MOZ_NOT_REACHED("This should never fail!");
}
MOZ_ASSERT(cx);
return cx;
}
NS_IMETHODIMP
TextComposition::CompositionEventDispatcher::Run()
{
if (!mPresContext->GetPresShell() ||
mPresContext->GetPresShell()->IsDestroying()) {
return NS_OK; // cannot dispatch any events anymore
}
nsEventStatus status = nsEventStatus_eIgnore;
switch (mEventMessage) {
case NS_COMPOSITION_START: {
nsCompositionEvent compStart(true, NS_COMPOSITION_START, mWidget);
nsQueryContentEvent selectedText(true, NS_QUERY_SELECTED_TEXT, mWidget);
nsContentEventHandler handler(mPresContext);
handler.OnQuerySelectedText(&selectedText);
NS_ASSERTION(selectedText.mSucceeded, "Failed to get selected text");
compStart.data = selectedText.mReply.mString;
nsIMEStateManager::DispatchCompositionEvent(mEventTarget, mPresContext,
&compStart, &status, nullptr);
break;
}
case NS_COMPOSITION_UPDATE:
case NS_COMPOSITION_END: {
nsCompositionEvent compEvent(true, mEventMessage, mWidget);
compEvent.data = mData;
nsIMEStateManager::DispatchCompositionEvent(mEventTarget, mPresContext,
&compEvent, &status, nullptr);
break;
}
case NS_TEXT_TEXT: {
nsTextEvent textEvent(true, NS_TEXT_TEXT, mWidget);
textEvent.theText = mData;
nsIMEStateManager::DispatchCompositionEvent(mEventTarget, mPresContext,
&textEvent, &status, nullptr);
break;
}
default:
MOZ_NOT_REACHED("Unsupported event");
break;
}
return NS_OK;
}
