--- a/b2g/installer/package-manifest.in
+++ b/b2g/installer/package-manifest.in
@@ -409,17 +409,17 @@
 @RESPATH@/components/nsSidebar.js
 @RESPATH@/components/nsAsyncShutdown.manifest
 @RESPATH@/components/nsAsyncShutdown.js
 @RESPATH@/components/htmlMenuBuilder.js
 @RESPATH@/components/htmlMenuBuilder.manifest
 @RESPATH@/components/PresentationDeviceInfoManager.manifest
 @RESPATH@/components/PresentationDeviceInfoManager.js
 @RESPATH@/components/BuiltinProviders.manifest
-@RESPATH@/components/TCPPresentationServer.js
+@RESPATH@/components/PresentationControlService.js
 @RESPATH@/components/PresentationDataChannelSessionTransport.js
 @RESPATH@/components/PresentationDataChannelSessionTransport.manifest
 
 #ifdef MOZ_SECUREELEMENT
 @RESPATH@/components/ACEService.js
 @RESPATH@/components/ACEService.manifest
 @RESPATH@/components/GPAccessRulesManager.js
 @RESPATH@/components/GPAccessRulesManager.manifest

--- a/browser/installer/package-manifest.in
+++ b/browser/installer/package-manifest.in
@@ -564,17 +564,17 @@
 #endif
 
 @RESPATH@/components/nsAsyncShutdown.manifest
 @RESPATH@/components/nsAsyncShutdown.js
 
 @RESPATH@/components/PresentationDeviceInfoManager.manifest
 @RESPATH@/components/PresentationDeviceInfoManager.js
 @RESPATH@/components/BuiltinProviders.manifest
-@RESPATH@/components/TCPPresentationServer.js
+@RESPATH@/components/PresentationControlService.js
 @RESPATH@/components/PresentationDataChannelSessionTransport.js
 @RESPATH@/components/PresentationDataChannelSessionTransport.manifest
 
 ; InputMethod API
 @RESPATH@/components/MozKeyboard.js
 @RESPATH@/components/InputMethod.manifest
 
 #ifdef MOZ_DEBUG

--- a/dom/presentation/interfaces/moz.build
+++ b/dom/presentation/interfaces/moz.build
@@ -1,28 +1,28 @@
 # -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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/.
 
 XPIDL_SOURCES += [
     'nsIPresentationControlChannel.idl',
+    'nsIPresentationControlService.idl',
     'nsIPresentationDevice.idl',
     'nsIPresentationDeviceManager.idl',
     'nsIPresentationDevicePrompt.idl',
     'nsIPresentationDeviceProvider.idl',
     'nsIPresentationListener.idl',
     'nsIPresentationLocalDevice.idl',
     'nsIPresentationRequestUIGlue.idl',
     'nsIPresentationService.idl',
     'nsIPresentationSessionRequest.idl',
     'nsIPresentationSessionTransport.idl',
     'nsIPresentationSessionTransportBuilder.idl',
-    'nsITCPPresentationServer.idl',
 ]
 
 if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'android':
     XPIDL_SOURCES += [
         'nsIPresentationNetworkHelper.idl',
     ]
 
 XPIDL_MODULE = 'dom_presentation'

rename from dom/presentation/interfaces/nsITCPPresentationServer.idl
rename to dom/presentation/interfaces/nsIPresentationControlService.idl
--- a/dom/presentation/interfaces/nsITCPPresentationServer.idl
+++ b/dom/presentation/interfaces/nsIPresentationControlService.idl
@@ -2,33 +2,33 @@
  * 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 "nsISupports.idl"
 
 interface nsIPresentationControlChannel;
 
 %{C++
-#define TCP_PRESENTATION_SERVER_CONTACT_ID \
-  "@mozilla.org/presentation-device/tcp-presentation-server;1"
+#define PRESENTATION_CONTROL_SERVICE_CONTACT_ID \
+  "@mozilla.org/presentation/control-service;1"
 %}
 
 /*
- * The device information required for establishing TCP control channel.
+ * The device information required for establishing control channel.
  */
 [scriptable, uuid(296fd171-e4d0-4de0-99ff-ad8ed52ddef3)]
 interface nsITCPDeviceInfo: nsISupports
 {
   readonly attribute AUTF8String id;
   readonly attribute AUTF8String address;
   readonly attribute uint16_t port;
 };
 
 [scriptable, uuid(09bddfaf-fcc2-4dc9-b33e-a509a1c2fb6d)]
-interface nsITCPPresentationServerListener: nsISupports
+interface nsIPresentationControlServerListener: nsISupports
 {
   /**
    * Callback while the server socket changes port.
    * This event won't be cached so you should get current port after setting
    * this listener to make sure the value is updated.
    * @param   aPort
    *          The port of the server socket.
    */
@@ -43,33 +43,34 @@ interface nsITCPPresentationServerListen
    */
   void onSessionRequest(in nsITCPDeviceInfo aDeviceInfo,
                         in DOMString aUrl,
                         in DOMString aPresentationId,
                         in nsIPresentationControlChannel aControlChannel);
 };
 
 /**
- * TCP presentation server which can be used by discovery services.
+ * Presentation control service which can be used for both presentation
+ * control client and server.
  */
 [scriptable, uuid(55d6b605-2389-4aae-a8fe-60d4440540ea)]
-interface nsITCPPresentationServer: nsISupports
+interface nsIPresentationControlService: nsISupports
 {
   /**
    * This method initialize server socket.
    * @param   aPort
    *          The port of the server socket.  Pass 0 or opt-out to indicate no
    *          preference, and a port will be selected automatically.
    * @throws  NS_ERROR_FAILURE if the server socket has been inited or the
    *          server socket can not be inited.
    */
-  void startService([optional] in uint16_t aPort);
+  void startServer([optional] in uint16_t aPort);
 
   /**
-   * Request session to designated remote TCP device.
+   * Request session to designated remote presentation control receiver.
    * @param   aDeviceInfo
    *          The remtoe device info for establish connection.
    * @param   aUrl
    *          The URL requested to open by remote device.
    * @param   aPresentationId
    *          The Id for representing this session.
    * @returns The control channel for this session.
    * @throws  NS_ERROR_FAILURE if the Id hasn't been inited.
@@ -91,12 +92,12 @@ interface nsITCPPresentationServer: nsIS
 
   /**
    * The id of the TCP presentation server. |requestSession| won't
    * work until the |id| is set.
    */
   attribute AUTF8String id;
 
   /**
-   * the listener for handling events of this TCP presentation server
+   * the listener for handling events of this presentation control server
    */
-  attribute nsITCPPresentationServerListener listener;
+  attribute nsIPresentationControlServerListener listener;
 };

