--- a/widget/android/AndroidBridge.cpp
+++ b/widget/android/AndroidBridge.cpp
@@ -868,43 +868,43 @@ NS_IMETHODIMP nsAndroidBridge::SetBrowse
     return NS_OK;
 }
 
 extern "C"
 __attribute__ ((visibility("default")))
 jobject JNICALL
 Java_org_mozilla_gecko_GeckoAppShell_allocateDirectBuffer(JNIEnv *env, jclass, jlong size);
 
-static jni::DependentRef<java::GeckoLayerClient>
-GetJavaLayerClient(mozIDOMWindowProxy* aWindow)
+static jni::DependentRef<java::LayerSession::Compositor>
+GetJavaCompositor(mozIDOMWindowProxy* aWindow)
 {
     MOZ_ASSERT(aWindow);
 
     nsCOMPtr<nsPIDOMWindowOuter> domWindow = nsPIDOMWindowOuter::From(aWindow);
     nsCOMPtr<nsIWidget> widget =
             widget::WidgetUtils::DOMWindowToWidget(domWindow);
     MOZ_ASSERT(widget);
 
-    return static_cast<nsWindow*>(widget.get())->GetLayerClient();
+    return static_cast<nsWindow*>(widget.get())->GetJavaCompositor();
 }
 
 void
 AndroidBridge::ContentDocumentChanged(mozIDOMWindowProxy* aWindow)
 {
-    auto layerClient = GetJavaLayerClient(aWindow);
+    auto layerClient = GetJavaCompositor(aWindow);
     if (!layerClient) {
         return;
     }
     layerClient->ContentDocumentChanged();
 }
 
 bool
 AndroidBridge::IsContentDocumentDisplayed(mozIDOMWindowProxy* aWindow)
 {
-    auto layerClient = GetJavaLayerClient(aWindow);
+    auto layerClient = GetJavaCompositor(aWindow);
     if (!layerClient) {
         return false;
     }
     return layerClient->IsContentDocumentDisplayed();
 }
 
 jni::Object::LocalRef AndroidBridge::ChannelCreate(jni::Object::Param stream) {
     JNIEnv* const env = jni::GetEnvForThread();

--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -431,16 +431,21 @@ public:
         if (!uiThread) {
             return;
         }
         uiThread->Dispatch(NewRunnableFunction(
                 static_cast<void(*)(const NPZCRef&)>(callDestroy),
                 mozilla::Move(npzc)), nsIThread::DISPATCH_NORMAL);
     }
 
+    const NativePanZoomController::Ref& GetJavaNPZC() const
+    {
+        return mNPZC;
+    }
+
 public:
     void SetIsLongpressEnabled(bool aIsLongpressEnabled)
     {
         RefPtr<IAPZCTreeManager> controller;
 
         if (LockedWindowPtr window{mWindow}) {
             controller = window->mAPZC;
         }
@@ -779,17 +784,16 @@ nsWindow::AndroidView::GetSettings(JSCon
  */
 class nsWindow::LayerViewSupport final
     : public LayerSession::Compositor::Natives<LayerViewSupport>
 {
     using LockedWindowPtr = WindowPtr<LayerViewSupport>::Locked;
 
     WindowPtr<LayerViewSupport> mWindow;
     LayerSession::Compositor::GlobalRef mCompositor;
-    GeckoLayerClient::GlobalRef mLayerClient;
     Atomic<bool, ReleaseAcquire> mCompositorPaused;
     jni::Object::GlobalRef mSurface;
 
     // In order to use Event::HasSameTypeAs in PostTo(), we cannot make
     // LayerViewEvent a template because each template instantiation is
     // a different type. So implement LayerViewEvent as a ProxyEvent.
     class LayerViewEvent final : public nsAppShell::ProxyEvent
     {
@@ -865,19 +869,19 @@ public:
             uiThread->Dispatch(NS_NewRunnableFunction(
                     "LayerViewSupport::OnDetach",
                     [compositor] {
                         compositor->OnCompositorDetached();
                     }));
         }
     }
 
-    const GeckoLayerClient::Ref& GetLayerClient() const
+    const LayerSession::Compositor::Ref& GetJavaCompositor() const
     {
-        return mLayerClient;
+        return mCompositor;
     }
 
     bool CompositorPaused() const
     {
         return mCompositorPaused;
     }
 
     jni::Object::Param GetSurface()
@@ -894,25 +898,23 @@ private:
         }
         return child.forget();
     }
 
     /**
      * Compositor methods
      */
 public:
