--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -80,21 +80,24 @@ using mozilla::Unused;
 
 #include "imgIEncoder.h"
 
 #include "nsString.h"
 #include "GeckoProfiler.h" // For PROFILER_LABEL
 #include "nsIXULRuntime.h"
 #include "nsPrintfCString.h"
 
+#include "mozilla/ipc/Shmem.h"
+
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::layers;
 using namespace mozilla::java;
 using namespace mozilla::widget;
+using namespace mozilla::ipc;
 
 NS_IMPL_ISUPPORTS_INHERITED0(nsWindow, nsBaseWidget)
 
 #include "mozilla/layers/CompositorBridgeChild.h"
 #include "mozilla/layers/CompositorSession.h"
 #include "mozilla/layers/LayerTransactionParent.h"
 #include "mozilla/layers/UiCompositorControllerChild.h"
 #include "mozilla/Services.h"
@@ -754,21 +757,16 @@ public:
         mNPZC->UpdateOverscrollVelocity(x, y);
     }
 
     void UpdateOverscrollOffset(const float x, const float y)
     {
         mNPZC->UpdateOverscrollOffset(x, y);
     }
 
-    void SetScrollingRootContent(const bool isRootContent)
-    {
-        mNPZC->SetScrollingRootContent(isRootContent);
-    }
-
     void SetSelectionDragState(const bool aState)
     {
         mNPZC->OnSelectionDragState(aState);
     }
 };
 
 template<> const char
 nsWindow::NativePtr<nsWindow::NPZCSupport>::sName[] = "NPZCSupport";