--- a/dom/presentation/provider/BuiltinProviders.manifest
+++ b/dom/presentation/provider/BuiltinProviders.manifest
@@ -1,2 +1,2 @@
-component {f4079b8b-ede5-4b90-a112-5b415a931deb} TCPPresentationServer.js
-contract @mozilla.org/presentation-device/tcp-presentation-server;1 {f4079b8b-ede5-4b90-a112-5b415a931deb}
+component {f4079b8b-ede5-4b90-a112-5b415a931deb} PresentationControlService.js
+contract @mozilla.org/presentation/control-service;1 {f4079b8b-ede5-4b90-a112-5b415a931deb}

--- a/dom/presentation/provider/DisplayDeviceProvider.cpp
+++ b/dom/presentation/provider/DisplayDeviceProvider.cpp
@@ -6,17 +6,16 @@
 
 #include "DisplayDeviceProvider.h"
 #include "mozilla/Logging.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "mozilla/unused.h"
 #include "nsIObserverService.h"
 #include "nsIServiceManager.h"
-#include "nsITCPPresentationServer.h"
 #include "nsIWindowWatcher.h"
 #include "nsNetUtil.h"
 #include "nsPIDOMWindow.h"
 #include "nsSimpleURI.h"
 #include "nsTCPDeviceInfo.h"
 #include "nsThreadUtils.h"
 
 static mozilla::LazyLogModule gDisplayDeviceProviderLog("DisplayDeviceProvider");
@@ -30,38 +29,38 @@ static mozilla::LazyLogModule gDisplayDe
 namespace mozilla {
 namespace dom {
 namespace presentation {
 
 /**
  * This wrapper is used to break circular-reference problem.
  */
 class DisplayDeviceProviderWrappedListener final
-  : public nsITCPPresentationServerListener
+  : public nsIPresentationControlServerListener
 {
 public:
   NS_DECL_ISUPPORTS
-  NS_FORWARD_SAFE_NSITCPPRESENTATIONSERVERLISTENER(mListener)
+  NS_FORWARD_SAFE_NSIPRESENTATIONCONTROLSERVERLISTENER(mListener)
 
   explicit DisplayDeviceProviderWrappedListener() = default;
 
   nsresult SetListener(DisplayDeviceProvider* aListener)
   {
     mListener = aListener;
     return NS_OK;
   }
 
 private:
   virtual ~DisplayDeviceProviderWrappedListener() = default;
 
   DisplayDeviceProvider* mListener = nullptr;
 };
 
 NS_IMPL_ISUPPORTS(DisplayDeviceProviderWrappedListener,
-                  nsITCPPresentationServerListener)
+                  nsIPresentationControlServerListener)
 
 NS_IMPL_ISUPPORTS(DisplayDeviceProvider::HDMIDisplayDevice,
                   nsIPresentationDevice,
                   nsIPresentationLocalDevice)
 
 // nsIPresentationDevice
 NS_IMETHODIMP
 DisplayDeviceProvider::HDMIDisplayDevice::GetId(nsACString& aId)
@@ -176,17 +175,17 @@ DisplayDeviceProvider::HDMIDisplayDevice
   }
 
   return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(DisplayDeviceProvider,
                   nsIObserver,
                   nsIPresentationDeviceProvider,
-                  nsITCPPresentationServerListener)
+                  nsIPresentationControlServerListener)
 
 DisplayDeviceProvider::~DisplayDeviceProvider()
 {
   Uninit();
 }
 
 nsresult
 DisplayDeviceProvider::Init()
@@ -206,18 +205,18 @@ DisplayDeviceProvider::Init()
   mDevice = new HDMIDisplayDevice(this);
 
   mWrappedListener = new DisplayDeviceProviderWrappedListener();
   rv = mWrappedListener->SetListener(this);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  mPresentationServer = do_CreateInstance(TCP_PRESENTATION_SERVER_CONTACT_ID,
-                                          &rv);
+  mPresentationService = do_CreateInstance(PRESENTATION_CONTROL_SERVICE_CONTACT_ID,
+                                           &rv);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = StartTCPService();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -248,43 +247,43 @@ DisplayDeviceProvider::Uninit()
 }
 
 nsresult
 DisplayDeviceProvider::StartTCPService()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsresult rv;
-  rv =  mPresentationServer->SetId(NS_LITERAL_CSTRING("DisplayDeviceProvider"));
+  rv =  mPresentationService->SetId(NS_LITERAL_CSTRING("DisplayDeviceProvider"));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   uint16_t servicePort;
-  rv = mPresentationServer->GetPort(&servicePort);
+  rv = mPresentationService->GetPort(&servicePort);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   /*
    * If |servicePort| is non-zero, it means PresentationServer is running.
    * Otherwise, we should make it start serving.
    */
   if (!servicePort) {
-    rv = mPresentationServer->SetListener(mWrappedListener);
+    rv = mPresentationService->SetListener(mWrappedListener);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = mPresentationServer->StartService(0);
+    rv = mPresentationService->StartServer(0);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = mPresentationServer->GetPort(&servicePort);
+    rv = mPresentationService->GetPort(&servicePort);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   mPort = servicePort;
 
   return NS_OK;
@@ -363,17 +362,17 @@ DisplayDeviceProvider::SetListener(nsIPr
 }
 
 NS_IMETHODIMP
 DisplayDeviceProvider::ForceDiscovery()
 {
   return NS_OK;
 }
 
-// nsITCPPresentationServerListener
+// nsIPresentationControlServerListener
 NS_IMETHODIMP
 DisplayDeviceProvider::OnPortChange(uint16_t aPort)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mPort = aPort;
   return NS_OK;
 }
 
@@ -438,25 +437,25 @@ DisplayDeviceProvider::Observe(nsISuppor
 
 nsresult
 DisplayDeviceProvider::RequestSession(HDMIDisplayDevice* aDevice,
                                       const nsAString& aUrl,
                                       const nsAString& aPresentationId,
                                       nsIPresentationControlChannel** aControlChannel)
 {
   MOZ_ASSERT(aDevice);
-  MOZ_ASSERT(mPresentationServer);
+  MOZ_ASSERT(mPresentationService);
   NS_ENSURE_ARG_POINTER(aControlChannel);
   *aControlChannel = nullptr;
 
   nsCOMPtr<nsITCPDeviceInfo> deviceInfo = new TCPDeviceInfo(aDevice->Id(),
                                                             aDevice->Address(),
                                                             mPort);
 
-  return mPresentationServer->RequestSession(deviceInfo,
-                                             aUrl,
-                                             aPresentationId,
-                                             aControlChannel);
+  return mPresentationService->RequestSession(deviceInfo,
+                                              aUrl,
+                                              aPresentationId,
+                                              aControlChannel);
 }
 
 } // namespace presentation
 } // namespace dom
 } // namespace mozilla

