nsresult SystemWorkerManager::InitNetd(JSContext *cx) { nsCOMPtr<nsIWorkerHolder> worker = do_GetService(kNetworkManagerCID); NS_ENSURE_TRUE(worker, NS_ERROR_FAILURE); jsval workerval; nsresult rv = worker->GetWorker(&workerval); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(!JSVAL_IS_PRIMITIVE(workerval), NS_ERROR_UNEXPECTED); JSAutoRequest ar(cx); JSAutoCompartment ac(cx, JSVAL_TO_OBJECT(workerval)); WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(cx, workerval); if (!wctd) { NS_WARNING("Failed to GetWorkerCrossThreadDispatcher"); return NS_ERROR_FAILURE; } nsRefPtr<ConnectWorkerToNetd> connection = new ConnectWorkerToNetd(); if (!wctd->PostTask(connection)) { NS_WARNING("Failed to connect worker to netd"); return NS_ERROR_UNEXPECTED; } // Now that we're set up, connect ourselves to the Netd process. mozilla::RefPtr<NetdReceiver> receiver = new NetdReceiver(wctd); StartNetd(receiver); mNetdWorker = worker; return NS_OK; }
nsresult RadioManager::Init() { NS_ASSERTION(NS_IsMainThread(), "We can only initialize on the main thread"); nsCOMPtr<nsIObserverService> obs = do_GetService(NS_OBSERVERSERVICE_CONTRACTID); if (!obs) { NS_WARNING("Failed to get observer service!"); return NS_ERROR_FAILURE; } nsresult rv = obs->AddObserver(this, PROFILE_BEFORE_CHANGE_TOPIC, false); NS_ENSURE_SUCCESS(rv, rv); // The telephony worker component is a hack that gives us a global object for // our own functions and makes creating the worker possible. nsCOMPtr<nsIRadioWorker> worker(do_CreateInstance(kTelephonyWorkerCID)); NS_ENSURE_TRUE(worker, NS_ERROR_FAILURE); jsval workerval; rv = worker->GetWorker(&workerval); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(!JSVAL_IS_PRIMITIVE(workerval), "bad worker value"); JSContext *cx; rv = nsContentUtils::ThreadJSContextStack()->GetSafeJSContext(&cx); NS_ENSURE_SUCCESS(rv, rv); nsCxPusher pusher; if (!cx || !pusher.Push(cx, false)) { return NS_ERROR_FAILURE; } JSObject *workerobj = JSVAL_TO_OBJECT(workerval); JSAutoRequest ar(cx); JSAutoEnterCompartment ac; if (!ac.enter(cx, workerobj)) { return NS_ERROR_OUT_OF_MEMORY; } WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(cx, workerval); if (!wctd) { return NS_ERROR_FAILURE; } nsRefPtr<ConnectWorkerToRIL> connection = new ConnectWorkerToRIL(); if (!wctd->PostTask(connection)) { return NS_ERROR_UNEXPECTED; } // Now that we're set up, connect ourselves to the RIL thread. mozilla::RefPtr<RILReceiver> receiver = new RILReceiver(wctd); StartRil(receiver); mTelephone = do_QueryInterface(worker); NS_ENSURE_TRUE(mTelephone, NS_ERROR_FAILURE); return NS_OK; }
nsresult SystemWorkerManager::RegisterRilWorker(unsigned int aClientId, const JS::Value& aWorker, JSContext *aCx) { NS_ENSURE_TRUE(!JSVAL_IS_PRIMITIVE(aWorker), NS_ERROR_UNEXPECTED); mRilConsumers.EnsureLengthAtLeast(aClientId + 1); if (mRilConsumers[aClientId]) { NS_WARNING("RilConsumer already registered"); return NS_ERROR_FAILURE; } JSAutoRequest ar(aCx); JSAutoCompartment ac(aCx, JSVAL_TO_OBJECT(aWorker)); WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(aCx, aWorker); if (!wctd) { NS_WARNING("Failed to GetWorkerCrossThreadDispatcher for ril"); return NS_ERROR_FAILURE; } nsRefPtr<ConnectWorkerToRIL> connection = new ConnectWorkerToRIL(aClientId); if (!wctd->PostTask(connection)) { NS_WARNING("Failed to connect worker to ril"); return NS_ERROR_UNEXPECTED; } // Now that we're set up, connect ourselves to the RIL thread. mRilConsumers[aClientId] = new RilConsumer(aClientId, wctd); return NS_OK; }
nsresult SystemWorkerManager::RegisterRilWorker(const JS::Value& aWorker, JSContext *aCx) { NS_ENSURE_TRUE(!JSVAL_IS_PRIMITIVE(aWorker), NS_ERROR_UNEXPECTED); JSAutoRequest ar(aCx); JSAutoCompartment ac(aCx, JSVAL_TO_OBJECT(aWorker)); WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(aCx, aWorker); if (!wctd) { return NS_ERROR_FAILURE; } nsRefPtr<ConnectWorkerToRIL> connection = new ConnectWorkerToRIL(); if (!wctd->PostTask(connection)) { return NS_ERROR_UNEXPECTED; } // Now that we're set up, connect ourselves to the RIL thread. mozilla::RefPtr<RILReceiver> receiver = new RILReceiver(wctd); StartRil(receiver); return NS_OK; }
nsresult SystemWorkerManager::InitRIL(JSContext *cx) { // We're keeping as much of this implementation as possible in JS, so the real // worker lives in RadioInterfaceLayer.js. All we do here is hold it alive and // hook it up to the RIL thread. nsCOMPtr<nsIRadioInterfaceLayer> ril = do_CreateInstance("@mozilla.org/ril;1"); NS_ENSURE_TRUE(ril, NS_ERROR_FAILURE); nsCOMPtr<nsIWorkerHolder> worker = do_QueryInterface(ril); if (worker) { jsval workerval; nsresult rv = worker->GetWorker(&workerval); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(!JSVAL_IS_PRIMITIVE(workerval), NS_ERROR_UNEXPECTED); JSAutoRequest ar(cx); JSAutoCompartment ac(cx, JSVAL_TO_OBJECT(workerval)); WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(cx, workerval); if (!wctd) { return NS_ERROR_FAILURE; } nsRefPtr<ConnectWorkerToRIL> connection = new ConnectWorkerToRIL(); if (!wctd->PostTask(connection)) { return NS_ERROR_UNEXPECTED; } // Now that we're set up, connect ourselves to the RIL thread. mozilla::RefPtr<RILReceiver> receiver = new RILReceiver(wctd); StartRil(receiver); } mRIL = ril; return NS_OK; }