@@ -966,77 +964,57 @@ public:
         mCompositorPaused = false;
         OnResumedCompositor();
     }
 
     void SyncPauseCompositor()
     {
         MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
 
-        int64_t id = 0;
+        RefPtr<UiCompositorControllerChild> child;
         if (LockedWindowPtr window{mWindow}) {
-            id = window->GetRootLayerId();
+            child = window->GetUiCompositorControllerChild();
         }
 
-        if (id == 0) {
-            return;
-        }
-
-        RefPtr<UiCompositorControllerChild> child = UiCompositorControllerChild::Get();
         if (child) {
           mCompositorPaused = true;
-          child->SendPause(id);
+          child->Pause();
         }
     }
 
     void SyncResumeCompositor()
     {
         MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
 
-        int64_t id = 0;
+        RefPtr<UiCompositorControllerChild> child;
         if (LockedWindowPtr window{mWindow}) {
-            id = window->GetRootLayerId();
+            child = window->GetUiCompositorControllerChild();
         }
 
-        if (id == 0) {
-            return;
-        }
-
-        RefPtr<UiCompositorControllerChild> child = UiCompositorControllerChild::Get();
         if (child) {
           mCompositorPaused = false;
-          child->SendResume(id);
+          child->Resume();
         }
     }
 
     void SyncResumeResizeCompositor(const LayerView::Compositor::LocalRef& aObj,
                                     int32_t aWidth, int32_t aHeight,
                                     jni::Object::Param aSurface)
     {
         MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
 
         mSurface = aSurface;
 
-        int64_t id = 0;
+        RefPtr<UiCompositorControllerChild> child;
         if (LockedWindowPtr window{mWindow}) {
-            id = window->GetRootLayerId();
-        }
-
-        if (id == 0) {
-            return;
+            child = window->GetUiCompositorControllerChild();
         }
 
-        RefPtr<UiCompositorControllerChild> child = UiCompositorControllerChild::Get();
-
-        if (!child) {
-            // When starting, sometimes the UiCompositorControllerChild is still initializing
-            // so cache the resized surface dimensions until it has initialized.
-            UiCompositorControllerChild::CacheSurfaceResize(id, aWidth, aHeight);
-        } else {
-            child->SendResumeAndResize(id, aWidth, aHeight);
+        if (child) {
+            child->ResumeAndResize(aWidth, aHeight);
         }
 
         mCompositorPaused = false;
 
         class OnResumedEvent : public nsAppShell::Event
         {
             LayerView::Compositor::GlobalRef mCompositor;
 
@@ -1059,44 +1037,188 @@ public:
         };
 
         nsAppShell::PostEvent(MakeUnique<LayerViewEvent>(
                 MakeUnique<OnResumedEvent>(aObj)));
     }
 
     void SyncInvalidateAndScheduleComposite()
     {
-        RefPtr<UiCompositorControllerChild> child = UiCompositorControllerChild::Get();
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
 
         if (!child) {
             return;
         }
 
-        int64_t id = 0;
-        if (LockedWindowPtr window{mWindow}) {
-            id = window->GetRootLayerId();
-        }
-
-        if (id == 0) {
-            return;
-        }
-
         if (!AndroidBridge::IsJavaUiThread()) {
             RefPtr<nsThread> uiThread = GetAndroidUiThread();
             if (uiThread) {
-                uiThread->Dispatch(NewRunnableMethod<const int64_t&>(child,
-                                                                     &UiCompositorControllerChild::SendInvalidateAndRender,
-                                                                     id),
+                uiThread->Dispatch(NewRunnableMethod(child,
+                                                     &UiCompositorControllerChild::InvalidateAndRender),
                                    nsIThread::DISPATCH_NORMAL);
             }
             return;
         }
 
         MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
-        child->SendInvalidateAndRender(id);
+        child->InvalidateAndRender();
+    }
+
+    void SetMaxToolbarHeight(int32_t aHeight)
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (child) {
+          mCompositorPaused = false;
+          child->SetMaxToolbarHeight(aHeight);
+        }
+    }
+
+    void SetPinned(bool aPinned, int32_t aReason)
+    {
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (!child) {
+          return;
+        }
+
+        if (!AndroidBridge::IsJavaUiThread()) {
+            RefPtr<nsThread> uiThread = GetAndroidUiThread();
+            if (uiThread) {
+                uiThread->Dispatch(NewRunnableMethod<bool, int32_t>(
+                                       child, &UiCompositorControllerChild::SetPinned, aPinned, aReason),
+                                   nsIThread::DISPATCH_NORMAL);
+            }
+            return;
+        }
+
+        child->SetPinned(aPinned, aReason);
+    }
+
+
+    void SendToolbarAnimatorMessage(int32_t aMessage)
+    {
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (!child) {
+          return;
+        }
+
+        if (!AndroidBridge::IsJavaUiThread()) {
+            RefPtr<nsThread> uiThread = GetAndroidUiThread();
+            if (uiThread) {
+                uiThread->Dispatch(NewRunnableMethod<int32_t>(
+                                       child, &UiCompositorControllerChild::ToolbarAnimatorMessageFromUI, aMessage),
+                                   nsIThread::DISPATCH_NORMAL);
+            }
+            return;
+        }
+
+        child->ToolbarAnimatorMessageFromUI(aMessage);
+    }
+
+    void RecvToolbarAnimatorMessage(int32_t aMessage)
+    {
+        mCompositor->RecvToolbarAnimatorMessage(aMessage);
+    }
+
+    void SetDefaultClearColor(int32_t aColor)
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (!child) {
+          return;
+        }
+
+        child->SetDefaultClearColor((uint32_t)aColor);
+    }
+
+    void RequestScreenPixels()
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (child) {
+          child->RequestScreenPixels();
+        }
+    }
+
+    void RecvScreenPixels(int32_t aWidth, int32_t aHeight, Shmem& aMem)
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+
+        auto pixels = mozilla::jni::IntArray::New(aMem.get<int>(), aMem.Size<int>());
+        mCompositor->RecvScreenPixels(aWidth, aHeight, pixels);
+
+        // Pixels have been copied, so Dealloc Shmem
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (child) {
+          child->DeallocPixelBuffer(aMem);
+        }
+    }
+
+    void EnableLayerUpdateNotifications(bool aEnable)
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (child) {
+          child->EnableLayerUpdateNotifications(aEnable);
+        }
+    }
+
+    void RecvLayerUpdated()
+    {
+        mCompositor->RecvLayerUpdated();
+    }
+
+    void SendToolbarPixelsToCompositor(int32_t aWidth, int32_t aHeight, jni::IntArray::Param aPixels)
+    {
+        MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+        RefPtr<UiCompositorControllerChild> child;
+        if (LockedWindowPtr window{mWindow}) {
+            child = window->GetUiCompositorControllerChild();
+        }
+
+        if (child) {
+           Shmem mem;
+           child->AllocPixelBuffer(aPixels->Length() * sizeof(int32_t), &mem);
+           aPixels->CopyTo(mem.get<int32_t>(), mem.Size<int32_t>());
+           if (!child->ToolbarPixelsToCompositor(aWidth, aHeight, mem)) {
+               child->DeallocPixelBuffer(mem);
+           }
+        }
     }
 };
 
 template<> const char
 nsWindow::NativePtr<nsWindow::LayerViewSupport>::sName[] = "LayerViewSupport";
 
 /* PresentationMediaPlayerManager native calls access inner nsWindow functionality so PMPMSupport is a child class of nsWindow */
 class nsWindow::PMPMSupport final
@@ -1529,16 +1651,23 @@ nsWindow::RedrawAll()
 {
     if (mAttachedWidgetListener) {
         mAttachedWidgetListener->RequestRepaint();
     } else if (mWidgetListener) {
         mWidgetListener->RequestRepaint();
     }
 }
 