--- a/dom/presentation/provider/DisplayDeviceProvider.h
+++ b/dom/presentation/provider/DisplayDeviceProvider.h
@@ -10,17 +10,17 @@
 #include "mozilla/RefPtr.h"
 #include "mozilla/WeakPtr.h"
 #include "nsCOMPtr.h"
 #include "nsIDOMWindow.h"
 #include "nsIDisplayInfo.h"
 #include "nsIObserver.h"
 #include "nsIPresentationDeviceProvider.h"
 #include "nsIPresentationLocalDevice.h"
-#include "nsITCPPresentationServer.h"
+#include "nsIPresentationControlService.h"
 #include "nsIWindowWatcher.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "nsWeakReference.h"
 
 namespace mozilla {
 namespace dom {
 namespace presentation {
@@ -33,17 +33,17 @@ enum DisplayType {
     DISPLAY_VIRTUAL,
     NUM_DISPLAY_TYPES
 };
 
 class DisplayDeviceProviderWrappedListener;
 
 class DisplayDeviceProvider final : public nsIObserver
                                   , public nsIPresentationDeviceProvider
-                                  , public nsITCPPresentationServerListener
+                                  , public nsIPresentationControlServerListener
                                   , public SupportsWeakPtr<DisplayDeviceProvider>
 {
 private:
   class HDMIDisplayDevice final : public nsIPresentationLocalDevice
   {
   public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIPRESENTATIONDEVICE
@@ -84,17 +84,17 @@ private:
     // the reference cycle.
     WeakPtr<DisplayDeviceProvider> mProvider;
   };
 
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
   NS_DECL_NSIPRESENTATIONDEVICEPROVIDER
-  NS_DECL_NSITCPPRESENTATIONSERVERLISTENER
+  NS_DECL_NSIPRESENTATIONCONTROLSERVERLISTENER
   // For using WeakPtr when MOZ_REFCOUNTED_LEAK_CHECKING defined
   MOZ_DECLARE_WEAKREFERENCE_TYPENAME(DisplayDeviceProvider)
 
   nsresult RequestSession(HDMIDisplayDevice* aDevice,
                           const nsAString& aUrl,
                           const nsAString& aPresentationId,
                           nsIPresentationControlChannel** aControlChannel);
 private:
@@ -109,17 +109,17 @@ private:
   nsresult StartTCPService();
 
   // Now support HDMI display only and there should be only one HDMI display.
   nsCOMPtr<nsIPresentationLocalDevice> mDevice = nullptr;
   // weak pointer
   // PresentationDeviceManager (mDeviceListener) hold strong pointer to
   // DisplayDeviceProvider. Use nsWeakPtr to avoid reference cycle.
   nsWeakPtr mDeviceListener = nullptr;
-  nsCOMPtr<nsITCPPresentationServer> mPresentationServer;
+  nsCOMPtr<nsIPresentationControlService> mPresentationService;
   // Used to prevent reference cycle between DisplayDeviceProvider and
   // TCPPresentationServer.
   RefPtr<DisplayDeviceProviderWrappedListener> mWrappedListener;
 
   bool mInitialized = false;
   uint16_t mPort;
 };
 

--- a/dom/presentation/provider/MulticastDNSDeviceProvider.cpp
+++ b/dom/presentation/provider/MulticastDNSDeviceProvider.cpp
@@ -64,24 +64,24 @@ GetAndroidDeviceName(nsACString& aRetVal
 
 /**
  * This wrapper is used to break circular-reference problem.
  */
 class DNSServiceWrappedListener final
   : public nsIDNSServiceDiscoveryListener
   , public nsIDNSRegistrationListener
   , public nsIDNSServiceResolveListener
-  , public nsITCPPresentationServerListener
+  , public nsIPresentationControlServerListener
 {
 public:
   NS_DECL_ISUPPORTS
   NS_FORWARD_SAFE_NSIDNSSERVICEDISCOVERYLISTENER(mListener)
   NS_FORWARD_SAFE_NSIDNSREGISTRATIONLISTENER(mListener)
   NS_FORWARD_SAFE_NSIDNSSERVICERESOLVELISTENER(mListener)
-  NS_FORWARD_SAFE_NSITCPPRESENTATIONSERVERLISTENER(mListener)
+  NS_FORWARD_SAFE_NSIPRESENTATIONCONTROLSERVERLISTENER(mListener)
 
   explicit DNSServiceWrappedListener() = default;
 
   nsresult SetListener(MulticastDNSDeviceProvider* aListener)
   {
     mListener = aListener;
     return NS_OK;
   }
@@ -91,24 +91,24 @@ private:
 
   MulticastDNSDeviceProvider* mListener = nullptr;
 };
 
 NS_IMPL_ISUPPORTS(DNSServiceWrappedListener,
                   nsIDNSServiceDiscoveryListener,
                   nsIDNSRegistrationListener,
                   nsIDNSServiceResolveListener,
-                  nsITCPPresentationServerListener)
+                  nsIPresentationControlServerListener)
 
 NS_IMPL_ISUPPORTS(MulticastDNSDeviceProvider,
                   nsIPresentationDeviceProvider,
                   nsIDNSServiceDiscoveryListener,
                   nsIDNSRegistrationListener,
                   nsIDNSServiceResolveListener,
-                  nsITCPPresentationServerListener,
+                  nsIPresentationControlServerListener,
                   nsIObserver)
 
 MulticastDNSDeviceProvider::~MulticastDNSDeviceProvider()
 {
   Uninit();
 }
 
 nsresult
@@ -127,17 +127,17 @@ MulticastDNSDeviceProvider::Init()
     return rv;
   }
 
   mWrappedListener = new DNSServiceWrappedListener();
   if (NS_WARN_IF(NS_FAILED(rv = mWrappedListener->SetListener(this)))) {
     return rv;
   }
 
-  mPresentationServer = do_CreateInstance(TCP_PRESENTATION_SERVER_CONTACT_ID, &rv);
+  mPresentationService = do_CreateInstance(PRESENTATION_CONTROL_SERVICE_CONTACT_ID, &rv);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   mDiscoveryTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -152,17 +152,17 @@ MulticastDNSDeviceProvider::Init()
 #ifdef MOZ_WIDGET_ANDROID
   // FIXME: Bug 1185806 - Provide a common device name setting.
   if (mServiceName.IsEmpty()) {
     GetAndroidDeviceName(mServiceName);
     Unused << Preferences::SetCString(PREF_PRESENTATION_DEVICE_NAME, mServiceName);
   }
 #endif // MOZ_WIDGET_ANDROID
 
-  Unused << mPresentationServer->SetId(mServiceName);
+  Unused << mPresentationService->SetId(mServiceName);
 
   if (mDiscoveryEnabled && NS_WARN_IF(NS_FAILED(rv = ForceDiscovery()))) {
     return rv;
   }
 
   if (mDiscoverable && NS_WARN_IF(NS_FAILED(rv = RegisterService()))) {
     return rv;
   }
@@ -206,32 +206,32 @@ MulticastDNSDeviceProvider::RegisterServ
 
   if (!mDiscoverable) {
     return NS_OK;
   }
 
   nsresult rv;
 
   uint16_t servicePort;
-  if (NS_WARN_IF(NS_FAILED(rv = mPresentationServer->GetPort(&servicePort)))) {
+  if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->GetPort(&servicePort)))) {
     return rv;
   }
 
   /**
     * If |servicePort| is non-zero, it means PresentationServer is running.
     * Otherwise, we should make it start serving.
     */
   if (!servicePort) {
-    if (NS_WARN_IF(NS_FAILED(rv = mPresentationServer->SetListener(mWrappedListener)))) {
+    if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->SetListener(mWrappedListener)))) {
       return rv;
     }
