The Tor Browser: dom/system/gonk/NetworkWorker.cpp@b8a032363ba2 (annotated)

dom/system/gonk/NetworkWorker.cpp@b8a032363ba2 (annotated)

dom/system/gonk/NetworkWorker.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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 "NetworkWorker.h"
 #include "NetworkUtils.h"
 #include <nsThreadUtils.h>
 #include "mozilla/ModuleUtils.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "nsXULAppAPI.h"
 #include "nsCxPusher.h"
 #define NS_NETWORKWORKER_CID \
   { 0x6df093e1, 0x8127, 0x4fa7, {0x90, 0x13, 0xa3, 0xaa, 0xa7, 0x79, 0xbb, 0xdd} }
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::ipc;
 namespace mozilla {
 nsCOMPtr<nsIThread> gWorkerThread;
 // The singleton network worker, to be used on the main thread.
 StaticRefPtr<NetworkWorker> gNetworkWorker;
 // The singleton networkutils class, that can be used on any thread.
 static nsAutoPtr<NetworkUtils> gNetworkUtils;
 // Runnable used dispatch command result on the main thread.
 class NetworkResultDispatcher : public nsRunnable
 {
 public:
   NetworkResultDispatcher(const NetworkResultOptions& aResult)
   {
     MOZ_ASSERT(!NS_IsMainThread());
 #define COPY_FIELD(prop) mResult.prop = aResult.prop;
     COPY_FIELD(mId)
     COPY_FIELD(mRet)
     COPY_FIELD(mBroadcast)
     COPY_FIELD(mTopic)
     COPY_FIELD(mReason)
     COPY_FIELD(mResultCode)
     COPY_FIELD(mResultReason)
     COPY_FIELD(mError)
     COPY_FIELD(mRxBytes)
     COPY_FIELD(mTxBytes)
     COPY_FIELD(mDate)
     COPY_FIELD(mEnable)
     COPY_FIELD(mResult)
     COPY_FIELD(mSuccess)
     COPY_FIELD(mCurExternalIfname)
     COPY_FIELD(mCurInternalIfname)
 #undef COPY_FIELD
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (gNetworkWorker) {
       gNetworkWorker->DispatchNetworkResult(mResult);
     }
     return NS_OK;
   }
 private:
   NetworkResultOptions mResult;
 };
 // Runnable used dispatch netd command on the worker thread.
 class NetworkCommandDispatcher : public nsRunnable
 {
 public:
   NetworkCommandDispatcher(const NetworkParams& aParams)
     : mParams(aParams)
   {
     MOZ_ASSERT(NS_IsMainThread());
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(!NS_IsMainThread());
     if (gNetworkUtils) {
       gNetworkUtils->ExecuteCommand(mParams);
     }
     return NS_OK;
   }
 private:
   NetworkParams mParams;
 };
 // Runnable used dispatch netd result on the worker thread.
 class NetdEventRunnable : public nsRunnable
 {
 public:
   NetdEventRunnable(NetdCommand* aCommand)
     : mCommand(aCommand)
   {
     MOZ_ASSERT(!NS_IsMainThread());
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(!NS_IsMainThread());
     if (gNetworkUtils) {
       gNetworkUtils->onNetdMessage(mCommand);
     }
     return NS_OK;
   }
 private:
   nsAutoPtr<NetdCommand> mCommand;
 };
 class NetdMessageConsumer : public NetdConsumer
 {
 public:
   NetdMessageConsumer()
   {
     MOZ_ASSERT(NS_IsMainThread());
   }
   void MessageReceived(NetdCommand* aCommand)
   {
     MOZ_ASSERT(!NS_IsMainThread());
     nsCOMPtr<nsIRunnable> runnable = new NetdEventRunnable(aCommand);
     if (gWorkerThread) {
       gWorkerThread->Dispatch(runnable, nsIEventTarget::DISPATCH_NORMAL);
     }
   }
 };
 NS_IMPL_ISUPPORTS(NetworkWorker, nsINetworkWorker)
 NetworkWorker::NetworkWorker()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!gNetworkWorker);
 }
 NetworkWorker::~NetworkWorker()
 {
   MOZ_ASSERT(!gNetworkWorker);
   MOZ_ASSERT(!mListener);
 }
 already_AddRefed<NetworkWorker>
 NetworkWorker::FactoryCreate()
 {
   if (XRE_GetProcessType() != GeckoProcessType_Default) {
     return nullptr;
   }
   MOZ_ASSERT(NS_IsMainThread());
   if (!gNetworkWorker) {
     gNetworkWorker = new NetworkWorker();
     ClearOnShutdown(&gNetworkWorker);
     gNetworkUtils = new NetworkUtils(NetworkWorker::NotifyResult);
     ClearOnShutdown(&gNetworkUtils);
   }
   nsRefPtr<NetworkWorker> worker = gNetworkWorker.get();
   return worker.forget();
 }
 NS_IMETHODIMP
 NetworkWorker::Start(nsINetworkEventListener* aListener)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aListener);
   if (mListener) {
     return NS_OK;
   }
   nsresult rv;
   rv = NS_NewNamedThread("NetworkWorker", getter_AddRefs(gWorkerThread));
   if (NS_FAILED(rv)) {
     NS_WARNING("Can't create network control thread");
     return NS_ERROR_FAILURE;
   }
   StartNetd(new NetdMessageConsumer());
   mListener = aListener;
   return NS_OK;
 }
 NS_IMETHODIMP
 NetworkWorker::Shutdown()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!mListener) {
     return NS_OK;
   }
   StopNetd();
   gWorkerThread->Shutdown();
   gWorkerThread = nullptr;
   mListener = nullptr;
   return NS_OK;
 }
 // Receive command from main thread (NetworkService.js).
 NS_IMETHODIMP
 NetworkWorker::PostMessage(JS::Handle<JS::Value> aOptions, JSContext* aCx)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NetworkCommandOptions options;
   if (!options.Init(aCx, aOptions)) {
     NS_WARNING("Bad dictionary passed to NetworkWorker::SendCommand");
     return NS_ERROR_FAILURE;
   }
   // Dispatch the command to the control thread.
   NetworkParams NetworkParams(options);
   nsCOMPtr<nsIRunnable> runnable = new NetworkCommandDispatcher(NetworkParams);
   if (gWorkerThread) {
     gWorkerThread->Dispatch(runnable, nsIEventTarget::DISPATCH_NORMAL);
   }
   return NS_OK;
 }
 void
 NetworkWorker::DispatchNetworkResult(const NetworkResultOptions& aOptions)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mozilla::AutoSafeJSContext cx;
   JS::RootedValue val(cx);
   if (!aOptions.ToObject(cx, &val)) {
     return;
   }
   // Call the listener with a JS value.
   if (mListener) {
     mListener->OnEvent(val);
   }
 }
 // Callback function from network worker thread to update result on main thread.
 void
 NetworkWorker::NotifyResult(NetworkResultOptions& aResult)
 {
   MOZ_ASSERT(!NS_IsMainThread());
   nsCOMPtr<nsIRunnable> runnable = new NetworkResultDispatcher(aResult);
   NS_DispatchToMainThread(runnable);
 }
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(NetworkWorker,
                                          NetworkWorker::FactoryCreate)
 NS_DEFINE_NAMED_CID(NS_NETWORKWORKER_CID);
 static const mozilla::Module::CIDEntry kNetworkWorkerCIDs[] = {
   { &kNS_NETWORKWORKER_CID, false, nullptr, NetworkWorkerConstructor },
   { nullptr }
 };
 static const mozilla::Module::ContractIDEntry kNetworkWorkerContracts[] = {
   { "@mozilla.org/network/worker;1", &kNS_NETWORKWORKER_CID },
   { nullptr }
 };
 static const mozilla::Module kNetworkWorkerModule = {
   mozilla::Module::kVersion,
   kNetworkWorkerCIDs,
   kNetworkWorkerContracts,
   nullptr
 };
 } // namespace mozilla
 NSMODULE_DEFN(NetworkWorkerModule) = &kNetworkWorkerModule;

The Tor Browser / annotate

dom/system/gonk/NetworkWorker.cpp@b8a032363ba2 (annotated)

dom/system/gonk/NetworkWorker.cpp