+
+RefPtr<UiCompositorControllerChild>
+nsWindow::GetUiCompositorControllerChild()
+{
+    return mCompositorSession ? mCompositorSession->GetUiCompositorControllerChild() : nullptr;
+}
+
 int64_t
 nsWindow::GetRootLayerId() const
 {
     return mCompositorSession ? mCompositorSession->RootLayerTreeId() : 0;
 }
 
 void
 nsWindow::EnableEventDispatcher()
@@ -1956,27 +2085,16 @@ void
 nsWindow::UpdateOverscrollOffset(const float aX, const float aY)
 {
     if (NativePtr<NPZCSupport>::Locked npzcs{mNPZCSupport}) {
         npzcs->UpdateOverscrollOffset(aX, aY);
     }
 }
 
 void
-nsWindow::SetScrollingRootContent(const bool isRootContent)
-{
-    // On Android, the Controller thread and UI thread are the same.
-    MOZ_ASSERT(APZThreadUtils::IsControllerThread(), "nsWindow::SetScrollingRootContent must be called from the controller thread");
-
-    if (NativePtr<NPZCSupport>::Locked npzcs{mNPZCSupport}) {
-        npzcs->SetScrollingRootContent(isRootContent);
-    }
-}
-
-void
 nsWindow::SetSelectionDragState(bool aState)
 {
     if (NativePtr<NPZCSupport>::Locked npzcs{mNPZCSupport}) {
         npzcs->SetSelectionDragState(aState);
     }
 }
 
 void *
@@ -2205,84 +2323,16 @@ nsWindow::SynthesizeNativeMouseMove(Layo
     MOZ_ASSERT(mLayerViewSupport);
     GeckoLayerClient::LocalRef client = mLayerViewSupport->GetLayerClient();
     client->SynthesizeNativeMouseEvent(sdk::MotionEvent::ACTION_HOVER_MOVE, aPoint.x, aPoint.y);
 
     return NS_OK;
 }
 
 bool
-nsWindow::PreRender(WidgetRenderingContext* aContext)
-{
-    if (Destroyed()) {
-        return true;
-    }
-
-    layers::Compositor* compositor = aContext->mCompositor;
-
-    GeckoLayerClient::LocalRef client;
-
-    if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
-        client = lvs->GetLayerClient();
-    }
-
-    if (compositor && client) {
-        // Android Color is ARGB which is apparently unusual.
-        compositor->SetDefaultClearColor(gfx::Color::UnusualFromARGB((uint32_t)client->ClearColor()));
-    }
-
-    return true;
-}
-void
-nsWindow::DrawWindowUnderlay(WidgetRenderingContext* aContext,
-                             LayoutDeviceIntRect aRect)
-{
-    if (Destroyed()) {
-        return;
-    }
-
-    GeckoLayerClient::LocalRef client;
-
-    if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
-        client = lvs->GetLayerClient();
-    }
-
-    if (!client) {
-        return;
-    }
-
-    LayerRenderer::Frame::LocalRef frame = client->CreateFrame();
-    mLayerRendererFrame = frame;
-    if (NS_WARN_IF(!mLayerRendererFrame)) {
-        return;
-    }
-
-    if (!WidgetPaintsBackground()) {
-        return;
-    }
-
-    frame->BeginDrawing();
-}
-
-void
-nsWindow::DrawWindowOverlay(WidgetRenderingContext* aContext,
-                            LayoutDeviceIntRect aRect)
-{
-    PROFILER_LABEL("nsWindow", "DrawWindowOverlay",
-        js::ProfileEntry::Category::GRAPHICS);
-
-    if (Destroyed() || NS_WARN_IF(!mLayerRendererFrame)) {
-        return;
-    }
-
-    mLayerRendererFrame->EndDrawing();
-    mLayerRendererFrame = nullptr;
-}
-
-bool
 nsWindow::WidgetPaintsBackground()
 {
     static bool sWidgetPaintsBackground = true;
     static bool sWidgetPaintsBackgroundPrefCached = false;
 
     if (!sWidgetPaintsBackgroundPrefCached) {
         sWidgetPaintsBackgroundPrefCached = true;
         mozilla::Preferences::AddBoolVarCache(&sWidgetPaintsBackground,
@@ -2352,8 +2402,49 @@ nsWindow::GetWidgetScreen()
 jni::DependentRef<java::GeckoLayerClient>
 nsWindow::GetLayerClient()
 {
     if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
         return lvs->GetLayerClient().Get();
     }
     return nullptr;
 }
+void
+nsWindow::RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage)
+{
+    MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+    if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
+        lvs->RecvToolbarAnimatorMessage(aMessage);
+    }
+}
+
+void
+nsWindow::UpdateRootFrameMetrics(float aScrollX, float aScrollY, float aZoom,
+                                 float aCssPageLeft, float aCssPageTop,
+                                 float aCssPageRight, float aCssPageBottom) {
+
+  MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+  if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
+    GeckoLayerClient::LocalRef client = lvs->GetLayerClient();
+    client->UpdateRootFrameMetrics(aScrollX, aScrollY, aZoom,
+                                   aCssPageLeft, aCssPageTop,
+                                   aCssPageRight, aCssPageBottom);
+  }
+}
+
+
+void
+nsWindow::RecvScreenPixels(int32_t aWidth, int32_t aHeight, Shmem& aMem)
+{
+  MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+  if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
+    lvs->RecvScreenPixels(aWidth, aHeight, aMem);
+  }
+}
+
+void
+nsWindow::RecvLayerUpdated()
+{
+  MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
+  if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
+    lvs->RecvLayerUpdated();
+  }
+}