-    if (NS_WARN_IF(NS_FAILED(rv = mPresentationServer->StartService(0)))) {
+    if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->StartServer(0)))) {
       return rv;
     }
-    if (NS_WARN_IF(NS_FAILED(rv = mPresentationServer->GetPort(&servicePort)))) {
+    if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->GetPort(&servicePort)))) {
       return rv;
     }
   }
 
   // Cancel on going service registration.
   if (mRegisterRequest) {
     mRegisterRequest->Cancel(NS_OK);
     mRegisterRequest = nullptr;
@@ -266,19 +266,19 @@ MulticastDNSDeviceProvider::UnregisterSe
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (mRegisterRequest) {
     mRegisterRequest->Cancel(aReason);
     mRegisterRequest = nullptr;
   }
 
-  if (mPresentationServer) {
-    mPresentationServer->SetListener(nullptr);
-    mPresentationServer->Close();
+  if (mPresentationService) {
+    mPresentationService->SetListener(nullptr);
+    mPresentationService->Close();
   }
 
   return NS_OK;
 }
 
 nsresult
 MulticastDNSDeviceProvider::StopDiscovery(nsresult aReason)
 {
@@ -299,34 +299,34 @@ MulticastDNSDeviceProvider::StopDiscover
 
 nsresult
 MulticastDNSDeviceProvider::RequestSession(Device* aDevice,
                                            const nsAString& aUrl,
                                            const nsAString& aPresentationId,
                                            nsIPresentationControlChannel** aRetVal)
 {
   MOZ_ASSERT(aDevice);
-  MOZ_ASSERT(mPresentationServer);
+  MOZ_ASSERT(mPresentationService);
 
   RefPtr<TCPDeviceInfo> deviceInfo = new TCPDeviceInfo(aDevice->Id(),
                                                        aDevice->Address(),
                                                        aDevice->Port());
 
-  return mPresentationServer->RequestSession(deviceInfo, aUrl, aPresentationId, aRetVal);
+  return mPresentationService->RequestSession(deviceInfo, aUrl, aPresentationId, aRetVal);
 }
 
 nsresult
 MulticastDNSDeviceProvider::AddDevice(const nsACString& aId,
                                       const nsACString& aServiceName,
                                       const nsACString& aServiceType,
                                       const nsACString& aAddress,
                                       const uint16_t aPort)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(mPresentationServer);
+  MOZ_ASSERT(mPresentationService);
 
   RefPtr<Device> device = new Device(aId, /* ID */
                                      aServiceName,
                                      aServiceType,
                                      aAddress,
                                      aPort,
                                      DeviceState::eActive,
                                      this);
@@ -344,17 +344,17 @@ MulticastDNSDeviceProvider::AddDevice(co
 nsresult
 MulticastDNSDeviceProvider::UpdateDevice(const uint32_t aIndex,
                                          const nsACString& aServiceName,
                                          const nsACString& aServiceType,
                                          const nsACString& aAddress,
                                          const uint16_t aPort)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(mPresentationServer);
+  MOZ_ASSERT(mPresentationService);
 
   if (NS_WARN_IF(aIndex >= mDevices.Length())) {
     return NS_ERROR_INVALID_ARG;
   }
 
   RefPtr<Device> device = mDevices[aIndex];
   device->Update(aServiceName, aServiceType, aAddress, aPort);
   device->ChangeState(DeviceState::eActive);
@@ -366,17 +366,17 @@ MulticastDNSDeviceProvider::UpdateDevice
 
   return NS_OK;
 }
 
 nsresult
 MulticastDNSDeviceProvider::RemoveDevice(const uint32_t aIndex)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(mPresentationServer);
+  MOZ_ASSERT(mPresentationService);
 
   if (NS_WARN_IF(aIndex >= mDevices.Length())) {
     return NS_ERROR_INVALID_ARG;
   }
 
   RefPtr<Device> device = mDevices[aIndex];
 
   LOG_I("RemoveDevice: %s", device->Id().get());
@@ -759,17 +759,17 @@ MulticastDNSDeviceProvider::OnServiceRes
   nsAutoCString host;
   if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetHost(host)))) {
     return rv;
   }
 
   if (mRegisteredName == serviceName) {
     LOG_I("ignore self");
 
-    if (NS_WARN_IF(NS_FAILED(rv = mPresentationServer->SetId(host)))) {
+    if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->SetId(host)))) {
       return rv;
     }
 
     return NS_OK;
   }
 
   nsAutoCString address;
   if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetAddress(address)))) {
@@ -809,17 +809,17 @@ MulticastDNSDeviceProvider::OnResolveFai
                                             int32_t aErrorCode)
 {
   LOG_E("OnResolveFailed: %d", aErrorCode);
   MOZ_ASSERT(NS_IsMainThread());
 
   return NS_OK;
 }
 
