Add m-esr52 at 52.6.0

1 files changed, 1310 insertions, 0 deletions

diff --git a/dom/flyweb/FlyWebService.cpp b/dom/flyweb/FlyWebService.cpp
new file mode 100644
index 000000000..5f3b0d66f
--- /dev/null
+++ b/dom/flyweb/FlyWebService.cpp
@@ -0,0 +1,1310 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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/dom/FlyWebService.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/FlyWebPublishedServerIPC.h"
+#include "mozilla/AddonPathService.h"
+#include "nsISocketTransportService.h"
+#include "mdns/libmdns/nsDNSServiceInfo.h"
+#include "nsIUUIDGenerator.h"
+#include "nsStandardURL.h"
+#include "mozilla/Services.h"
+#include "nsISupportsPrimitives.h"
+#include "mozilla/dom/FlyWebDiscoveryManagerBinding.h"
+#include "prnetdb.h"
+#include "DNS.h"
+#include "nsContentPermissionHelper.h"
+#include "nsSocketTransportService2.h"
+#include "nsSocketTransport2.h"
+#include "nsHashPropertyBag.h"
+#include "nsNetUtil.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIProperty.h"
+#include "nsICertOverrideService.h"
+
+namespace mozilla {
+namespace dom {
+
+struct FlyWebPublishOptions;
+
+static LazyLogModule gFlyWebServiceLog("FlyWebService");
+#undef LOG_I
+#define LOG_I(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+
+#undef LOG_E
+#define LOG_E(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Error, (__VA_ARGS__))
+
+#undef LOG_TEST_I
+#define LOG_TEST_I(...) MOZ_LOG_TEST(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug)
+
+class FlyWebPublishServerPermissionCheck final
+  : public nsIContentPermissionRequest
+  , public nsIRunnable
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  FlyWebPublishServerPermissionCheck(const nsCString& aServiceName, uint64_t aWindowID,
+                                     FlyWebPublishedServer* aServer)
+    : mServiceName(aServiceName)
+    , mWindowID(aWindowID)
+    , mServer(aServer)
+  {}
+
+  uint64_t WindowID() const
+  {
+    return mWindowID;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    nsGlobalWindow* globalWindow = nsGlobalWindow::GetInnerWindowWithId(mWindowID);
+    if (!globalWindow) {
+      return Cancel();
+    }
+    mWindow = globalWindow->AsInner();
+    if (NS_WARN_IF(!mWindow)) {
+      return Cancel();
+    }
+
+    nsCOMPtr<nsIDocument> doc = mWindow->GetDoc();
+    if (NS_WARN_IF(!doc)) {
+      return Cancel();
+    }
+
+    mPrincipal = doc->NodePrincipal();
+    MOZ_ASSERT(mPrincipal);
+
+    mRequester = new nsContentPermissionRequester(mWindow);
+    return nsContentPermissionUtils::AskPermission(this, mWindow);
+  }
+
+  NS_IMETHOD Cancel() override
+  {
+    Resolve(false);
+    return NS_OK;
+  }
+
+  NS_IMETHOD Allow(JS::HandleValue aChoices) override
+  {
+    MOZ_ASSERT(aChoices.isUndefined());
+    Resolve(true);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetTypes(nsIArray** aTypes) override
+  {
+    nsTArray<nsString> emptyOptions;
+    return nsContentPermissionUtils::CreatePermissionArray(NS_LITERAL_CSTRING("flyweb-publish-server"),
+                                                           NS_LITERAL_CSTRING("unused"), emptyOptions, aTypes);
+  }
+
+  NS_IMETHOD GetRequester(nsIContentPermissionRequester** aRequester) override
+  {
+    NS_ENSURE_ARG_POINTER(aRequester);
+    nsCOMPtr<nsIContentPermissionRequester> requester = mRequester;
+    requester.forget(aRequester);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetPrincipal(nsIPrincipal** aRequestingPrincipal) override
+  {
+    NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetWindow(mozIDOMWindow** aRequestingWindow) override
+  {
+    NS_IF_ADDREF(*aRequestingWindow = mWindow);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetElement(nsIDOMElement** aRequestingElement) override
+  {
+    *aRequestingElement = nullptr;
+    return NS_OK;
+  }
+
+private:
+  void Resolve(bool aResolve)
+  {
+    mServer->PermissionGranted(aResolve);
+  }
+
+  virtual ~FlyWebPublishServerPermissionCheck() = default;
+
+  nsCString mServiceName;
+  uint64_t mWindowID;
+  RefPtr<FlyWebPublishedServer> mServer;
+  nsCOMPtr<nsPIDOMWindowInner> mWindow;
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCOMPtr<nsIContentPermissionRequester> mRequester;
+};
+
+NS_IMPL_ISUPPORTS(FlyWebPublishServerPermissionCheck,
+                  nsIContentPermissionRequest,
+                  nsIRunnable)
+
+class FlyWebMDNSService final
+  : public nsIDNSServiceDiscoveryListener
+  , public nsIDNSServiceResolveListener
+  , public nsIDNSRegistrationListener
+  , public nsITimerCallback
+{
+  friend class FlyWebService;
+
+private:
+  enum DiscoveryState {
+    DISCOVERY_IDLE,
+    DISCOVERY_STARTING,
+    DISCOVERY_RUNNING,
+    DISCOVERY_STOPPING
+  };
+
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDNSSERVICEDISCOVERYLISTENER
+  NS_DECL_NSIDNSSERVICERESOLVELISTENER
+  NS_DECL_NSIDNSREGISTRATIONLISTENER
+  NS_DECL_NSITIMERCALLBACK
+
+  explicit FlyWebMDNSService(FlyWebService* aService,
+                             const nsACString& aServiceType);
+
+private:
+  virtual ~FlyWebMDNSService() = default;
+
+  nsresult Init();
+  nsresult StartDiscovery();
+  nsresult StopDiscovery();
+
+  void ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices);
+  bool HasService(const nsAString& aServiceId);
+  nsresult PairWithService(const nsAString& aServiceId,
+                           UniquePtr<FlyWebService::PairedInfo>& aInfo);
+
+  nsresult StartDiscoveryOf(FlyWebPublishedServerImpl* aServer);
+
+  void EnsureDiscoveryStarted();
+  void EnsureDiscoveryStopped();
+
+  // Cycle-breaking link to manager.
+  FlyWebService* mService;
+  nsCString mServiceType;
+
+  // Indicates the desired state of the system.  If mDiscoveryActive is true,
+  // it indicates that backend discovery "should be happening", and discovery
+  // events should be forwarded to listeners.
+  // If false, the backend discovery "should be idle", and any discovery events
+  // that show up should not be forwarded to listeners.
+  bool mDiscoveryActive;
+
+  uint32_t mNumConsecutiveStartDiscoveryFailures;
+
+  // Represents the internal discovery state as it relates to nsDNSServiceDiscovery.
+  // When mDiscoveryActive is true, this state will periodically loop from
+  // (IDLE => STARTING => RUNNING => STOPPING => IDLE).
+  DiscoveryState mDiscoveryState;
+
+  nsCOMPtr<nsITimer> mDiscoveryStartTimer;
+  nsCOMPtr<nsITimer> mDiscoveryStopTimer;
+  nsCOMPtr<nsIDNSServiceDiscovery> mDNSServiceDiscovery;
+  nsCOMPtr<nsICancelable> mCancelDiscovery;
+  nsTHashtable<nsStringHashKey> mNewServiceSet;
+
+  struct DiscoveredInfo
+  {
+    explicit DiscoveredInfo(nsIDNSServiceInfo* aDNSServiceInfo);
+    FlyWebDiscoveredService mService;
+    nsCOMPtr<nsIDNSServiceInfo> mDNSServiceInfo;
+  };
+  nsClassHashtable<nsStringHashKey, DiscoveredInfo> mServiceMap;
+};
+
+void
+LogDNSInfo(nsIDNSServiceInfo* aServiceInfo, const char* aFunc)
+{
+  if (!LOG_TEST_I()) {
+    return;
+  }
+
+  nsCString tmp;
+  aServiceInfo->GetServiceName(tmp);
+  LOG_I("%s: serviceName=%s", aFunc, tmp.get());
+
+  aServiceInfo->GetHost(tmp);
+  LOG_I("%s: host=%s", aFunc, tmp.get());
+
+  aServiceInfo->GetAddress(tmp);
+  LOG_I("%s: address=%s", aFunc, tmp.get());
+
+  uint16_t port = -2;
+  aServiceInfo->GetPort(&port);
+  LOG_I("%s: port=%d", aFunc, (int)port);
+
+  nsCOMPtr<nsIPropertyBag2> attributes;
+  aServiceInfo->GetAttributes(getter_AddRefs(attributes));
+  if (!attributes) {
+    LOG_I("%s: no attributes", aFunc);
+  } else {
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    attributes->GetEnumerator(getter_AddRefs(enumerator));
+    MOZ_ASSERT(enumerator);
+
+    LOG_I("%s: attributes start", aFunc);
+
+    bool hasMoreElements;
+    while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) &&
+           hasMoreElements) {
+      nsCOMPtr<nsISupports> element;
+      MOZ_ALWAYS_SUCCEEDS(enumerator->GetNext(getter_AddRefs(element)));
+      nsCOMPtr<nsIProperty> property = do_QueryInterface(element);
+      MOZ_ASSERT(property);
+
+      nsAutoString name;
+      nsCOMPtr<nsIVariant> value;
+      MOZ_ALWAYS_SUCCEEDS(property->GetName(name));
+      MOZ_ALWAYS_SUCCEEDS(property->GetValue(getter_AddRefs(value)));
+
+      nsAutoCString str;
+      nsresult rv = value->GetAsACString(str);
+      if (NS_SUCCEEDED(rv)) {
+        LOG_I("%s: attribute name=%s value=%s", aFunc,
+              NS_ConvertUTF16toUTF8(name).get(), str.get());
+      } else {
+        uint16_t type;
+        MOZ_ALWAYS_SUCCEEDS(value->GetDataType(&type));
+        LOG_I("%s: attribute *unstringifiable* name=%s type=%d", aFunc,
+              NS_ConvertUTF16toUTF8(name).get(), (int)type);
+      }
+    }
+
+    LOG_I("%s: attributes end", aFunc);
+  }
+}
+
+NS_IMPL_ISUPPORTS(FlyWebMDNSService,
+                  nsIDNSServiceDiscoveryListener,
+                  nsIDNSServiceResolveListener,
+                  nsIDNSRegistrationListener,
+                  nsITimerCallback)
+
+FlyWebMDNSService::FlyWebMDNSService(
+        FlyWebService* aService,
+        const nsACString& aServiceType)
+  : mService(aService)
+  , mServiceType(aServiceType)
+  , mDiscoveryActive(false)
+  , mNumConsecutiveStartDiscoveryFailures(0)
+  , mDiscoveryState(DISCOVERY_IDLE)
+{}
+
+nsresult
+FlyWebMDNSService::OnDiscoveryStarted(const nsACString& aServiceType)
+{
+  MOZ_ASSERT(mDiscoveryState == DISCOVERY_STARTING);
+  mDiscoveryState = DISCOVERY_RUNNING;
+  // Reset consecutive start discovery failures.
+  mNumConsecutiveStartDiscoveryFailures = 0;
+  LOG_I("===========================================");
+  LOG_I("MDNSService::OnDiscoveryStarted(%s)", PromiseFlatCString(aServiceType).get());
+  LOG_I("===========================================");
+
+  // Clear the new service array.
+  mNewServiceSet.Clear();
+
+  // If service discovery is inactive, then stop network discovery immediately.
+  if (!mDiscoveryActive) {
+    // Set the stop timer to fire immediately.
+    Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStopTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
+    return NS_OK;
+  }
+
+  // Otherwise, set the stop timer to fire in 5 seconds.
+  Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStopTimer->InitWithCallback(this, 5 * 1000, nsITimer::TYPE_ONE_SHOT)));
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnDiscoveryStopped(const nsACString& aServiceType)
+{
+  LOG_I("///////////////////////////////////////////");
+  LOG_I("MDNSService::OnDiscoveryStopped(%s)", PromiseFlatCString(aServiceType).get());
+  LOG_I("///////////////////////////////////////////");
+  MOZ_ASSERT(mDiscoveryState == DISCOVERY_STOPPING);
+  mDiscoveryState = DISCOVERY_IDLE;
+
+  // If service discovery is inactive, then discard all results and do not proceed.
+  if (!mDiscoveryActive) {
+    mServiceMap.Clear();
+    mNewServiceSet.Clear();
+    return NS_OK;
+  }
+
+  // Process the service map, add to the pair map.
+  for (auto iter = mServiceMap.Iter(); !iter.Done(); iter.Next()) {
+    DiscoveredInfo* service = iter.UserData();
+
+    if (!mNewServiceSet.Contains(service->mService.mServiceId)) {
+      iter.Remove();
+    }
+  }
+
+  // Notify FlyWebService of changed service list.
+  mService->NotifyDiscoveredServicesChanged();
+
+  // Start discovery again immediately.
+  Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnServiceFound(nsIDNSServiceInfo* aServiceInfo)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceFound");
+
+  // If discovery is not active, don't do anything with the result.
+  // If there is no discovery underway, ignore this.
+  if (!mDiscoveryActive || mDiscoveryState != DISCOVERY_RUNNING) {
+    return NS_OK;
+  }
+
+  // Discovery is underway - resolve the service.
+  nsresult rv = mDNSServiceDiscovery->ResolveService(aServiceInfo, this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnServiceLost(nsIDNSServiceInfo* aServiceInfo)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceLost");
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnStartDiscoveryFailed(const nsACString& aServiceType, int32_t aErrorCode)
+{
+  LOG_E("MDNSService::OnStartDiscoveryFailed(%s): %d", PromiseFlatCString(aServiceType).get(), (int) aErrorCode);
+
+  MOZ_ASSERT(mDiscoveryState == DISCOVERY_STARTING);
+  mDiscoveryState = DISCOVERY_IDLE;
+  mNumConsecutiveStartDiscoveryFailures++;
+
+  // If discovery is active, and the number of consecutive failures is < 3, try starting again.
+  if (mDiscoveryActive && mNumConsecutiveStartDiscoveryFailures < 3) {
+    Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
+  }
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnStopDiscoveryFailed(const nsACString& aServiceType, int32_t aErrorCode)
+{
+  LOG_E("MDNSService::OnStopDiscoveryFailed(%s)", PromiseFlatCString(aServiceType).get());
+  MOZ_ASSERT(mDiscoveryState == DISCOVERY_STOPPING);
+  mDiscoveryState = DISCOVERY_IDLE;
+
+  // If discovery is active, start discovery again immediately.
+  if (mDiscoveryActive) {
+    Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
+  }
+
+  return NS_OK;
+}
+
+static bool
+IsAcceptableServiceAddress(const nsCString& addr)
+{
+  PRNetAddr prNetAddr;
+  PRStatus status = PR_StringToNetAddr(addr.get(), &prNetAddr);
+  if (status == PR_FAILURE) {
+    return false;
+  }
+  // Only allow ipv4 addreses for now.
+  return prNetAddr.raw.family == PR_AF_INET;
+}
+
+nsresult
+FlyWebMDNSService::OnServiceResolved(nsIDNSServiceInfo* aServiceInfo)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceResolved");
+
+  // If discovery is not active, don't do anything with the result.
+  // If there is no discovery underway, ignore this resolve.
+  if (!mDiscoveryActive || mDiscoveryState != DISCOVERY_RUNNING) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+
+  nsCString address;
+  rv = aServiceInfo->GetAddress(address);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (!IsAcceptableServiceAddress(address)) {
+    return NS_OK;
+  }
+
+  // Create a new serviceInfo and stuff it in the new service array.
+  UniquePtr<DiscoveredInfo> svc(new DiscoveredInfo(aServiceInfo));
+  mNewServiceSet.PutEntry(svc->mService.mServiceId);
+
+  DiscoveredInfo* existingSvc =
+    mServiceMap.Get(svc->mService.mServiceId);
+  if (existingSvc) {
+    // Update the underlying DNS service info, but leave the old object in place.
+    existingSvc->mDNSServiceInfo = aServiceInfo;
+  } else {
+    DiscoveredInfo* info = svc.release();
+    mServiceMap.Put(info->mService.mServiceId, info);
+  }
+
+  // Notify FlyWebService of changed service list.
+  mService->NotifyDiscoveredServicesChanged();
+
+  return NS_OK;
+}
+
+FlyWebMDNSService::DiscoveredInfo::DiscoveredInfo(nsIDNSServiceInfo* aDNSServiceInfo)
+  : mDNSServiceInfo(aDNSServiceInfo)
+{
+  nsCString tmp;
+  DebugOnly<nsresult> drv = aDNSServiceInfo->GetServiceName(tmp);
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+  CopyUTF8toUTF16(tmp, mService.mDisplayName);
+
+  mService.mTransport = NS_LITERAL_STRING("mdns");
+
+  drv = aDNSServiceInfo->GetServiceType(tmp);
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+  CopyUTF8toUTF16(tmp, mService.mServiceType);
+
+  nsCOMPtr<nsIPropertyBag2> attrs;
+  drv = aDNSServiceInfo->GetAttributes(getter_AddRefs(attrs));
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+  if (attrs) {
+    attrs->GetPropertyAsAString(NS_LITERAL_STRING("cert"), mService.mCert);
+    attrs->GetPropertyAsAString(NS_LITERAL_STRING("path"), mService.mPath);
+  }
+
+  // Construct a service id from the name, host, address, and port.
+  nsCString cHost;
+  drv = aDNSServiceInfo->GetHost(cHost);
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+
+  nsCString cAddress;
+  drv = aDNSServiceInfo->GetAddress(cAddress);
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+
+  uint16_t port;
+  drv = aDNSServiceInfo->GetPort(&port);
+  MOZ_ASSERT(NS_SUCCEEDED(drv));
+  nsAutoString portStr;
+  portStr.AppendInt(port, 10);
+
+  mService.mServiceId =
+    NS_ConvertUTF8toUTF16(cAddress) +
+    NS_LITERAL_STRING(":") +
+    portStr +
+    NS_LITERAL_STRING("|") +
+    mService.mServiceType +
+    NS_LITERAL_STRING("|") +
+    NS_ConvertUTF8toUTF16(cHost) +
+    NS_LITERAL_STRING("|") +
+    mService.mDisplayName;
+}
+
+
+nsresult
+FlyWebMDNSService::OnResolveFailed(nsIDNSServiceInfo* aServiceInfo, int32_t aErrorCode)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnResolveFailed");
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnServiceRegistered(nsIDNSServiceInfo* aServiceInfo)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceRegistered");
+
+  nsCString cName;
+  if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsString name = NS_ConvertUTF8toUTF16(cName);
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
+  if (!existingServer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  existingServer->PublishedServerStarted(NS_OK);
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnServiceUnregistered(nsIDNSServiceInfo* aServiceInfo)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceUnregistered");
+
+  nsCString cName;
+  if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsString name = NS_ConvertUTF8toUTF16(cName);
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
+  if (!existingServer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  LOG_I("OnServiceRegistered(MDNS): De-advertised server with name %s.", cName.get());
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnRegistrationFailed(nsIDNSServiceInfo* aServiceInfo, int32_t errorCode)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnRegistrationFailed");
+
+  nsCString cName;
+  if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsString name = NS_ConvertUTF8toUTF16(cName);
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
+  if (!existingServer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  LOG_I("OnServiceRegistered(MDNS): Registration of server with name %s failed.", cName.get());
+
+  // Remove the nsICancelable from the published server.
+  existingServer->PublishedServerStarted(NS_ERROR_FAILURE);
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::OnUnregistrationFailed(nsIDNSServiceInfo* aServiceInfo, int32_t errorCode)
+{
+  LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnUnregistrationFailed");
+
+  nsCString cName;
+  if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsString name = NS_ConvertUTF8toUTF16(cName);
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
+  if (!existingServer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  LOG_I("OnServiceRegistered(MDNS): Un-Advertisement of server with name %s failed.", cName.get());
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::Notify(nsITimer* timer)
+{
+  if (timer == mDiscoveryStopTimer.get()) {
+    LOG_I("MDNSService::Notify() got discovery stop timeout");
+    // Internet discovery stop timer has fired.
+    nsresult rv = StopDiscovery();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    return NS_OK;
+  }
+
+  if (timer == mDiscoveryStartTimer.get()) {
+    LOG_I("MDNSService::Notify() got discovery start timeout");
+    // Internet discovery start timer has fired.
+    nsresult rv = StartDiscovery();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    return NS_OK;
+  }
+
+  LOG_E("MDNSService::Notify got unknown timeout.");
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::Init()
+{
+  MOZ_ASSERT(mDiscoveryState == DISCOVERY_IDLE);
+
+  mDiscoveryStartTimer = do_CreateInstance("@mozilla.org/timer;1");
+  if (!mDiscoveryStartTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mDiscoveryStopTimer = do_CreateInstance("@mozilla.org/timer;1");
+  if (!mDiscoveryStopTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv;
+  mDNSServiceDiscovery = do_GetService(DNSSERVICEDISCOVERY_CONTRACT_ID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::StartDiscovery()
+{
+  nsresult rv;
+
+  // Always cancel the timer.
+  rv = mDiscoveryStartTimer->Cancel();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    LOG_E("FlyWeb failed to cancel DNS service discovery start timer.");
+  }
+
+  // If discovery is not idle, don't start it.
+  if (mDiscoveryState != DISCOVERY_IDLE) {
+    return NS_OK;
+  }
+
+  LOG_I("FlyWeb starting dicovery.");
+  mDiscoveryState = DISCOVERY_STARTING;
+
+  // start the discovery.
+  rv = mDNSServiceDiscovery->StartDiscovery(mServiceType, this,
+                                            getter_AddRefs(mCancelDiscovery));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    LOG_E("FlyWeb failed to start DNS service discovery.");
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::StopDiscovery()
+{
+  nsresult rv;
+
+  // Always cancel the timer.
+  rv = mDiscoveryStopTimer->Cancel();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    LOG_E("FlyWeb failed to cancel DNS service discovery stop timer.");
+  }
+
+  // If discovery is not running, do nothing.
+  if (mDiscoveryState != DISCOVERY_RUNNING) {
+    return NS_OK;
+  }
+
+  LOG_I("FlyWeb stopping dicovery.");
+
+  // Mark service discovery as stopping.
+  mDiscoveryState = DISCOVERY_STOPPING;
+
+  if (mCancelDiscovery) {
+    LOG_I("MDNSService::StopDiscovery() - mCancelDiscovery exists!");
+    nsCOMPtr<nsICancelable> cancelDiscovery = mCancelDiscovery.forget();
+    rv = cancelDiscovery->Cancel(NS_ERROR_ABORT);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      LOG_E("FlyWeb failed to cancel DNS stop service discovery.");
+    }
+  } else {
+    LOG_I("MDNSService::StopDiscovery() - mCancelDiscovery does not exist!");
+    mDiscoveryState = DISCOVERY_IDLE;
+  }
+
+  return NS_OK;
+}
+
+void
+FlyWebMDNSService::ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices)
+{
+  for (auto iter = mServiceMap.Iter(); !iter.Done(); iter.Next()) {
+    aServices.AppendElement(iter.UserData()->mService);
+  }
+}
+
+bool
+FlyWebMDNSService::HasService(const nsAString& aServiceId)
+{
+  return mServiceMap.Contains(aServiceId);
+}
+
+nsresult
+FlyWebMDNSService::PairWithService(const nsAString& aServiceId,
+                                   UniquePtr<FlyWebService::PairedInfo>& aInfo)
+{
+  MOZ_ASSERT(HasService(aServiceId));
+
+  nsresult rv;
+  nsCOMPtr<nsIUUIDGenerator> uuidgen =
+    do_GetService("@mozilla.org/uuid-generator;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsID id;
+  rv = uuidgen->GenerateUUIDInPlace(&id);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aInfo.reset(new FlyWebService::PairedInfo());
+
+  char uuidChars[NSID_LENGTH];
+  id.ToProvidedString(uuidChars);
+  CopyUTF8toUTF16(Substring(uuidChars + 1, uuidChars + NSID_LENGTH - 2),
+                  aInfo->mService.mHostname);
+
+  DiscoveredInfo* discInfo = mServiceMap.Get(aServiceId);
+
+  nsAutoString url;
+  if (discInfo->mService.mCert.IsEmpty()) {
+    url.AssignLiteral("http://");
+  } else {
+    url.AssignLiteral("https://");
+  }
+  url.Append(aInfo->mService.mHostname + NS_LITERAL_STRING("/"));
+  nsCOMPtr<nsIURI> uiURL;
+  NS_NewURI(getter_AddRefs(uiURL), url);
+  MOZ_ASSERT(uiURL);
+  if (!discInfo->mService.mPath.IsEmpty()) {
+    nsCOMPtr<nsIURI> tmp = uiURL.forget();
+    NS_NewURI(getter_AddRefs(uiURL), discInfo->mService.mPath, nullptr, tmp);
+  }
+  if (uiURL) {
+    nsAutoCString spec;
+    uiURL->GetSpec(spec);
+    CopyUTF8toUTF16(spec, aInfo->mService.mUiUrl);
+  }
+
+  aInfo->mService.mDiscoveredService = discInfo->mService;
+  aInfo->mDNSServiceInfo = discInfo->mDNSServiceInfo;
+
+  return NS_OK;
+}
+
+nsresult
+FlyWebMDNSService::StartDiscoveryOf(FlyWebPublishedServerImpl* aServer)
+{
+
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(aServer->Name());
+  MOZ_ASSERT(existingServer);
+
+  // Advertise the service via mdns.
+  RefPtr<net::nsDNSServiceInfo> serviceInfo(new net::nsDNSServiceInfo());
+
+  serviceInfo->SetPort(aServer->Port());
+  serviceInfo->SetServiceType(mServiceType);
+
+  nsCString certKey;
+  aServer->GetCertKey(certKey);
+  nsString uiURL;
+  aServer->GetUiUrl(uiURL);
+
+  if (!uiURL.IsEmpty() || !certKey.IsEmpty()) {
+    RefPtr<nsHashPropertyBag> attrs = new nsHashPropertyBag();
+    if (!uiURL.IsEmpty()) {
+      attrs->SetPropertyAsAString(NS_LITERAL_STRING("path"), uiURL);
+    }
+    if (!certKey.IsEmpty()) {
+      attrs->SetPropertyAsACString(NS_LITERAL_STRING("cert"), certKey);
+    }
+    serviceInfo->SetAttributes(attrs);
+  }
+
+  nsCString cstrName = NS_ConvertUTF16toUTF8(aServer->Name());
+  LOG_I("MDNSService::StartDiscoveryOf() advertising service %s", cstrName.get());
+  serviceInfo->SetServiceName(cstrName);
+
+  LogDNSInfo(serviceInfo, "FlyWebMDNSService::StartDiscoveryOf");
+
+  // Advertise the service.
+  nsCOMPtr<nsICancelable> cancelRegister;
+  nsresult rv = mDNSServiceDiscovery->
+    RegisterService(serviceInfo, this, getter_AddRefs(cancelRegister));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // All done.
+  aServer->SetCancelRegister(cancelRegister);
+
+  return NS_OK;
+}
+
+void
+FlyWebMDNSService::EnsureDiscoveryStarted()
+{
+  mDiscoveryActive = true;
+  // If state is idle, start discovery immediately.
+  if (mDiscoveryState == DISCOVERY_IDLE) {
+    StartDiscovery();
+  }
+}
+
+void
+FlyWebMDNSService::EnsureDiscoveryStopped()
+{
+  // All we need to do is set the flag to false.
+  // If current state is IDLE, it's already the correct state.
+  // Otherwise, the handlers for the internal state
+  // transitions will check this flag and drive the state
+  // towards IDLE.
+  mDiscoveryActive = false;
+}
+
+static StaticRefPtr<FlyWebService> gFlyWebService;
+
+NS_IMPL_ISUPPORTS(FlyWebService, nsIObserver)
+
+FlyWebService::FlyWebService()
+  : mMonitor("FlyWebService::mMonitor")
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->AddObserver(this, "inner-window-destroyed", false);
+  }
+}
+
+FlyWebService::~FlyWebService()
+{
+}
+
+FlyWebService*
+FlyWebService::GetExisting()
+{
+  return gFlyWebService;
+}
+
+FlyWebService*
+FlyWebService::GetOrCreate()
+{
+  if (!gFlyWebService) {
+    gFlyWebService = new FlyWebService();
+    ClearOnShutdown(&gFlyWebService);
+    ErrorResult rv = gFlyWebService->Init();
+    if (rv.Failed()) {
+      gFlyWebService = nullptr;
+      return nullptr;
+    }
+  }
+  return gFlyWebService;
+}
+
+ErrorResult
+FlyWebService::Init()
+{
+  // Most functions of FlyWebService should not be started in the child.
+  // Instead FlyWebService in the child is mainly responsible for tracking
+  // publishedServer lifetimes. Other functions are handled by the
+  // FlyWebService running in the parent.
+  if (XRE_GetProcessType() == GeckoProcessType_Content) {
+    return ErrorResult(NS_OK);
+  }
+
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!mMDNSHttpService) {
+    mMDNSHttpService = new FlyWebMDNSService(this, NS_LITERAL_CSTRING("_http._tcp."));
+    ErrorResult rv;
+
+    rv = mMDNSHttpService->Init();
+    if (rv.Failed()) {
+      LOG_E("FlyWebService failed to initialize MDNS _http._tcp.");
+      mMDNSHttpService = nullptr;
+      rv.SuppressException();
+    }
+  }
+
+  if (!mMDNSFlywebService) {
+    mMDNSFlywebService = new FlyWebMDNSService(this, NS_LITERAL_CSTRING("_flyweb._tcp."));
+    ErrorResult rv;
+
+    rv = mMDNSFlywebService->Init();
+    if (rv.Failed()) {
+      LOG_E("FlyWebService failed to initialize MDNS _flyweb._tcp.");
+      mMDNSFlywebService = nullptr;
+      rv.SuppressException();
+    }
+  }
+
+  return ErrorResult(NS_OK);
+}
+
+static already_AddRefed<FlyWebPublishPromise>
+MakeRejectionPromise(const char* name)
+{
+    MozPromiseHolder<FlyWebPublishPromise> holder;
+    RefPtr<FlyWebPublishPromise> promise = holder.Ensure(name);
+    holder.Reject(NS_ERROR_FAILURE, name);
+    return promise.forget();
+}
+
+static bool
+CheckForFlyWebAddon(const nsACString& uriString)
+{
+  // Before proceeding, ensure that the FlyWeb system addon exists.
+  nsresult rv;
+  nsCOMPtr<nsIURI> uri;
+  rv = NS_NewURI(getter_AddRefs(uri), uriString);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  JSAddonId *addonId = MapURIToAddonID(uri);
+  if (!addonId) {
+    return false;
+  }
+
+  JSFlatString* flat = JS_ASSERT_STRING_IS_FLAT(JS::StringOfAddonId(addonId));
+  nsAutoString addonIdString;
+  AssignJSFlatString(addonIdString, flat);
+  if (!addonIdString.EqualsLiteral("flyweb@mozilla.org")) {
+    nsCString addonIdCString = NS_ConvertUTF16toUTF8(addonIdString);
+    return false;
+  }
+
+  return true;
+}
+
+already_AddRefed<FlyWebPublishPromise>
+FlyWebService::PublishServer(const nsAString& aName,
+                             const FlyWebPublishOptions& aOptions,
+                             nsPIDOMWindowInner* aWindow)
+{
+  // Scan uiUrl for illegal characters
+
+  RefPtr<FlyWebPublishedServer> existingServer =
+    FlyWebService::GetOrCreate()->FindPublishedServerByName(aName);
+  if (existingServer) {
+    LOG_I("PublishServer: Trying to publish server with already-existing name %s.",
+          NS_ConvertUTF16toUTF8(aName).get());
+    return MakeRejectionPromise(__func__);
+  }
+
+  RefPtr<FlyWebPublishedServer> server;
+  if (XRE_GetProcessType() == GeckoProcessType_Content) {
+    server = new FlyWebPublishedServerChild(aWindow, aName, aOptions);
+  } else {
+    server = new FlyWebPublishedServerImpl(aWindow, aName, aOptions);
+
+    // Before proceeding, ensure that the FlyWeb system addon exists.
+    if (!CheckForFlyWebAddon(NS_LITERAL_CSTRING("chrome://flyweb/skin/icon-64.png")) &&
+        !CheckForFlyWebAddon(NS_LITERAL_CSTRING("chrome://flyweb/content/icon-64.png")))
+    {
+      LOG_E("PublishServer: Failed to find FlyWeb system addon.");
+      return MakeRejectionPromise(__func__);
+    }
+  }
+
+  if (aWindow) {
+    nsresult rv;
+
+    MOZ_ASSERT(NS_IsMainThread());
+    rv = NS_DispatchToCurrentThread(
+      MakeAndAddRef<FlyWebPublishServerPermissionCheck>(
+        NS_ConvertUTF16toUTF8(aName), aWindow->WindowID(), server));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      LOG_E("PublishServer: Failed to dispatch permission check runnable for %s",
+            NS_ConvertUTF16toUTF8(aName).get());
+      return MakeRejectionPromise(__func__);
+    }
+  } else {
+    // If aWindow is null, we're definitely in the e10s parent process.
+    // In this case, we know that permission has already been granted
+    // by the user because of content-process prompt.
+    MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+    server->PermissionGranted(true);
+  }
+
+  mServers.AppendElement(server);
+
+  return server->GetPublishPromise();
+}
+
+already_AddRefed<FlyWebPublishedServer>
+FlyWebService::FindPublishedServerByName(
+        const nsAString& aName)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  for (FlyWebPublishedServer* publishedServer : mServers) {
+    if (publishedServer->Name().Equals(aName)) {
+      RefPtr<FlyWebPublishedServer> server = publishedServer;
+      return server.forget();
+    }
+  }
+  return nullptr;
+}
+
+void
+FlyWebService::RegisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  mDiscoveryManagerTable.PutEntry(aDiscoveryManager);
+  if (mMDNSHttpService) {
+    mMDNSHttpService->EnsureDiscoveryStarted();
+  }
+  if (mMDNSFlywebService) {
+    mMDNSFlywebService->EnsureDiscoveryStarted();
+  }
+}
+
+void
+FlyWebService::UnregisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  mDiscoveryManagerTable.RemoveEntry(aDiscoveryManager);
+  if (mDiscoveryManagerTable.IsEmpty()) {
+    if (mMDNSHttpService) {
+      mMDNSHttpService->EnsureDiscoveryStopped();
+    }
+    if (mMDNSFlywebService) {
+      mMDNSFlywebService->EnsureDiscoveryStopped();
+    }
+  }
+}
+
+NS_IMETHODIMP
+FlyWebService::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  if (strcmp(aTopic, "inner-window-destroyed")) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE);
+
+  uint64_t innerID;
+  nsresult rv = wrapper->GetData(&innerID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (FlyWebPublishedServer* server : mServers) {
+    if (server->OwnerWindowID() == innerID) {
+      server->Close();
+    }
+  }
+
+  return NS_OK;
+}
+
+void
+FlyWebService::UnregisterServer(FlyWebPublishedServer* aServer)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  DebugOnly<bool> removed = mServers.RemoveElement(aServer);
+  MOZ_ASSERT(removed);
+}
+
+bool
+FlyWebService::HasConnectionOrServer(uint64_t aWindowID)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  for (FlyWebPublishedServer* server : mServers) {
+    nsPIDOMWindowInner* win = server->GetOwner();
+    if (win && win->WindowID() == aWindowID) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void
+FlyWebService::NotifyDiscoveredServicesChanged()
+{
+  // Process the service map, add to the pair map.
+  for (auto iter = mDiscoveryManagerTable.Iter(); !iter.Done(); iter.Next()) {
+    iter.Get()->GetKey()->NotifyDiscoveredServicesChanged();
+  }
+}
+
+void
+FlyWebService::ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mMDNSHttpService) {
+    mMDNSHttpService->ListDiscoveredServices(aServices);
+  }
+  if (mMDNSFlywebService) {
+    mMDNSFlywebService->ListDiscoveredServices(aServices);
+  }
+}
+
+void
+FlyWebService::PairWithService(const nsAString& aServiceId,
+                               FlyWebPairingCallback& aCallback)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  // See if we have already paired with this service.  If so, re-use the
+  // FlyWebPairedService for that.
+  {
+    ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
+    for (auto iter = mPairedServiceTable.Iter(); !iter.Done(); iter.Next()) {
+      PairedInfo* pairInfo = iter.UserData();
+      if (pairInfo->mService.mDiscoveredService.mServiceId.Equals(aServiceId)) {
+        ErrorResult er;
+        ReentrantMonitorAutoExit pairedMapRelease(mMonitor);
+        aCallback.PairingSucceeded(pairInfo->mService, er);
+        ENSURE_SUCCESS_VOID(er);
+        return;
+      }
+    }
+  }
+
+  UniquePtr<PairedInfo> pairInfo;
+
+  nsresult rv = NS_OK;
+  bool notFound = false;
+  if (mMDNSHttpService && mMDNSHttpService->HasService(aServiceId)) {
+    rv = mMDNSHttpService->PairWithService(aServiceId, pairInfo);
+  } else if (mMDNSFlywebService && mMDNSFlywebService->HasService(aServiceId)) {
+    rv = mMDNSFlywebService->PairWithService(aServiceId, pairInfo);
+  } else {
+    notFound = true;
+  }
+
+  if (NS_FAILED(rv)) {
+    ErrorResult result;
+    result.Throw(rv);
+    const nsAString& reason = NS_LITERAL_STRING("Error pairing.");
+    aCallback.PairingFailed(reason, result);
+    ENSURE_SUCCESS_VOID(result);
+    return;
+  }
+
+  if (!pairInfo) {
+    ErrorResult res;
+    const nsAString& reason = notFound ?
+      NS_LITERAL_STRING("No such service.") :
+      NS_LITERAL_STRING("Error pairing.");
+    aCallback.PairingFailed(reason, res);
+    ENSURE_SUCCESS_VOID(res);
+    return;
+  }
+
+  // Add fingerprint to certificate override database.
+  if (!pairInfo->mService.mDiscoveredService.mCert.IsEmpty()) {
+    nsCOMPtr<nsICertOverrideService> override =
+      do_GetService("@mozilla.org/security/certoverride;1");
+    if (!override ||
+        NS_FAILED(override->RememberTemporaryValidityOverrideUsingFingerprint(
+          NS_ConvertUTF16toUTF8(pairInfo->mService.mHostname),
+          -1,
+          NS_ConvertUTF16toUTF8(pairInfo->mService.mDiscoveredService.mCert),
+          nsICertOverrideService::ERROR_UNTRUSTED |
+          nsICertOverrideService::ERROR_MISMATCH))) {
+      ErrorResult res;
+      aCallback.PairingFailed(NS_LITERAL_STRING("Error adding certificate override."), res);
+      ENSURE_SUCCESS_VOID(res);
+      return;
+    }
+  }
+
+  // Grab a weak reference to the PairedInfo so that we can
+  // use it even after ownership has been transferred to mPairedServiceTable
+  PairedInfo* pairInfoWeak = pairInfo.release();
+
+  {
+    ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
+    mPairedServiceTable.Put(
+      NS_ConvertUTF16toUTF8(pairInfoWeak->mService.mHostname), pairInfoWeak);
+  }
+
+  ErrorResult er;
+  aCallback.PairingSucceeded(pairInfoWeak->mService, er);
+  ENSURE_SUCCESS_VOID(er);
+}
+
+nsresult
+FlyWebService::CreateTransportForHost(const char **types,
+                                      uint32_t typeCount,
+                                      const nsACString &host,
+                                      int32_t port,
+                                      const nsACString &hostRoute,
+                                      int32_t portRoute,
+                                      nsIProxyInfo *proxyInfo,
+                                      nsISocketTransport **result)
+{
+  // This might be called on background threads
+
+  *result = nullptr;
+
+  nsCString ipAddrString;
+  uint16_t discPort;
+
+  {
+    ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
+
+    PairedInfo* info = mPairedServiceTable.Get(host);
+
+    if (!info) {
+      return NS_OK;
+    }
+
+    // Get the ip address of the underlying service.
+    info->mDNSServiceInfo->GetAddress(ipAddrString);
+    info->mDNSServiceInfo->GetPort(&discPort);
+  }
+
+  // Parse it into an NetAddr.
+  PRNetAddr prNetAddr;
+  PRStatus status = PR_StringToNetAddr(ipAddrString.get(), &prNetAddr);
+  NS_ENSURE_FALSE(status == PR_FAILURE, NS_ERROR_FAILURE);
+
+  // Convert PRNetAddr to NetAddr.
+  mozilla::net::NetAddr netAddr;
+  PRNetAddrToNetAddr(&prNetAddr, &netAddr);
+  netAddr.inet.port = htons(discPort);
+
+  RefPtr<mozilla::net::nsSocketTransport> trans = new mozilla::net::nsSocketTransport();
+  nsresult rv = trans->InitPreResolved(
+    types, typeCount, host, port, hostRoute, portRoute, proxyInfo, &netAddr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  trans.forget(result);
+  return NS_OK;
+}
+
+void
+FlyWebService::StartDiscoveryOf(FlyWebPublishedServerImpl* aServer)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  nsresult rv = mMDNSFlywebService ?
+    mMDNSFlywebService->StartDiscoveryOf(aServer) :
+    NS_ERROR_FAILURE;
+
+  if (NS_FAILED(rv)) {
+    aServer->PublishedServerStarted(rv);
+  }
+}
+
+} // namespace dom
+} // namespace mozilla