--- a/widget/android/nsWindow.h
+++ b/widget/android/nsWindow.h
@@ -24,21 +24,26 @@ struct ANPEvent;
 
 namespace mozilla {
     class WidgetTouchEvent;
 
     namespace layers {
         class CompositorBridgeChild;
         class LayerManager;
         class APZCTreeManager;
+        class UiCompositorControllerChild;
     }
 
     namespace widget {
         class GeckoEditableSupport;
     } // namespace widget
+
+    namespace ipc {
+        class Shmem;
+    } // namespace ipc
 }
 
 class nsWindow : public nsBaseWidget
 {
 private:
     virtual ~nsWindow();
 
 public:
@@ -209,17 +214,16 @@ public:
 
     void OnSizeChanged(const mozilla::gfx::IntSize& aSize);
 
     void InitEvent(mozilla::WidgetGUIEvent& event,
                    LayoutDeviceIntPoint* aPoint = 0);
 
     void UpdateOverscrollVelocity(const float aX, const float aY);
     void UpdateOverscrollOffset(const float aX, const float aY);
-    void SetScrollingRootContent(const bool isRootContent);
 
     //
     // nsIWidget
     //
 
     using nsBaseWidget::Create; // for Create signature not overridden here
     virtual MOZ_MUST_USE nsresult Create(nsIWidget* aParent,
                                          nsNativeWidget aNativeParent,
@@ -277,21 +281,16 @@ public:
     virtual InputContext GetInputContext() override;
 
     void SetSelectionDragState(bool aState);
     LayerManager* GetLayerManager(PLayerTransactionChild* aShadowManager = nullptr,
                                   LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
                                   LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 
     virtual bool NeedsPaint() override;
-    virtual bool PreRender(mozilla::widget::WidgetRenderingContext* aContext) override;
-    virtual void DrawWindowUnderlay(mozilla::widget::WidgetRenderingContext* aContext,
-                                    LayoutDeviceIntRect aRect) override;
-    virtual void DrawWindowOverlay(mozilla::widget::WidgetRenderingContext* aContext,
-                                   LayoutDeviceIntRect aRect) override;
 
     virtual bool WidgetPaintsBackground() override;
 
     virtual uint32_t GetMaxTouchPoints() const override;
 
     void UpdateZoomConstraints(const uint32_t& aPresShellId,
                                const FrameMetrics::ViewID& aViewId,
                                const mozilla::Maybe<ZoomConstraints>& aConstraints) override;
@@ -304,17 +303,17 @@ public:
                                         nsIObserver* aObserver) override;
     nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
                                         uint32_t aNativeMessage,
                                         uint32_t aModifierFlags,
                                         nsIObserver* aObserver) override;
     nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
                                        nsIObserver* aObserver) override;
 
-    CompositorBridgeChild* GetCompositorBridgeChild() const;
+    mozilla::layers::CompositorBridgeChild* GetCompositorBridgeChild() const;
 
     mozilla::jni::DependentRef<mozilla::java::GeckoLayerClient> GetLayerClient();
 
     // 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; }
@@ -348,14 +347,21 @@ protected:
     static void DumpWindows();
     static void DumpWindows(const nsTArray<nsWindow*>& wins, int indent = 0);
     static void LogWindow(nsWindow *win, int index, int indent);
 
 private:
     void CreateLayerManager(int aCompositorWidth, int aCompositorHeight);
     void RedrawAll();
 
-    mozilla::java::LayerRenderer::Frame::GlobalRef mLayerRendererFrame;
+    int64_t GetRootLayerId() const;
+    RefPtr<mozilla::layers::UiCompositorControllerChild> GetUiCompositorControllerChild();
 
-    int64_t GetRootLayerId() const;
+public:
+    void RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage) override;
+    void UpdateRootFrameMetrics(float aScrollX, float aScrollY, float aZoom,
+                                float aCssPageLeft, float aCssPageTop,
+                                float aCssPageRight, float aCssPageBottom) override;
+    void RecvScreenPixels(int32_t aWidth, int32_t aHeight, mozilla::ipc::Shmem& aMem) override;
+    void RecvLayerUpdated() override;
 };
 
 #endif /* NSWINDOW_H_ */