-// nsITCPPresentationServerListener
+// nsIPresentationControlServerListener
 NS_IMETHODIMP
 MulticastDNSDeviceProvider::OnPortChange(uint16_t aPort)
 {
   LOG_I("OnPortChange: %d", aPort);
   MOZ_ASSERT(NS_IsMainThread());
 
   if (mDiscoverable) {
     RegisterService();

--- a/dom/presentation/provider/MulticastDNSDeviceProvider.h
+++ b/dom/presentation/provider/MulticastDNSDeviceProvider.h
@@ -8,17 +8,17 @@
 
 #include "mozilla/RefPtr.h"
 #include "nsCOMPtr.h"
 #include "nsICancelable.h"
 #include "nsIDNSServiceDiscovery.h"
 #include "nsIObserver.h"
 #include "nsIPresentationDevice.h"
 #include "nsIPresentationDeviceProvider.h"
-#include "nsITCPPresentationServer.h"
+#include "nsIPresentationControlService.h"
 #include "nsITimer.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "nsWeakPtr.h"
 
 namespace mozilla {
 namespace dom {
 namespace presentation {
@@ -26,26 +26,26 @@ namespace presentation {
 class DNSServiceWrappedListener;
 class MulticastDNSService;
 
 class MulticastDNSDeviceProvider final
   : public nsIPresentationDeviceProvider
   , public nsIDNSServiceDiscoveryListener
   , public nsIDNSRegistrationListener
   , public nsIDNSServiceResolveListener
-  , public nsITCPPresentationServerListener
+  , public nsIPresentationControlServerListener
   , public nsIObserver
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIPRESENTATIONDEVICEPROVIDER
   NS_DECL_NSIDNSSERVICEDISCOVERYLISTENER
   NS_DECL_NSIDNSREGISTRATIONLISTENER
   NS_DECL_NSIDNSSERVICERESOLVELISTENER
-  NS_DECL_NSITCPPRESENTATIONSERVERLISTENER
+  NS_DECL_NSIPRESENTATIONCONTROLSERVERLISTENER
   NS_DECL_NSIOBSERVER
 
   explicit MulticastDNSDeviceProvider() = default;
   nsresult Init();
   nsresult Uninit();
 
 private:
   enum class DeviceState : uint32_t {
@@ -170,17 +170,17 @@ private:
   // preferences
   nsresult OnDiscoveryChanged(bool aEnabled);
   nsresult OnDiscoveryTimeoutChanged(uint32_t aTimeoutMs);
   nsresult OnDiscoverableChanged(bool aEnabled);
   nsresult OnServiceNameChanged(const nsACString& aServiceName);
 
   bool mInitialized = false;
   nsWeakPtr mDeviceListener;
-  nsCOMPtr<nsITCPPresentationServer> mPresentationServer;
+  nsCOMPtr<nsIPresentationControlService> mPresentationService;
   nsCOMPtr<nsIDNSServiceDiscovery> mMulticastDNS;
   RefPtr<DNSServiceWrappedListener> mWrappedListener;
 
   nsCOMPtr<nsICancelable> mDiscoveryRequest;
   nsCOMPtr<nsICancelable> mRegisterRequest;
 
   nsTArray<RefPtr<Device>> mDevices;
 

rename from dom/presentation/provider/TCPPresentationServer.js
rename to dom/presentation/provider/PresentationControlService.js
--- a/dom/presentation/provider/TCPPresentationServer.js
+++ b/dom/presentation/provider/PresentationControlService.js
@@ -6,71 +6,71 @@
 const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/NetUtil.jsm");
 
 const DEBUG = Services.prefs.getBoolPref("dom.presentation.tcp_server.debug");
 function log(aMsg) {
-  dump("-*- TCPPresentationServer.js: " + aMsg + "\n");
+  dump("-*- PresentationControlService.js: " + aMsg + "\n");
 }
 
 function TCPDeviceInfo(aAddress, aPort, aId) {
   this.address = aAddress;
   this.port = aPort;
   this.id = aId;
 }
 
-function TCPPresentationServer() {
+function PresentationControlService() {
   this._id = null;
   this._port = 0;
   this._serverSocket = null;
 }
 
-TCPPresentationServer.prototype = {
+PresentationControlService.prototype = {
   /**
    * If a user agent connects to this server, we create a control channel but
    * hand it to |TCPDevice.listener| when the initial information exchange
    * finishes. Therefore, we hold the control channels in this period.
    */
   _controlChannels: [],
 
-  startService: function(aPort) {
+  startServer: function(aPort) {
     if (this._isServiceInit()) {
-      DEBUG && log("TCPPresentationServer - server socket has been initialized");
+      DEBUG && log("PresentationControlService - server socket has been initialized");
       throw Cr.NS_ERROR_FAILURE;
     }
 
     /**
      * 0 or undefined indicates opt-out parameter, and a port will be selected
      * automatically.
      */
     let serverSocketPort = (typeof aPort !== "undefined" && aPort !== 0) ? aPort : -1;
 
     this._serverSocket = Cc["@mozilla.org/network/server-socket;1"]
                          .createInstance(Ci.nsIServerSocket);
 
     if (!this._serverSocket) {
-      DEBUG && log("TCPPresentationServer - create server socket fail.");
+      DEBUG && log("PresentationControlService - create server socket fail.");
       throw Cr.NS_ERROR_FAILURE;
     }
 
     try {
       this._serverSocket.init(serverSocketPort, false, -1);
       this._serverSocket.asyncListen(this);
     } catch (e) {
       // NS_ERROR_SOCKET_ADDRESS_IN_USE
-      DEBUG && log("TCPPresentationServer - init server socket fail: " + e);
+      DEBUG && log("PresentationControlService - init server socket fail: " + e);
       throw Cr.NS_ERROR_FAILURE;
     }
 
     this._port = this._serverSocket.port;
 
-    DEBUG && log("TCPPresentationServer - service start on port: " + this._port);
+    DEBUG && log("PresentationControlService - service start on port: " + this._port);
 
     // Monitor network interface change to restart server socket.
     // Only B2G has nsINetworkManager
     Services.obs.addObserver(this, "network-active-changed", false);
     Services.obs.addObserver(this, "network:offline-status-changed", false);
   },
 
   get id() {
@@ -94,76 +94,76 @@ TCPPresentationServer.prototype = {
   },
 
   _isServiceInit: function() {
     return this._serverSocket !== null;
   },
 
   requestSession: function(aDeviceInfo, aUrl, aPresentationId) {
     if (!this.id) {
-      DEBUG && log("TCPPresentationServer - Id has not initialized; requestSession fails");
+      DEBUG && log("PresentationControlService - Id has not initialized; requestSession fails");
       return null;
     }
-    DEBUG && log("TCPPresentationServer - requestSession to " + aDeviceInfo.id
+    DEBUG && log("PresentationControlService - requestSession to " + aDeviceInfo.id
                  + ": " + aUrl + ", " + aPresentationId);
 
     let sts = Cc["@mozilla.org/network/socket-transport-service;1"]
                 .getService(Ci.nsISocketTransportService)
 
     let socketTransport;
     try {
       socketTransport = sts.createTransport(null,
                                             0,
                                             aDeviceInfo.address,
                                             aDeviceInfo.port,
                                             null);
     } catch (e) {
-      DEBUG && log("TCPPresentationServer - createTransport throws: " + e);
+      DEBUG && log("PresentationControlService - createTransport throws: " + e);
       // Pop the exception to |TCPDevice.establishControlChannel|
       throw Cr.NS_ERROR_FAILURE;
     }
     return new TCPControlChannel(this,
                                  socketTransport,
                                  aDeviceInfo,
                                  aPresentationId,
                                  "sender",
                                  aUrl);
   },
 
   responseSession: function(aDeviceInfo, aSocketTransport) {
     if (!this._isServiceInit()) {
-      DEBUG && log("TCPPresentationServer - should never receive remote " +
+      DEBUG && log("PresentationControlService - should never receive remote " +
                    "session request before server socket initialization");
       return null;
     }
-    DEBUG && log("TCPPresentationServer - responseSession to "
+    DEBUG && log("PresentationControlService - responseSession to "
                  + JSON.stringify(aDeviceInfo));
     return new TCPControlChannel(this,
                                  aSocketTransport,
                                  aDeviceInfo,
                                  null, // presentation ID
                                  "receiver",
                                  null // url
                                  );
   },
 
   // Triggered by TCPControlChannel
   onSessionRequest: function(aDeviceInfo, aUrl, aPresentationId, aControlChannel) {
-    DEBUG && log("TCPPresentationServer - onSessionRequest: "
+    DEBUG && log("PresentationControlService - onSessionRequest: "
                  + aDeviceInfo.address + ":" + aDeviceInfo.port);
     this.listener.onSessionRequest(aDeviceInfo,
                                    aUrl,
                                    aPresentationId,
                                    aControlChannel);
     this.releaseControlChannel(aControlChannel);
   },
 
   // nsIServerSocketListener (Triggered by nsIServerSocket.init)
   onSocketAccepted: function(aServerSocket, aClientSocket) {
-    DEBUG && log("TCPPresentationServer - onSocketAccepted: "
+    DEBUG && log("PresentationControlService - onSocketAccepted: "
                  + aClientSocket.host + ":" + aClientSocket.port);
     let deviceInfo = new TCPDeviceInfo(aClientSocket.host, aClientSocket.port);
     this.holdControlChannel(this.responseSession(deviceInfo, aClientSocket));
   },
 
   holdControlChannel: function(aControlChannel) {
     this._controlChannels.push(aControlChannel);
   },
@@ -172,84 +172,84 @@ TCPPresentationServer.prototype = {
     let index = this._controlChannels.indexOf(aControlChannel);
     if (index !== -1) {
       delete this._controlChannels[index];
     }
   },
 
   // nsIServerSocketListener (Triggered by nsIServerSocket.init)
   onStopListening: function(aServerSocket, aStatus) {
-    DEBUG && log("TCPPresentationServer - onStopListening: " + aStatus);
+    DEBUG && log("PresentationControlService - onStopListening: " + aStatus);
   },
 
   close: function() {
-    DEBUG && log("TCPPresentationServer - close");
+    DEBUG && log("PresentationControlService - close");
     if (this._isServiceInit()) {
-      DEBUG && log("TCPPresentationServer - close server socket");
+      DEBUG && log("PresentationControlService - close server socket");
       this._serverSocket.close();
       this._serverSocket = null;
 
       Services.obs.removeObserver(this, "network-active-changed");
       Services.obs.removeObserver(this, "network:offline-status-changed");
     }
     this._port = 0;
   },
 
   // nsIObserver
   observe: function(aSubject, aTopic, aData) {
-    DEBUG && log("TCPPresentationServer - observe: " + aTopic);
+    DEBUG && log("PresentationControlService - observe: " + aTopic);
     switch (aTopic) {
       case "network-active-changed": {
         if (!aSubject) {
           DEBUG && log("No active network");
           return;
         }
 
         /**
          * Restart service only when original status is online because other
          * cases will be handled by "network:offline-status-changed".
          */
         if (!Services.io.offline) {
-          this._restartService();
+          this._restartServer();
         }
         break;
       }
       case "network:offline-status-changed": {
         if (aData == "offline") {
           DEBUG && log("network offline");
           return;
         }
-        this._restartService();
+        this._restartServer();
         break;
       }
     }
   },
 
-  _restartService: function() {
-    DEBUG && log("TCPPresentationServer - restart service");
+  _restartServer: function() {
+    DEBUG && log("PresentationControlService - restart service");
 
     // restart server socket
     if (this._isServiceInit()) {
       let port = this._port;
       this.close();
 
       try {
-        this.startService();
+        this.startServer();
         if (this._listener && this._port !== port) {
            this._listener.onPortChange(this._port);
         }
       } catch (e) {
-        DEBUG && log("TCPPresentationServer - restart service fail: " + e);
+        DEBUG && log("PresentationControlService - restart service fail: " + e);
       }
     }
   },
 
   classID: Components.ID("{f4079b8b-ede5-4b90-a112-5b415a931deb}"),
   QueryInterface : XPCOMUtils.generateQI([Ci.nsIServerSocketListener,
-                                          Ci.nsITCPPresentationServer,
+                                          Ci.nsIPresentationControlService,
                                           Ci.nsIObserver]),
 };
 
 function ChannelDescription(aInit) {
   this._type = aInit.type;
   switch (this._type) {
     case Ci.nsIPresentationChannelDescription.TYPE_TCP:
       this._tcpAddresses = Cc["@mozilla.org/array;1"]
@@ -311,31 +311,31 @@ function discriptionAsJson(aDescription)
       break;
     case Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL:
       json.dataChannelSDP = aDescription.dataChannelSDP;
       break;
   }
   return json;
 }
 
-function TCPControlChannel(presentationServer,
+function TCPControlChannel(presentationService,
                            transport,
                            deviceInfo,
                            presentationId,
                            direction,
                            url) {
   DEBUG && log("create TCPControlChannel: " + presentationId + " with role: "
                + direction);
   this._deviceInfo = deviceInfo;
   this._presentationId = presentationId;
   this._direction = direction;
   this._transport = transport;
   this._url = url;
 
-  this._presentationServer =  presentationServer;
+  this._presentationService =  presentationService;
 
   let currentThread = Services.tm.currentThread;
   transport.setEventSink(this, currentThread);
 
   this._input = this._transport.openInputStream(0, 0, 0)
                                .QueryInterface(Ci.nsIAsyncInputStream);
   this._input.asyncWait(this.QueryInterface(Ci.nsIStreamListener),
                         Ci.nsIAsyncInputStream.WAIT_CLOSURE_ONLY,
@@ -385,17 +385,17 @@ TCPControlChannel.prototype = {
     this._sendingMessageType = aType;
   },
 
   _sendInit: function() {
     let msg = {
       type: "requestSession:Init",
       presentationId: this._presentationId,
       url: this._url,
-      id: this._presentationServer.id,
+      id: this._presentationService.id,
     };
 
     this._sendMessage("init", msg, function(e) {
       this.close();
       this._notifyClosed(e.result);
     });
   },
 
@@ -527,20 +527,20 @@ TCPControlChannel.prototype = {
   _handleMessage: function(aMsg) {
     DEBUG && log("TCPControlChannel - handleMessage from "
                  + JSON.stringify(this._deviceInfo) + ": " + JSON.stringify(aMsg));
     switch (aMsg.type) {
       case "requestSession:Init": {
         this._deviceInfo.id = aMsg.id;
         this._url = aMsg.url;
         this._presentationId = aMsg.presentationId;
-        this._presentationServer.onSessionRequest(this._deviceInfo,
-                                                  aMsg.url,
-                                                  aMsg.presentationId,
-                                                  this);
+        this._presentationService.onSessionRequest(this._deviceInfo,
+                                                   aMsg.url,
+                                                   aMsg.presentationId,
+                                                   this);
         this._notifyOpened();
         break;
       }
       case "requestSession:Offer": {
         this._onOffer(aMsg.offer);
         break;
       }
       case "requestSession:Answer": {
@@ -681,20 +681,20 @@ TCPControlChannel.prototype = {
         this._pendingCloseReason = aReason;
       }
 
       this._transport.setEventSink(null, null);
       this._pump = null;
 
       this._input.close();
       this._output.close();
-      this._presentationServer.releaseControlChannel(this);
+      this._presentationService.releaseControlChannel(this);
 
       this._connected = false;
     }
   },
 
   classID: Components.ID("{fefb8286-0bdc-488b-98bf-0c11b485c955}"),
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannel,
                                          Ci.nsIStreamListener]),
 };
 
-this.NSGetFactory = XPCOMUtils.generateNSGetFactory([TCPPresentationServer]);
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([PresentationControlService]);

--- a/dom/presentation/provider/moz.build
+++ b/dom/presentation/provider/moz.build
@@ -1,17 +1,17 @@
 # -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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/.
 
 EXTRA_COMPONENTS += [
     'BuiltinProviders.manifest',
-    'TCPPresentationServer.js'
+    'PresentationControlService.js'
 ]
 
 UNIFIED_SOURCES += [
     'DisplayDeviceProvider.cpp',
     'MulticastDNSDeviceProvider.cpp',
     'PresentationDeviceProviderModule.cpp',
 ]
 

--- a/dom/presentation/tests/xpcshell/test_multicast_dns_device_provider.js
+++ b/dom/presentation/tests/xpcshell/test_multicast_dns_device_provider.js
@@ -9,17 +9,17 @@ const { classes: Cc, interfaces: Ci, man
 
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
 const INFO_CONTRACT_ID = "@mozilla.org/toolkit/components/mdnsresponder/dns-info;1";
 const PROVIDER_CONTRACT_ID = "@mozilla.org/presentation-device/multicastdns-provider;1";
 const SD_CONTRACT_ID = "@mozilla.org/toolkit/components/mdnsresponder/dns-sd;1";
 const UUID_CONTRACT_ID = "@mozilla.org/uuid-generator;1";
-const SERVER_CONTRACT_ID = "@mozilla.org/presentation-device/tcp-presentation-server;1";
+const SERVER_CONTRACT_ID = "@mozilla.org/presentation/control-service;1";
 
 const PREF_DISCOVERY = "dom.presentation.discovery.enabled";
 const PREF_DISCOVERABLE = "dom.presentation.discoverable";
 const PREF_DEVICENAME= "dom.presentation.device.name";
 
 var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
 
 function MockFactory(aClass) {
@@ -412,17 +412,17 @@ function handleSessionRequest() {
       listener.onServiceResolved(createDevice(mockDevice.host,
                                               mockDevice.port,
                                               mockDevice.serviceName,
                                               mockDevice.serviceType));
     }
   };
 
   let mockServerObj = {
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPPresentationServer]),
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlService]),
     requestSession: function(deviceInfo, url, presentationId) {
       this.request = {
         deviceInfo: deviceInfo,
         url: url,
         presentationId: presentationId,
       };
       return {
         QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannel]),
@@ -484,18 +484,18 @@ function handleOnSessionRequest() {
       listener.onServiceResolved(createDevice(mockDevice.host,
                                               mockDevice.port,
                                               mockDevice.serviceName,
                                               mockDevice.serviceType));
     }
   };
 
   let mockServerObj = {
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPPresentationServer]),
-    startService: function() {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlService]),
+    startServer: function() {},
     sessionRequest: function() {},
     close: function() {},
     id: '',
     port: 0,
     listener: null,
   };
 
   let contractHookSD = new ContractHook(SD_CONTRACT_ID, mockSDObj);
@@ -526,17 +526,17 @@ function handleOnSessionRequest() {
     port: 54321,
   };
 
   const testUrl = "http://example.com";
   const testPresentationId = "test-presentation-id";
   const testControlChannel = {
     QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannel]),
   };
-  provider.QueryInterface(Ci.nsITCPPresentationServerListener)
+  provider.QueryInterface(Ci.nsIPresentationControlServerListener)
           .onSessionRequest(deviceInfo, testUrl, testPresentationId, testControlChannel);
 
   Assert.equal(listener.request.deviceId, deviceInfo.id);
   Assert.equal(listener.request.url, testUrl);
   Assert.equal(listener.request.presentationId, testPresentationId);
 
   provider.listener = null;
 
@@ -550,18 +550,18 @@ function handleOnSessionRequestFromUnkno
   let mockSDObj = {
     QueryInterface: XPCOMUtils.generateQI([Ci.nsIDNSServiceDiscovery]),
     startDiscovery: function(serviceType, listener) {},
     registerService: function(serviceInfo, listener) {},
     resolveService: function(serviceInfo, listener) {}
   };
 
   let mockServerObj = {
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPPresentationServer]),
-    startService: function() {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlService]),
+    startServer: function() {},
     sessionRequest: function() {},
     close: function() {},
     id: '',
     port: 0,
     listener: null,
   };
 
   let contractHookSD = new ContractHook(SD_CONTRACT_ID, mockSDObj);
@@ -598,17 +598,17 @@ function handleOnSessionRequestFromUnkno
     port: 12345,
   };
 
   const testUrl = "http://example.com";
   const testPresentationId = "test-presentation-id";
   const testControlChannel = {
     QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannel]),
   };
-  provider.QueryInterface(Ci.nsITCPPresentationServerListener)
+  provider.QueryInterface(Ci.nsIPresentationControlServerListener)
           .onSessionRequest(deviceInfo, testUrl, testPresentationId, testControlChannel);
 
   Assert.equal(listener.request.deviceId, deviceInfo.id);
   Assert.equal(listener.request.url, testUrl);
   Assert.equal(listener.request.presentationId, testPresentationId);
 
   provider.listener = null;
 
@@ -682,18 +682,18 @@ function ignoreSelfDevice() {
       listener.onServiceResolved(createDevice(mockDevice.host,
                                               mockDevice.port,
                                               mockDevice.serviceName,
                                               mockDevice.serviceType));
     }
   };
 
   let mockServerObj = {
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPPresentationServer]),
-    startService: function() {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlService]),
+    startServer: function() {},
     sessionRequest: function() {},
     close: function() {},
     id: '',
     port: 0,
     listener: null,
   };
 
   let contractHookSD = new ContractHook(SD_CONTRACT_ID, mockSDObj);
@@ -996,17 +996,17 @@ function serverClosed() {
   };
   Assert.equal(listener.devices.length, 0);
 
   provider.listener = listener;
   Assert.equal(mockObj.serviceRegistered, 1);
   Assert.equal(mockObj.serviceUnregistered, 0);
   Assert.equal(listener.devices.length, 1);
 
-  let serverListener = provider.QueryInterface(Ci.nsITCPPresentationServerListener);
+  let serverListener = provider.QueryInterface(Ci.nsIPresentationControlServerListener);
   let randomPort = 9527;
   serverListener.onPortChange(randomPort);
 
   Assert.equal(mockObj.serviceRegistered, 2);
   Assert.equal(mockObj.serviceUnregistered, 1);
   Assert.equal(listener.devices.length, 1);
 
   // Unregister

--- a/dom/presentation/tests/xpcshell/test_tcp_control_channel.js
+++ b/dom/presentation/tests/xpcshell/test_tcp_control_channel.js
@@ -51,20 +51,20 @@ var candidate;
 const OFFER_ADDRESS = '192.168.123.123';
 const OFFER_PORT = 123;
 
 // controller's presentation channel description
 const ANSWER_ADDRESS = '192.168.321.321';
 const ANSWER_PORT = 321;
 
 function loopOfferAnser() {
-  tps = Cc["@mozilla.org/presentation-device/tcp-presentation-server;1"]
-        .createInstance(Ci.nsITCPPresentationServer);
+  tps = Cc["@mozilla.org/presentation/control-service;1"]
+        .createInstance(Ci.nsIPresentationControlService);
   tps.id = 'controllerID';
-  tps.startService(PRESENTER_CONTROL_CHANNEL_PORT);
+  tps.startServer(PRESENTER_CONTROL_CHANNEL_PORT);
 
   testPresentationServer();
 }
 
 
 function testPresentationServer() {
   let yayFuncs = makeJointSuccess(['controllerControlChannelClose',
                                    'presenterControlChannelClose']);
@@ -120,17 +120,17 @@ function testPresentationServer() {
           Assert.equal(aReason, CLOSE_CONTROL_CHANNEL_REASON, 'presenterControlChannel notify closed');
           this.status = 'closed';
           yayFuncs.controllerControlChannelClose();
         },
         QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannelListener]),
       };
     },
 
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPPresentationServerListener]),
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlServerListener]),
   };
 
   let presenterDeviceInfo = {
     id: 'presentatorID',
     address: '127.0.0.1',
     port: PRESENTER_CONTROL_CHANNEL_PORT,
     QueryInterface: XPCOMUtils.generateQI([Ci.nsITCPDeviceInfo]),
   };
