Add m-esr52 at 52.6.0

1 files changed, 458 insertions, 0 deletions

diff --git a/ipc/ril/Ril.cpp b/ipc/ril/Ril.cpp
new file mode 100644
index 000000000..90fb12052
--- /dev/null
+++ b/ipc/ril/Ril.cpp
@@ -0,0 +1,458 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ipc/Ril.h"
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include "jsfriendapi.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/workers/Workers.h"
+#include "mozilla/ipc/RilSocket.h"
+#include "mozilla/ipc/RilSocketConsumer.h"
+#include "nsThreadUtils.h" // For NS_IsMainThread.
+#include "RilConnector.h"
+
+#ifdef CHROMIUM_LOG
+#undef CHROMIUM_LOG
+#endif
+
+#if defined(MOZ_WIDGET_GONK)
+#include <android/log.h>
+#define CHROMIUM_LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gonk", args)
+#else
+#define CHROMIUM_LOG(args...)  printf(args);
+#endif
+
+namespace mozilla {
+namespace ipc {
+
+USING_WORKERS_NAMESPACE;
+using namespace JS;
+
+class RilConsumer;
+
+static const char RIL_SOCKET_NAME[] = "/dev/socket/rilproxy";
+
+static nsTArray<UniquePtr<RilConsumer>> sRilConsumers;
+
+//
+// RilConsumer
+//
+
+class RilConsumer final : public RilSocketConsumer
+{
+public:
+  RilConsumer();
+
+  nsresult ConnectWorkerToRIL(JSContext* aCx);
+
+  nsresult Register(unsigned long aClientId,
+                    WorkerCrossThreadDispatcher* aDispatcher);
+  void Unregister();
+
+  // Methods for |RilSocketConsumer|
+  //
+
+  void ReceiveSocketData(JSContext* aCx,
+                         int aIndex,
+                         UniquePtr<UnixSocketBuffer>& aBuffer) override;
+  void OnConnectSuccess(int aIndex) override;
+  void OnConnectError(int aIndex) override;
+  void OnDisconnect(int aIndex) override;
+
+protected:
+  static bool PostRILMessage(JSContext* aCx, unsigned aArgc, Value* aVp);
+
+  nsresult Send(JSContext* aCx, const CallArgs& aArgs);
+  nsresult Receive(JSContext* aCx,
+                   uint32_t aClientId,
+                   const UnixSocketBuffer* aBuffer);
+  void Close();
+
+private:
+  RefPtr<RilSocket> mSocket;
+  nsCString mAddress;
+  bool mShutdown;
+};
+
+RilConsumer::RilConsumer()
+  : mShutdown(false)
+{ }
+
+nsresult
+RilConsumer::ConnectWorkerToRIL(JSContext* aCx)
+{
+  // Set up the postRILMessage on the function for worker -> RIL thread
+  // communication.
+  Rooted<JSObject*> workerGlobal(aCx, CurrentGlobalOrNull(aCx));
+
+  // Check whether |postRILMessage| has been defined.  No one but this class
+  // should ever define |postRILMessage| in a RIL worker.
+  Rooted<Value> val(aCx);
+  if (!JS_GetProperty(aCx, workerGlobal, "postRILMessage", &val)) {
+    // Just returning failure here will cause the exception on the JSContext to
+    // be reported as needed.
+    return NS_ERROR_FAILURE;
+  }
+
+  // Make sure that |postRILMessage| is a function.
+  if (JSTYPE_FUNCTION == JS_TypeOfValue(aCx, val)) {
+    return NS_OK;
+  }
+
+  JSFunction* postRILMessage = JS_DefineFunction(aCx, workerGlobal,
+                                                 "postRILMessage",
+                                                 PostRILMessage, 2, 0);
+  if (NS_WARN_IF(!postRILMessage)) {
+    // Just returning failure here will cause the exception on the JSContext to
+    // be reported as needed.
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+nsresult
+RilConsumer::Register(unsigned long aClientId,
+                      WorkerCrossThreadDispatcher* aDispatcher)
+{
+  // Only append client id after RIL_SOCKET_NAME when it's not connected to
+  // the first(0) rilproxy for compatibility.
+  if (!aClientId) {
+    mAddress = RIL_SOCKET_NAME;
+  } else {
+    struct sockaddr_un addr_un;
+    snprintf(addr_un.sun_path, sizeof addr_un.sun_path, "%s%lu",
+             RIL_SOCKET_NAME, aClientId);
+    mAddress = addr_un.sun_path;
+  }
+
+  mSocket = new RilSocket(aDispatcher, this, aClientId);
+
+  nsresult rv = mSocket->Connect(new RilConnector(mAddress, aClientId));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+void
+RilConsumer::Unregister()
+{
+  mShutdown = true;
+  Close();
+}
+
+bool
+RilConsumer::PostRILMessage(JSContext* aCx, unsigned aArgc, Value* aVp)
+{
+  CallArgs args = CallArgsFromVp(aArgc, aVp);
+
+  if (args.length() != 2) {
+    JS_ReportErrorASCII(aCx, "Expecting two arguments with the RIL message");
+    return false;
+  }
+
+  int clientId = args[0].toInt32();
+
+  if ((ssize_t)sRilConsumers.Length() <= clientId || !sRilConsumers[clientId]) {
+    // Probably shutting down.
+    return true;
+  }
+
+  nsresult rv = sRilConsumers[clientId]->Send(aCx, args);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  return true;
+}
+
+nsresult
+RilConsumer::Send(JSContext* aCx, const CallArgs& aArgs)
+{
+  if (NS_WARN_IF(!mSocket) ||
+      NS_WARN_IF(mSocket->GetConnectionStatus() == SOCKET_DISCONNECTED)) {
+    // Probably shutting down.
+    return NS_OK;
+  }
+
+  UniquePtr<UnixSocketRawData> raw;
+
+  Value v = aArgs[1];
+
+  if (v.isString()) {
+    JSAutoByteString abs;
+    Rooted<JSString*> str(aCx, v.toString());
+    if (!abs.encodeUtf8(aCx, str)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    raw = MakeUnique<UnixSocketRawData>(abs.ptr(), abs.length());
+  } else if (!v.isPrimitive()) {
+    JSObject* obj = v.toObjectOrNull();
+    if (!JS_IsTypedArrayObject(obj)) {
+      JS_ReportErrorASCII(aCx, "Object passed in wasn't a typed array");
+      return NS_ERROR_FAILURE;
+    }
+
+    uint32_t type = JS_GetArrayBufferViewType(obj);
+    if (type != js::Scalar::Int8 &&
+        type != js::Scalar::Uint8 &&
+        type != js::Scalar::Uint8Clamped) {
+      JS_ReportErrorASCII(aCx, "Typed array data is not octets");
+      return NS_ERROR_FAILURE;
+    }
+
+    size_t size = JS_GetTypedArrayByteLength(obj);
+    bool isShared;
+    void* data;
+    {
+      AutoCheckCannotGC nogc;
+      data = JS_GetArrayBufferViewData(obj, &isShared, nogc);
+    }
+    if (isShared) {
+      JS_ReportErrorASCII(
+        aCx, "Incorrect argument.  Shared memory not supported");
+      return NS_ERROR_FAILURE;
+    }
+    raw = MakeUnique<UnixSocketRawData>(data, size);
+  } else {
+    JS_ReportErrorASCII(
+      aCx, "Incorrect argument. Expecting a string or a typed array");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!raw) {
+    JS_ReportErrorASCII(aCx, "Unable to post to RIL");
+    return NS_ERROR_FAILURE;
+  }
+
+  mSocket->SendSocketData(raw.release());
+
+  return NS_OK;
+}
+
+nsresult
+RilConsumer::Receive(JSContext* aCx,
+                     uint32_t aClientId,
+                     const UnixSocketBuffer* aBuffer)
+{
+  MOZ_ASSERT(aBuffer);
+
+  Rooted<JSObject*> obj(aCx, CurrentGlobalOrNull(aCx));
+
+  Rooted<JSObject*> array(aCx, JS_NewUint8Array(aCx, aBuffer->GetSize()));
+  if (NS_WARN_IF(!array)) {
+    // Just suppress the exception, since our callers don't have a way to
+    // indicate they failed.
+    JS_ClearPendingException(aCx);
+    return NS_ERROR_FAILURE;
+  }
+  {
+    AutoCheckCannotGC nogc;
+    bool isShared;
+    memcpy(JS_GetArrayBufferViewData(array, &isShared, nogc),
+           aBuffer->GetData(), aBuffer->GetSize());
+    MOZ_ASSERT(!isShared);      // Array was constructed above.
+  }
+
+  AutoValueArray<2> args(aCx);
+  args[0].setNumber(aClientId);
+  args[1].setObject(*array);
+
+  Rooted<Value> rval(aCx);
+  JS_CallFunctionName(aCx, obj, "onRILMessage", args, &rval);
+  // Just suppress the exception, since our callers don't have a way to
+  // indicate they failed.
+  JS_ClearPendingException(aCx);
+
+  return NS_OK;
+}
+
+void
+RilConsumer::Close()
+{
+  if (mSocket) {
+    mSocket->Close();
+    mSocket = nullptr;
+  }
+}
+
+// |RilSocketConnector|
+
+void
+RilConsumer::ReceiveSocketData(JSContext* aCx,
+                               int aIndex,
+                               UniquePtr<UnixSocketBuffer>& aBuffer)
+{
+  Receive(aCx, (uint32_t)aIndex, aBuffer.get());
+}
+
+void
+RilConsumer::OnConnectSuccess(int aIndex)
+{
+  // Nothing to do here.
+  CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+}
+
+void
+RilConsumer::OnConnectError(int aIndex)
+{
+  CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+  Close();
+}
+
+void
+RilConsumer::OnDisconnect(int aIndex)
+{
+  CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+  if (mShutdown) {
+    return;
+  }
+  mSocket->Connect(new RilConnector(mAddress, aIndex),
+                   mSocket->GetSuggestedConnectDelayMs());
+}
+
+//
+// RilWorker
+//
+
+nsTArray<UniquePtr<RilWorker>> RilWorker::sRilWorkers;
+
+nsresult
+RilWorker::Register(unsigned int aClientId,
+                    WorkerCrossThreadDispatcher* aDispatcher)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  sRilWorkers.EnsureLengthAtLeast(aClientId + 1);
+
+  if (sRilWorkers[aClientId]) {
+    NS_WARNING("RilWorkers already registered");
+    return NS_ERROR_FAILURE;
+  }
+
+  // Now that we're set up, connect ourselves to the RIL thread.
+  sRilWorkers[aClientId] = MakeUnique<RilWorker>(aDispatcher);
+
+  nsresult rv = sRilWorkers[aClientId]->RegisterConsumer(aClientId);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+void
+RilWorker::Shutdown()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  for (size_t i = 0; i < sRilWorkers.Length(); ++i) {
+    if (!sRilWorkers[i]) {
+      continue;
+    }
+    sRilWorkers[i]->UnregisterConsumer(i);
+    sRilWorkers[i] = nullptr;
+  }
+}
+
+RilWorker::RilWorker(WorkerCrossThreadDispatcher* aDispatcher)
+  : mDispatcher(aDispatcher)
+{
+  MOZ_ASSERT(mDispatcher);
+}
+
+class RilWorker::RegisterConsumerTask : public WorkerTask
+{
+public:
+  RegisterConsumerTask(unsigned int aClientId,
+                       WorkerCrossThreadDispatcher* aDispatcher)
+    : mClientId(aClientId)
+    , mDispatcher(aDispatcher)
+  {
+    MOZ_ASSERT(mDispatcher);
+  }
+
+  bool RunTask(JSContext* aCx) override
+  {
+    sRilConsumers.EnsureLengthAtLeast(mClientId + 1);
+
+    MOZ_ASSERT(!sRilConsumers[mClientId]);
+
+    auto rilConsumer = MakeUnique<RilConsumer>();
+
+    nsresult rv = rilConsumer->ConnectWorkerToRIL(aCx);
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+
+    rv = rilConsumer->Register(mClientId, mDispatcher);
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+    sRilConsumers[mClientId] = Move(rilConsumer);
+
+    return true;
+  }
+
+private:
+  unsigned int mClientId;
+  RefPtr<WorkerCrossThreadDispatcher> mDispatcher;
+};
+
+nsresult
+RilWorker::RegisterConsumer(unsigned int aClientId)
+{
+  RefPtr<RegisterConsumerTask> task = new RegisterConsumerTask(aClientId,
+                                                                 mDispatcher);
+  if (!mDispatcher->PostTask(task)) {
+    NS_WARNING("Failed to post register-consumer task.");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  return NS_OK;
+}
+
+class RilWorker::UnregisterConsumerTask : public WorkerTask
+{
+public:
+  UnregisterConsumerTask(unsigned int aClientId)
+    : mClientId(aClientId)
+  { }
+
+  bool RunTask(JSContext* aCx) override
+  {
+    MOZ_ASSERT(mClientId < sRilConsumers.Length());
+    MOZ_ASSERT(sRilConsumers[mClientId]);
+
+    sRilConsumers[mClientId]->Unregister();
+    sRilConsumers[mClientId] = nullptr;
+
+    return true;
+  }
+
+private:
+  unsigned int mClientId;
+};
+
+void
+RilWorker::UnregisterConsumer(unsigned int aClientId)
+{
+  RefPtr<UnregisterConsumerTask> task =
+    new UnregisterConsumerTask(aClientId);
+
+  if (!mDispatcher->PostTask(task)) {
+    NS_WARNING("Failed to post unregister-consumer task.");
+    return;
+  }
+}
+
+} // namespace ipc
+} // namespace mozilla