-    void AttachToJava(jni::Object::Param aClient, jni::Object::Param aNPZC)
+    void AttachToJava(jni::Object::Param aNPZC)
     {
         MOZ_ASSERT(NS_IsMainThread());
         if (!mWindow) {
             return; // Already shut down.
         }
 
-        mLayerClient = GeckoLayerClient::Ref::From(aClient);
-
         MOZ_ASSERT(aNPZC);
         auto npzc = NativePanZoomController::LocalRef(
                 jni::GetGeckoThreadEnv(),
                 NativePanZoomController::Ref::From(aNPZC));
         mWindow->mNPZCSupport.Attach(npzc, mWindow, npzc);
 
         if (RefPtr<nsThread> uiThread = GetAndroidUiThread()) {
             LayerSession::Compositor::GlobalRef compositor(mCompositor);
@@ -2210,49 +2212,47 @@ nsWindow::SynthesizeNativeTouchPoint(uin
     case TOUCH_CANCEL:
         eventType = sdk::MotionEvent::ACTION_CANCEL;
         break;
     case TOUCH_HOVER:   // not supported for now
     default:
         return NS_ERROR_UNEXPECTED;
     }
 
-    MOZ_ASSERT(mLayerViewSupport);
-    GeckoLayerClient::LocalRef client = mLayerViewSupport->GetLayerClient();
-    client->SynthesizeNativeTouchPoint(aPointerId, eventType,
-        aPoint.x, aPoint.y, aPointerPressure, aPointerOrientation);
-
+    MOZ_ASSERT(mNPZCSupport);
+    const auto& npzc = mNPZCSupport->GetJavaNPZC();
+    npzc->SynthesizeNativeTouchPoint(aPointerId, eventType, aPoint.x, aPoint.y,
+                                     aPointerPressure, aPointerOrientation);
     return NS_OK;
 }
 
 nsresult
 nsWindow::SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
                                      uint32_t aNativeMessage,
                                      uint32_t aModifierFlags,
                                      nsIObserver* aObserver)
 {
     mozilla::widget::AutoObserverNotifier notifier(aObserver, "mouseevent");
 
-    MOZ_ASSERT(mLayerViewSupport);
-    GeckoLayerClient::LocalRef client = mLayerViewSupport->GetLayerClient();
-    client->SynthesizeNativeMouseEvent(aNativeMessage, aPoint.x, aPoint.y);
-
+    MOZ_ASSERT(mNPZCSupport);
+    const auto& npzc = mNPZCSupport->GetJavaNPZC();
+    npzc->SynthesizeNativeMouseEvent(aNativeMessage, aPoint.x, aPoint.y);
     return NS_OK;
 }
 
 nsresult
 nsWindow::SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
                                     nsIObserver* aObserver)
 {
     mozilla::widget::AutoObserverNotifier notifier(aObserver, "mouseevent");
 
-    MOZ_ASSERT(mLayerViewSupport);
-    GeckoLayerClient::LocalRef client = mLayerViewSupport->GetLayerClient();
-    client->SynthesizeNativeMouseEvent(sdk::MotionEvent::ACTION_HOVER_MOVE, aPoint.x, aPoint.y);
-
+    MOZ_ASSERT(mNPZCSupport);
+    const auto& npzc = mNPZCSupport->GetJavaNPZC();
+    npzc->SynthesizeNativeMouseEvent(sdk::MotionEvent::ACTION_HOVER_MOVE,
+                                     aPoint.x, aPoint.y);
     return NS_OK;
 }
 
 bool
 nsWindow::WidgetPaintsBackground()
 {
     static bool sWidgetPaintsBackground = true;
     static bool sWidgetPaintsBackgroundPrefCached = false;
@@ -2318,21 +2318,21 @@ nsWindow::GetWidgetScreen()
         do_GetService("@mozilla.org/gfx/screenmanager;1");
     MOZ_ASSERT(screenMgr, "Failed to get nsIScreenManager");
 
     RefPtr<nsScreenManagerAndroid> screenMgrAndroid =
         (nsScreenManagerAndroid*) screenMgr.get();
     return screenMgrAndroid->ScreenForId(mScreenId);
 }
 
-jni::DependentRef<java::GeckoLayerClient>
-nsWindow::GetLayerClient()
+jni::DependentRef<java::LayerSession::Compositor>
+nsWindow::GetJavaCompositor()
 {
     if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
-        return lvs->GetLayerClient().Get();
+        return lvs->GetJavaCompositor().Get();
     }
     return nullptr;
 }
 void
 nsWindow::RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage)
 {
     MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
     if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
@@ -2340,18 +2340,18 @@ nsWindow::RecvToolbarAnimatorMessageFrom
     }
 }
 
 void
 nsWindow::UpdateRootFrameMetrics(const ScreenPoint& aScrollOffset, const CSSToScreenScale& aZoom)
 {
   MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
   if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
-    GeckoLayerClient::LocalRef client = lvs->GetLayerClient();
-    client->UpdateRootFrameMetrics(aScrollOffset.x, aScrollOffset.y, aZoom.scale);
+    const auto& compositor = lvs->GetJavaCompositor();
+    compositor->UpdateRootFrameMetrics(aScrollOffset.x, aScrollOffset.y, aZoom.scale);
   }
 }
 
 void
 nsWindow::RecvScreenPixels(Shmem&& aMem, const ScreenIntSize& aSize)
 {
   MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
   if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {

--- a/widget/android/nsWindow.h
+++ b/widget/android/nsWindow.h
@@ -295,17 +295,17 @@ public:
                                         uint32_t aNativeMessage,
                                         uint32_t aModifierFlags,
                                         nsIObserver* aObserver) override;
     nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
                                        nsIObserver* aObserver) override;
 
     mozilla::layers::CompositorBridgeChild* GetCompositorBridgeChild() const;
 
-    mozilla::jni::DependentRef<mozilla::java::GeckoLayerClient> GetLayerClient();
+    mozilla::jni::DependentRef<mozilla::java::LayerSession::Compositor> GetJavaCompositor();
 
     // Call this function when the users activity is the direct cause of an
     // event (like a keypress or mouse click).
     void UserActivity();
 
     mozilla::java::GeckoEditable::Ref& GetEditableParent() { return mEditable; }
 
     void RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage) override;