@@ -193,17 +193,17 @@ function setOffline() {
 
   // Let the server socket restart automatically.
   Services.io.offline = true;
   Services.io.offline = false;
 }
 
 function oneMoreLoop() {
   try {
-    tps.startService(PRESENTER_CONTROL_CHANNEL_PORT);
+    tps.startServer(PRESENTER_CONTROL_CHANNEL_PORT);
     testPresentationServer();
   } catch (e) {
     Assert.ok(false, 'TCP presentation init fail:' + e);
     run_next_test();
   }
 }
 
 

--- a/mobile/android/installer/package-manifest.in
+++ b/mobile/android/installer/package-manifest.in
@@ -407,17 +407,17 @@
 @BINPATH@/components/nsAsyncShutdown.js
 
 @BINPATH@/components/Downloads.manifest
 @BINPATH@/components/DownloadLegacy.js
 
 @BINPATH@/components/PresentationDeviceInfoManager.manifest
 @BINPATH@/components/PresentationDeviceInfoManager.js
 @BINPATH@/components/BuiltinProviders.manifest
-@BINPATH@/components/TCPPresentationServer.js
+@BINPATH@/components/PresentationControlService.js
 @BINPATH@/components/PresentationNetworkHelper.js
 @BINPATH@/components/PresentationNetworkHelper.manifest
 @BINPATH@/components/PresentationDataChannelSessionTransport.js
 @BINPATH@/components/PresentationDataChannelSessionTransport.manifest
 
 @BINPATH@/components/PACGenerator.js
 @BINPATH@/components/PACGenerator.manifest
 
@@ -552,9 +552,9 @@
 @BINPATH@/components/MarionetteComponents.manifest
 @BINPATH@/components/marionettecomponent.js
 #endif
 
 #ifdef PKG_LOCALE_MANIFEST
 #include @PKG_LOCALE_MANIFEST@
 #endif
 
-@BINPATH@/components/dom_audiochannel.xpt
\ No newline at end of file
+@BINPATH@/components/dom_audiochannel.xpt