diff --git a/flow/layers/layer_tree.cc b/flow/layers/layer_tree.cc
index 1ad6b64c18676..4fefac4eee79f 100644
--- a/flow/layers/layer_tree.cc
+++ b/flow/layers/layer_tree.cc
@@ -20,14 +20,13 @@
 
 namespace flutter {
 
-LayerTree::LayerTree(const SkISize& frame_size, float device_pixel_ratio)
-    : frame_size_(frame_size),
-      device_pixel_ratio_(device_pixel_ratio),
-      rasterizer_tracing_threshold_(0),
-      checkerboard_raster_cache_images_(false),
-      checkerboard_offscreen_layers_(false) {
-  FML_CHECK(device_pixel_ratio_ != 0.0f);
-}
+LayerTree::LayerTree(const Config& config, const SkISize& frame_size)
+    : root_layer_(config.root_layer),
+      frame_size_(frame_size),
+      rasterizer_tracing_threshold_(config.rasterizer_tracing_threshold),
+      checkerboard_raster_cache_images_(
+          config.checkerboard_raster_cache_images),
+      checkerboard_offscreen_layers_(config.checkerboard_offscreen_layers) {}
 
 inline SkColorSpace* GetColorSpace(DlCanvas* canvas) {
   return canvas ? canvas->GetImageInfo().colorSpace() : nullptr;
diff --git a/flow/layers/layer_tree.h b/flow/layers/layer_tree.h
index a39cc2360076f..4e55953bee05a 100644
--- a/flow/layers/layer_tree.h
+++ b/flow/layers/layer_tree.h
@@ -23,7 +23,14 @@ namespace flutter {
 
 class LayerTree {
  public:
-  LayerTree(const SkISize& frame_size, float device_pixel_ratio);
+  struct Config {
+    std::shared_ptr<Layer> root_layer;
+    uint32_t rasterizer_tracing_threshold = 0;
+    bool checkerboard_raster_cache_images = false;
+    bool checkerboard_offscreen_layers = false;
+  };
+
+  LayerTree(const Config& config, const SkISize& frame_size);
 
   // Perform a preroll pass on the tree and return information about
   // the tree that affects rendering this frame.
@@ -50,36 +57,18 @@ class LayerTree {
       GrDirectContext* gr_context = nullptr);
 
   Layer* root_layer() const { return root_layer_.get(); }
-
-  void set_root_layer(std::shared_ptr<Layer> root_layer) {
-    root_layer_ = std::move(root_layer);
-  }
-
   const SkISize& frame_size() const { return frame_size_; }
-  float device_pixel_ratio() const { return device_pixel_ratio_; }
 
   const PaintRegionMap& paint_region_map() const { return paint_region_map_; }
   PaintRegionMap& paint_region_map() { return paint_region_map_; }
 
   // The number of frame intervals missed after which the compositor must
-  // trace the rasterized picture to a trace file. Specify 0 to disable all
-  // tracing
-  void set_rasterizer_tracing_threshold(uint32_t interval) {
-    rasterizer_tracing_threshold_ = interval;
-  }
-
+  // trace the rasterized picture to a trace file. 0 stands for disabling all
+  // tracing.
   uint32_t rasterizer_tracing_threshold() const {
     return rasterizer_tracing_threshold_;
   }
 
-  void set_checkerboard_raster_cache_images(bool checkerboard) {
-    checkerboard_raster_cache_images_ = checkerboard;
-  }
-
-  void set_checkerboard_offscreen_layers(bool checkerboard) {
-    checkerboard_offscreen_layers_ = checkerboard;
-  }
-
   /// When `Paint` is called, if leaf layer tracing is enabled, additional
   /// metadata around raterization of leaf layers is collected.
   ///
@@ -95,7 +84,6 @@ class LayerTree {
  private:
   std::shared_ptr<Layer> root_layer_;
   SkISize frame_size_ = SkISize::MakeEmpty();  // Physical pixels.
-  const float device_pixel_ratio_;  // Logical / Physical pixels ratio.
   uint32_t rasterizer_tracing_threshold_;
   bool checkerboard_raster_cache_images_;
   bool checkerboard_offscreen_layers_;
diff --git a/flow/layers/layer_tree_unittests.cc b/flow/layers/layer_tree_unittests.cc
index b63fa59d99f1e..9fbcd4cd729ed 100644
--- a/flow/layers/layer_tree_unittests.cc
+++ b/flow/layers/layer_tree_unittests.cc
@@ -19,8 +19,7 @@ namespace testing {
 class LayerTreeTest : public CanvasTest {
  public:
   LayerTreeTest()
-      : layer_tree_(SkISize::Make(64, 64), 1.0f),
-        root_transform_(SkMatrix::Translate(1.0f, 1.0f)),
+      : root_transform_(SkMatrix::Translate(1.0f, 1.0f)),
         scoped_frame_(compositor_context_.AcquireFrame(nullptr,
                                                        &mock_canvas(),
                                                        nullptr,
@@ -31,12 +30,14 @@ class LayerTreeTest : public CanvasTest {
                                                        nullptr,
                                                        nullptr)) {}
 
-  LayerTree& layer_tree() { return layer_tree_; }
   CompositorContext::ScopedFrame& frame() { return *scoped_frame_.get(); }
   const SkMatrix& root_transform() { return root_transform_; }
 
+  std::unique_ptr<LayerTree> BuildLayerTree(const LayerTree::Config& config) {
+    return std::make_unique<LayerTree>(config, SkISize::Make(64, 64));
+  }
+
  private:
-  LayerTree layer_tree_;
   CompositorContext compositor_context_;
   SkMatrix root_transform_;
   std::unique_ptr<CompositorContext::ScopedFrame> scoped_frame_;
@@ -45,12 +46,14 @@ class LayerTreeTest : public CanvasTest {
 TEST_F(LayerTreeTest, PaintingEmptyLayerDies) {
   auto layer = std::make_shared<ContainerLayer>();
 
-  layer_tree().set_root_layer(layer);
-  layer_tree().Preroll(frame());
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
+  layer_tree->Preroll(frame());
   EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
   EXPECT_TRUE(layer->is_empty());
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
 }
 
 TEST_F(LayerTreeTest, PaintBeforePrerollDies) {
@@ -61,13 +64,15 @@ TEST_F(LayerTreeTest, PaintBeforePrerollDies) {
   auto layer = std::make_shared<ContainerLayer>();
   layer->Add(mock_layer);
 
-  layer_tree().set_root_layer(layer);
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
   EXPECT_EQ(mock_layer->paint_bounds(), kEmptyRect);
   EXPECT_EQ(layer->paint_bounds(), kEmptyRect);
   EXPECT_TRUE(mock_layer->is_empty());
   EXPECT_TRUE(layer->is_empty());
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
   EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
 }
 
@@ -79,15 +84,17 @@ TEST_F(LayerTreeTest, Simple) {
   auto layer = std::make_shared<ContainerLayer>();
   layer->Add(mock_layer);
 
-  layer_tree().set_root_layer(layer);
-  layer_tree().Preroll(frame());
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
+  layer_tree->Preroll(frame());
   EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
   EXPECT_EQ(layer->paint_bounds(), mock_layer->paint_bounds());
   EXPECT_FALSE(mock_layer->is_empty());
   EXPECT_FALSE(layer->is_empty());
   EXPECT_EQ(mock_layer->parent_matrix(), root_transform());
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
   EXPECT_EQ(mock_canvas().draw_calls(),
             std::vector({MockCanvas::DrawCall{
                 0, MockCanvas::DrawPathData{child_path, child_paint}}}));
@@ -107,8 +114,10 @@ TEST_F(LayerTreeTest, Multiple) {
 
   SkRect expected_total_bounds = child_path1.getBounds();
   expected_total_bounds.join(child_path2.getBounds());
-  layer_tree().set_root_layer(layer);
-  layer_tree().Preroll(frame());
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
+  layer_tree->Preroll(frame());
   EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
   EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
   EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
@@ -121,7 +130,7 @@ TEST_F(LayerTreeTest, Multiple) {
   EXPECT_EQ(mock_layer2->parent_cull_rect(),
             kGiantRect);  // Siblings are independent
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
   EXPECT_EQ(
       mock_canvas().draw_calls(),
       std::vector({MockCanvas::DrawCall{
@@ -140,8 +149,10 @@ TEST_F(LayerTreeTest, MultipleWithEmpty) {
   layer->Add(mock_layer1);
   layer->Add(mock_layer2);
 
-  layer_tree().set_root_layer(layer);
-  layer_tree().Preroll(frame());
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
+  layer_tree->Preroll(frame());
   EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
   EXPECT_EQ(mock_layer2->paint_bounds(), SkPath().getBounds());
   EXPECT_EQ(layer->paint_bounds(), child_path1.getBounds());
@@ -153,7 +164,7 @@ TEST_F(LayerTreeTest, MultipleWithEmpty) {
   EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
   EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
   EXPECT_EQ(mock_canvas().draw_calls(),
             std::vector({MockCanvas::DrawCall{
                 0, MockCanvas::DrawPathData{child_path1, child_paint1}}}));
@@ -172,8 +183,10 @@ TEST_F(LayerTreeTest, NeedsSystemComposite) {
 
   SkRect expected_total_bounds = child_path1.getBounds();
   expected_total_bounds.join(child_path2.getBounds());
-  layer_tree().set_root_layer(layer);
-  layer_tree().Preroll(frame());
+  auto layer_tree = BuildLayerTree(LayerTree::Config{
+      .root_layer = layer,
+  });
+  layer_tree->Preroll(frame());
   EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
   EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
   EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
@@ -185,7 +198,7 @@ TEST_F(LayerTreeTest, NeedsSystemComposite) {
   EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
   EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
-  layer_tree().Paint(frame());
+  layer_tree->Paint(frame());
   EXPECT_EQ(
       mock_canvas().draw_calls(),
       std::vector({MockCanvas::DrawCall{
diff --git a/lib/ui/compositing/scene.cc b/lib/ui/compositing/scene.cc
index c5070c6376091..17d00ea794c2a 100644
--- a/lib/ui/compositing/scene.cc
+++ b/lib/ui/compositing/scene.cc
@@ -40,27 +40,22 @@ Scene::Scene(std::shared_ptr<flutter::Layer> rootLayer,
              uint32_t rasterizerTracingThreshold,
              bool checkerboardRasterCacheImages,
              bool checkerboardOffscreenLayers) {
-  // Currently only supports a single window.
-  auto viewport_metrics = UIDartState::Current()
-                              ->platform_configuration()
-                              ->get_window(0)
-                              ->viewport_metrics();
-
-  layer_tree_ = std::make_shared<LayerTree>(
-      SkISize::Make(viewport_metrics.physical_width,
-                    viewport_metrics.physical_height),
-      static_cast<float>(viewport_metrics.device_pixel_ratio));
-  layer_tree_->set_root_layer(std::move(rootLayer));
-  layer_tree_->set_rasterizer_tracing_threshold(rasterizerTracingThreshold);
-  layer_tree_->set_checkerboard_raster_cache_images(
-      checkerboardRasterCacheImages);
-  layer_tree_->set_checkerboard_offscreen_layers(checkerboardOffscreenLayers);
+  layer_tree_config_.root_layer = std::move(rootLayer);
+  layer_tree_config_.rasterizer_tracing_threshold = rasterizerTracingThreshold;
+  layer_tree_config_.checkerboard_raster_cache_images =
+      checkerboardRasterCacheImages;
+  layer_tree_config_.checkerboard_offscreen_layers =
+      checkerboardOffscreenLayers;
 }
 
 Scene::~Scene() {}
 
+bool Scene::valid() {
+  return layer_tree_config_.root_layer != nullptr;
+}
+
 void Scene::dispose() {
-  layer_tree_.reset();
+  layer_tree_config_.root_layer.reset();
   ClearDartWrapper();
 }
 
@@ -69,8 +64,8 @@ Dart_Handle Scene::toImageSync(uint32_t width,
                                Dart_Handle raw_image_handle) {
   TRACE_EVENT0("flutter", "Scene::toImageSync");
 
-  if (!layer_tree_) {
-    return tonic::ToDart("Scene did not contain a layer tree.");
+  if (!valid()) {
+    return tonic::ToDart("Scene has been disposed.");
   }
 
   Scene::RasterizeToImage(width, height, raw_image_handle);
@@ -82,32 +77,32 @@ Dart_Handle Scene::toImage(uint32_t width,
                            Dart_Handle raw_image_callback) {
   TRACE_EVENT0("flutter", "Scene::toImage");
 
-  if (!layer_tree_) {
-    return tonic::ToDart("Scene did not contain a layer tree.");
+  if (!valid()) {
+    return tonic::ToDart("Scene has been disposed.");
   }
 
-  return Picture::RasterizeLayerTreeToImage(std::move(layer_tree_), width,
-                                            height, raw_image_callback);
+  return Picture::RasterizeLayerTreeToImage(BuildLayerTree(width, height),
+                                            raw_image_callback);
 }
 
 static sk_sp<DlImage> CreateDeferredImage(
     bool impeller,
-    std::shared_ptr<LayerTree> layer_tree,
-    uint32_t width,
-    uint32_t height,
+    std::unique_ptr<LayerTree> layer_tree,
     fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::RefPtr<fml::TaskRunner> raster_task_runner,
     fml::RefPtr<SkiaUnrefQueue> unref_queue) {
 #if IMPELLER_SUPPORTS_RENDERING
   if (impeller) {
-    return DlDeferredImageGPUImpeller::Make(
-        std::move(layer_tree), SkISize::Make(width, height),
-        std::move(snapshot_delegate), std::move(raster_task_runner));
+    return DlDeferredImageGPUImpeller::Make(std::move(layer_tree),
+                                            std::move(snapshot_delegate),
+                                            std::move(raster_task_runner));
   }
 #endif  // IMPELLER_SUPPORTS_RENDERING
 
-  const SkImageInfo image_info = SkImageInfo::Make(
-      width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+  const auto& frame_size = layer_tree->frame_size();
+  const SkImageInfo image_info =
+      SkImageInfo::Make(frame_size.width(), frame_size.height(),
+                        kRGBA_8888_SkColorType, kPremul_SkAlphaType);
   return DlDeferredImageGPUSkia::MakeFromLayerTree(
       image_info, std::move(layer_tree), std::move(snapshot_delegate),
       raster_task_runner, std::move(unref_queue));
@@ -126,15 +121,25 @@ void Scene::RasterizeToImage(uint32_t width,
 
   auto image = CanvasImage::Create();
   auto dl_image = CreateDeferredImage(
-      dart_state->IsImpellerEnabled(), layer_tree_, width, height,
+      dart_state->IsImpellerEnabled(), BuildLayerTree(width, height),
       std::move(snapshot_delegate), std::move(raster_task_runner),
       std::move(unref_queue));
   image->set_image(dl_image);
   image->AssociateWithDartWrapper(raw_image_handle);
 }
 
-std::shared_ptr<flutter::LayerTree> Scene::takeLayerTree() {
-  return std::move(layer_tree_);
+std::unique_ptr<flutter::LayerTree> Scene::takeLayerTree(uint64_t width,
+                                                         uint64_t height) {
+  return BuildLayerTree(width, height);
+}
+
+std::unique_ptr<LayerTree> Scene::BuildLayerTree(uint32_t width,
+                                                 uint32_t height) {
+  if (!valid()) {
+    return nullptr;
+  }
+  return std::make_unique<LayerTree>(layer_tree_config_,
+                                     SkISize::Make(width, height));
 }
 
 }  // namespace flutter
diff --git a/lib/ui/compositing/scene.h b/lib/ui/compositing/scene.h
index aca797836fcb1..a8a3614f64977 100644
--- a/lib/ui/compositing/scene.h
+++ b/lib/ui/compositing/scene.h
@@ -26,7 +26,8 @@ class Scene : public RefCountedDartWrappable<Scene> {
                      bool checkerboardRasterCacheImages,
                      bool checkerboardOffscreenLayers);
 
-  std::shared_ptr<flutter::LayerTree> takeLayerTree();
+  std::unique_ptr<flutter::LayerTree> takeLayerTree(uint64_t width,
+                                                    uint64_t height);
 
   Dart_Handle toImageSync(uint32_t width,
                           uint32_t height,
@@ -44,16 +45,16 @@ class Scene : public RefCountedDartWrappable<Scene> {
         bool checkerboardRasterCacheImages,
         bool checkerboardOffscreenLayers);
 
+  // Returns true if `dispose()` has not been called.
+  bool valid();
+
   void RasterizeToImage(uint32_t width,
                         uint32_t height,
                         Dart_Handle raw_image_handle);
 
-  // This is a shared_ptr to support flattening the layer tree from the UI
-  // thread onto the raster thread - allowing access to the texture registry
-  // required to render TextureLayers.
-  //
-  // No longer valid after calling `takeLayerTree`.
-  std::shared_ptr<flutter::LayerTree> layer_tree_;
+  std::unique_ptr<LayerTree> BuildLayerTree(uint32_t width, uint32_t height);
+
+  flutter::LayerTree::Config layer_tree_config_;
 };
 
 }  // namespace flutter
diff --git a/lib/ui/compositing/scene_builder_unittests.cc b/lib/ui/compositing/scene_builder_unittests.cc
index 41efcdc64efd5..702d83bf61417 100644
--- a/lib/ui/compositing/scene_builder_unittests.cc
+++ b/lib/ui/compositing/scene_builder_unittests.cc
@@ -59,7 +59,7 @@ TEST_F(ShellTest, SceneBuilderBuildAndSceneDisposeReleasesLayerStack) {
 
   auto validate_scene_has_no_layers =
       [message_latch, &retained_scene](Dart_NativeArguments args) {
-        EXPECT_FALSE(retained_scene->takeLayerTree());
+        EXPECT_FALSE(retained_scene->takeLayerTree(100, 100));
         retained_scene->Release();
         retained_scene = nullptr;
         message_latch->Signal();
diff --git a/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc b/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
index 40d09b8ff00c6..0c2a7de57cca4 100644
--- a/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
+++ b/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
@@ -3,20 +3,20 @@
 // found in the LICENSE file.
 
 #include "flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h"
-#include "display_list_deferred_image_gpu_impeller.h"
 
 #include <utility>
 
+#include "flutter/fml/make_copyable.h"
+
 namespace flutter {
 
 sk_sp<DlDeferredImageGPUImpeller> DlDeferredImageGPUImpeller::Make(
-    std::shared_ptr<LayerTree> layer_tree,
-    const SkISize& size,
+    std::unique_ptr<LayerTree> layer_tree,
     fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::RefPtr<fml::TaskRunner> raster_task_runner) {
   return sk_sp<DlDeferredImageGPUImpeller>(new DlDeferredImageGPUImpeller(
       DlDeferredImageGPUImpeller::ImageWrapper::Make(
-          std::move(layer_tree), size, std::move(snapshot_delegate),
+          std::move(layer_tree), std::move(snapshot_delegate),
           std::move(raster_task_runner))));
 }
 
@@ -106,13 +106,12 @@ DlDeferredImageGPUImpeller::ImageWrapper::Make(
 
 std::shared_ptr<DlDeferredImageGPUImpeller::ImageWrapper>
 DlDeferredImageGPUImpeller::ImageWrapper::Make(
-    std::shared_ptr<LayerTree> layer_tree,
-    const SkISize& size,
+    std::unique_ptr<LayerTree> layer_tree,
     fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::RefPtr<fml::TaskRunner> raster_task_runner) {
-  auto wrapper = std::shared_ptr<ImageWrapper>(
-      new ImageWrapper(nullptr, size, std::move(snapshot_delegate),
-                       std::move(raster_task_runner)));
+  auto wrapper = std::shared_ptr<ImageWrapper>(new ImageWrapper(
+      nullptr, layer_tree->frame_size(), std::move(snapshot_delegate),
+      std::move(raster_task_runner)));
   wrapper->SnapshotDisplayList(std::move(layer_tree));
   return wrapper;
 }
@@ -152,10 +151,11 @@ bool DlDeferredImageGPUImpeller::ImageWrapper::isTextureBacked() const {
 }
 
 void DlDeferredImageGPUImpeller::ImageWrapper::SnapshotDisplayList(
-    std::shared_ptr<LayerTree> layer_tree) {
+    std::unique_ptr<LayerTree> layer_tree) {
   fml::TaskRunner::RunNowOrPostTask(
       raster_task_runner_,
-      [weak_this = weak_from_this(), layer_tree = std::move(layer_tree)] {
+      fml::MakeCopyable([weak_this = weak_from_this(),
+                         layer_tree = std::move(layer_tree)]() {
         TRACE_EVENT0("flutter", "SnapshotDisplayList (impeller)");
         auto wrapper = weak_this.lock();
         if (!wrapper) {
@@ -183,7 +183,7 @@ void DlDeferredImageGPUImpeller::ImageWrapper::SnapshotDisplayList(
           return;
         }
         wrapper->texture_ = snapshot->impeller_texture();
-      });
+      }));
 }
 
 std::optional<std::string>
diff --git a/lib/ui/painting/display_list_deferred_image_gpu_impeller.h b/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
index 664818da8a0fc..7bcb27922423e 100644
--- a/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
+++ b/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
@@ -18,8 +18,7 @@ namespace flutter {
 class DlDeferredImageGPUImpeller final : public DlImage {
  public:
   static sk_sp<DlDeferredImageGPUImpeller> Make(
-      std::shared_ptr<LayerTree> layer_tree,
-      const SkISize& size,
+      std::unique_ptr<LayerTree> layer_tree,
       fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
       fml::RefPtr<fml::TaskRunner> raster_task_runner);
 
@@ -71,8 +70,7 @@ class DlDeferredImageGPUImpeller final : public DlImage {
         fml::RefPtr<fml::TaskRunner> raster_task_runner);
 
     static std::shared_ptr<ImageWrapper> Make(
-        std::shared_ptr<LayerTree> layer_tree,
-        const SkISize& size,
+        std::unique_ptr<LayerTree> layer_tree,
         fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
         fml::RefPtr<fml::TaskRunner> raster_task_runner);
 
@@ -107,7 +105,7 @@ class DlDeferredImageGPUImpeller final : public DlImage {
     // thread task spwaned by this method. After being flattened into a display
     // list, the image wrapper will be updated to hold this display list and the
     // layer tree can be dropped.
-    void SnapshotDisplayList(std::shared_ptr<LayerTree> layer_tree = nullptr);
+    void SnapshotDisplayList(std::unique_ptr<LayerTree> layer_tree = nullptr);
 
     // |ContextListener|
     void OnGrContextCreated() override;
diff --git a/lib/ui/painting/display_list_deferred_image_gpu_skia.cc b/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
index a2bb4c0b94cda..0cec39c737a5d 100644
--- a/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
+++ b/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
@@ -4,6 +4,7 @@
 
 #include "flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h"
 
+#include "flutter/fml/make_copyable.h"
 #include "third_party/skia/include/core/SkColorSpace.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/gpu/ganesh/SkImageGanesh.h"
@@ -25,7 +26,7 @@ sk_sp<DlDeferredImageGPUSkia> DlDeferredImageGPUSkia::Make(
 
 sk_sp<DlDeferredImageGPUSkia> DlDeferredImageGPUSkia::MakeFromLayerTree(
     const SkImageInfo& image_info,
-    std::shared_ptr<LayerTree> layer_tree,
+    std::unique_ptr<LayerTree> layer_tree,
     fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
     const fml::RefPtr<fml::TaskRunner>& raster_task_runner,
     fml::RefPtr<SkiaUnrefQueue> unref_queue) {
@@ -114,7 +115,7 @@ DlDeferredImageGPUSkia::ImageWrapper::Make(
 std::shared_ptr<DlDeferredImageGPUSkia::ImageWrapper>
 DlDeferredImageGPUSkia::ImageWrapper::MakeFromLayerTree(
     const SkImageInfo& image_info,
-    std::shared_ptr<LayerTree> layer_tree,
+    std::unique_ptr<LayerTree> layer_tree,
     fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::RefPtr<fml::TaskRunner> raster_task_runner,
     fml::RefPtr<SkiaUnrefQueue> unref_queue) {
@@ -164,10 +165,11 @@ bool DlDeferredImageGPUSkia::ImageWrapper::isTextureBacked() const {
 }
 
 void DlDeferredImageGPUSkia::ImageWrapper::SnapshotDisplayList(
-    std::shared_ptr<LayerTree> layer_tree) {
+    std::unique_ptr<LayerTree> layer_tree) {
   fml::TaskRunner::RunNowOrPostTask(
       raster_task_runner_,
-      [weak_this = weak_from_this(), layer_tree = std::move(layer_tree)]() {
+      fml::MakeCopyable([weak_this = weak_from_this(),
+                         layer_tree = std::move(layer_tree)]() mutable {
         auto wrapper = weak_this.lock();
         if (!wrapper) {
           return;
@@ -199,7 +201,7 @@ void DlDeferredImageGPUSkia::ImageWrapper::SnapshotDisplayList(
           std::scoped_lock lock(wrapper->error_mutex_);
           wrapper->error_ = result->error;
         }
-      });
+      }));
 }
 
 std::optional<std::string> DlDeferredImageGPUSkia::ImageWrapper::get_error() {
diff --git a/lib/ui/painting/display_list_deferred_image_gpu_skia.h b/lib/ui/painting/display_list_deferred_image_gpu_skia.h
index 2d6c9b53c5cf9..4e3558fbe9348 100644
--- a/lib/ui/painting/display_list_deferred_image_gpu_skia.h
+++ b/lib/ui/painting/display_list_deferred_image_gpu_skia.h
@@ -30,7 +30,7 @@ class DlDeferredImageGPUSkia final : public DlImage {
 
   static sk_sp<DlDeferredImageGPUSkia> MakeFromLayerTree(
       const SkImageInfo& image_info,
-      std::shared_ptr<LayerTree> layer_tree,
+      std::unique_ptr<LayerTree> layer_tree,
       fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
       const fml::RefPtr<fml::TaskRunner>& raster_task_runner,
       fml::RefPtr<SkiaUnrefQueue> unref_queue);
@@ -85,7 +85,7 @@ class DlDeferredImageGPUSkia final : public DlImage {
 
     static std::shared_ptr<ImageWrapper> MakeFromLayerTree(
         const SkImageInfo& image_info,
-        std::shared_ptr<LayerTree> layer_tree,
+        std::unique_ptr<LayerTree> layer_tree,
         fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
         fml::RefPtr<fml::TaskRunner> raster_task_runner,
         fml::RefPtr<SkiaUnrefQueue> unref_queue);
@@ -125,7 +125,7 @@ class DlDeferredImageGPUSkia final : public DlImage {
     // thread task spwaned by this method. After being flattened into a display
     // list, the image wrapper will be updated to hold this display list and the
     // layer tree can be dropped.
-    void SnapshotDisplayList(std::shared_ptr<LayerTree> layer_tree = nullptr);
+    void SnapshotDisplayList(std::unique_ptr<LayerTree> layer_tree = nullptr);
 
     // |ContextListener|
     void OnGrContextCreated() override;
diff --git a/lib/ui/painting/picture.cc b/lib/ui/painting/picture.cc
index 53a9371277555..74c7b0dc78141 100644
--- a/lib/ui/painting/picture.cc
+++ b/lib/ui/painting/picture.cc
@@ -118,24 +118,27 @@ Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
                                       uint32_t width,
                                       uint32_t height,
                                       Dart_Handle raw_image_callback) {
-  return RasterizeToImage(display_list, nullptr, width, height,
-                          raw_image_callback);
+  return DoRasterizeToImage(display_list, nullptr, width, height,
+                            raw_image_callback);
 }
 
 Dart_Handle Picture::RasterizeLayerTreeToImage(
-    std::shared_ptr<LayerTree> layer_tree,
-    uint32_t width,
-    uint32_t height,
+    std::unique_ptr<LayerTree> layer_tree,
     Dart_Handle raw_image_callback) {
-  return RasterizeToImage(nullptr, std::move(layer_tree), width, height,
-                          raw_image_callback);
+  FML_DCHECK(layer_tree != nullptr);
+  auto frame_size = layer_tree->frame_size();
+  return DoRasterizeToImage(nullptr, std::move(layer_tree), frame_size.width(),
+                            frame_size.height(), raw_image_callback);
 }
 
-Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
-                                      std::shared_ptr<LayerTree> layer_tree,
-                                      uint32_t width,
-                                      uint32_t height,
-                                      Dart_Handle raw_image_callback) {
+Dart_Handle Picture::DoRasterizeToImage(const sk_sp<DisplayList>& display_list,
+                                        std::unique_ptr<LayerTree> layer_tree,
+                                        uint32_t width,
+                                        uint32_t height,
+                                        Dart_Handle raw_image_callback) {
+  // Either display_list or layer_tree should be provided.
+  FML_DCHECK((display_list == nullptr) != (layer_tree == nullptr));
+
   if (Dart_IsNull(raw_image_callback) || !Dart_IsClosure(raw_image_callback)) {
     return tonic::ToDart("Image callback was invalid");
   }
@@ -157,8 +160,6 @@ Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
   // thread owns the sole reference to the layer tree. So we do it in the
   // raster thread.
 
-  auto picture_bounds = SkISize::Make(width, height);
-
   auto ui_task =
       // The static leak checker gets confused by the use of fml::MakeCopyable.
       // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
@@ -198,14 +199,17 @@ Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
   // Kick things off on the raster rask runner.
   fml::TaskRunner::RunNowOrPostTask(
       raster_task_runner,
-      [ui_task_runner, snapshot_delegate, display_list, picture_bounds, ui_task,
-       layer_tree = std::move(layer_tree)] {
+      fml::MakeCopyable([ui_task_runner, snapshot_delegate, display_list, width,
+                         height, ui_task,
+                         layer_tree = std::move(layer_tree)]() mutable {
+        auto picture_bounds = SkISize::Make(width, height);
         sk_sp<DlImage> image;
         if (layer_tree) {
-          auto display_list = layer_tree->Flatten(
-              SkRect::MakeWH(picture_bounds.width(), picture_bounds.height()),
-              snapshot_delegate->GetTextureRegistry(),
-              snapshot_delegate->GetGrContext());
+          FML_DCHECK(picture_bounds == layer_tree->frame_size());
+          auto display_list =
+              layer_tree->Flatten(SkRect::MakeWH(width, height),
+                                  snapshot_delegate->GetTextureRegistry(),
+                                  snapshot_delegate->GetGrContext());
 
           image = snapshot_delegate->MakeRasterSnapshot(display_list,
                                                         picture_bounds);
@@ -216,7 +220,7 @@ Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
 
         fml::TaskRunner::RunNowOrPostTask(
             ui_task_runner, [ui_task, image]() { ui_task(image); });
-      });
+      }));
 
   return Dart_Null();
 }
diff --git a/lib/ui/painting/picture.h b/lib/ui/painting/picture.h
index d0c2a0123fa1d..89c84095336ed 100644
--- a/lib/ui/painting/picture.h
+++ b/lib/ui/painting/picture.h
@@ -49,19 +49,18 @@ class Picture : public RefCountedDartWrappable<Picture> {
                                       Dart_Handle raw_image_callback);
 
   static Dart_Handle RasterizeLayerTreeToImage(
-      std::shared_ptr<LayerTree> layer_tree,
-      uint32_t width,
-      uint32_t height,
+      std::unique_ptr<LayerTree> layer_tree,
       Dart_Handle raw_image_callback);
 
-  // Callers may provide either a display list or a layer tree. If a layer tree
-  // is provided, it will be flattened on the raster thread. In this case the
-  // display list will be ignored.
-  static Dart_Handle RasterizeToImage(const sk_sp<DisplayList>& display_list,
-                                      std::shared_ptr<LayerTree> layer_tree,
-                                      uint32_t width,
-                                      uint32_t height,
-                                      Dart_Handle raw_image_callback);
+  // Callers may provide either a display list or a layer tree, but not both.
+  //
+  // If a layer tree is provided, it will be flattened on the raster thread, and
+  // picture_bounds should be the layer tree's frame_size().
+  static Dart_Handle DoRasterizeToImage(const sk_sp<DisplayList>& display_list,
+                                        std::unique_ptr<LayerTree> layer_tree,
+                                        uint32_t width,
+                                        uint32_t height,
+                                        Dart_Handle raw_image_callback);
 
  private:
   explicit Picture(sk_sp<DisplayList> display_list);
diff --git a/runtime/runtime_controller.cc b/runtime/runtime_controller.cc
index 66ffd8c76ac1b..e384f96ec3aee 100644
--- a/runtime/runtime_controller.cc
+++ b/runtime/runtime_controller.cc
@@ -20,6 +20,8 @@
 
 namespace flutter {
 
+const uint64_t kFlutterDefaultViewId = 0llu;
+
 RuntimeController::RuntimeController(RuntimeDelegate& p_client,
                                      const TaskRunners& task_runners)
     : client_(p_client), vm_(nullptr), context_(task_runners) {}
@@ -316,7 +318,17 @@ void RuntimeController::ScheduleFrame() {
 
 // |PlatformConfigurationClient|
 void RuntimeController::Render(Scene* scene) {
-  client_.Render(scene->takeLayerTree());
+  // TODO(dkwingsmt): Currently only supports a single window.
+  int64_t view_id = kFlutterDefaultViewId;
+  auto window =
+      UIDartState::Current()->platform_configuration()->get_window(view_id);
+  if (window == nullptr) {
+    return;
+  }
+  const auto& viewport_metrics = window->viewport_metrics();
+  client_.Render(scene->takeLayerTree(viewport_metrics.physical_width,
+                                      viewport_metrics.physical_height),
+                 viewport_metrics.device_pixel_ratio);
 }
 
 // |PlatformConfigurationClient|
diff --git a/runtime/runtime_delegate.h b/runtime/runtime_delegate.h
index 0fbb43391e113..18e4dbfdfd31c 100644
--- a/runtime/runtime_delegate.h
+++ b/runtime/runtime_delegate.h
@@ -27,7 +27,8 @@ class RuntimeDelegate {
 
   virtual void ScheduleFrame(bool regenerate_layer_tree = true) = 0;
 
-  virtual void Render(std::shared_ptr<flutter::LayerTree> layer_tree) = 0;
+  virtual void Render(std::unique_ptr<flutter::LayerTree> layer_tree,
+                      float device_pixel_ratio) = 0;
 
   virtual void UpdateSemantics(SemanticsNodeUpdates update,
                                CustomAccessibilityActionUpdates actions) = 0;
diff --git a/shell/common/animator.cc b/shell/common/animator.cc
index 0b969c2ccbc0b..bb4c131cdff68 100644
--- a/shell/common/animator.cc
+++ b/shell/common/animator.cc
@@ -128,7 +128,8 @@ void Animator::BeginFrame(
   }
 }
 
-void Animator::Render(std::shared_ptr<flutter::LayerTree> layer_tree) {
+void Animator::Render(std::unique_ptr<flutter::LayerTree> layer_tree,
+                      float device_pixel_ratio) {
   has_rendered_ = true;
   last_layer_tree_size_ = layer_tree->frame_size();
 
@@ -148,7 +149,8 @@ void Animator::Render(std::shared_ptr<flutter::LayerTree> layer_tree) {
       frame_timings_recorder_->GetVsyncTargetTime());
 
   auto layer_tree_item = std::make_unique<LayerTreeItem>(
-      std::move(layer_tree), std::move(frame_timings_recorder_));
+      std::move(layer_tree), std::move(frame_timings_recorder_),
+      device_pixel_ratio);
   // Commit the pending continuation.
   PipelineProduceResult result =
       producer_continuation_.Complete(std::move(layer_tree_item));
diff --git a/shell/common/animator.h b/shell/common/animator.h
index dfacb4a786bf3..4e6295957bdcc 100644
--- a/shell/common/animator.h
+++ b/shell/common/animator.h
@@ -54,7 +54,8 @@ class Animator final {
 
   void RequestFrame(bool regenerate_layer_tree = true);
 
-  void Render(std::shared_ptr<flutter::LayerTree> layer_tree);
+  void Render(std::unique_ptr<flutter::LayerTree> layer_tree,
+              float device_pixel_ratio);
 
   const std::weak_ptr<VsyncWaiter> GetVsyncWaiter() const;
 
diff --git a/shell/common/animator_unittests.cc b/shell/common/animator_unittests.cc
index 05c728c57ae16..a3d814e298daa 100644
--- a/shell/common/animator_unittests.cc
+++ b/shell/common/animator_unittests.cc
@@ -155,9 +155,9 @@ TEST_F(ShellTest, AnimatorDoesNotNotifyIdleBeforeRender) {
   task_runners.GetUITaskRunner()->PostDelayedTask(
       [&] {
         ASSERT_FALSE(delegate.notify_idle_called_);
-        auto layer_tree =
-            std::make_shared<LayerTree>(SkISize::Make(600, 800), 1.0);
-        animator->Render(std::move(layer_tree));
+        auto layer_tree = std::make_unique<LayerTree>(LayerTree::Config(),
+                                                      SkISize::Make(600, 800));
+        animator->Render(std::move(layer_tree), 1.0);
         task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
       },
       // See kNotifyIdleTaskWaitTime in animator.cc.
@@ -238,9 +238,9 @@ TEST_F(ShellTest, AnimatorDoesNotNotifyDelegateIfPipelineIsNotEmpty) {
     begin_frame_latch.Wait();
 
     PostTaskSync(task_runners.GetUITaskRunner(), [&] {
-      auto layer_tree =
-          std::make_shared<LayerTree>(SkISize::Make(600, 800), 1.0);
-      animator->Render(std::move(layer_tree));
+      auto layer_tree = std::make_unique<LayerTree>(LayerTree::Config(),
+                                                    SkISize::Make(600, 800));
+      animator->Render(std::move(layer_tree), 1.0);
     });
   }
 
diff --git a/shell/common/engine.cc b/shell/common/engine.cc
index 522ee89a52a7b..e63a19352f095 100644
--- a/shell/common/engine.cc
+++ b/shell/common/engine.cc
@@ -450,18 +450,18 @@ void Engine::ScheduleFrame(bool regenerate_layer_tree) {
   animator_->RequestFrame(regenerate_layer_tree);
 }
 
-void Engine::Render(std::shared_ptr<flutter::LayerTree> layer_tree) {
+void Engine::Render(std::unique_ptr<flutter::LayerTree> layer_tree,
+                    float device_pixel_ratio) {
   if (!layer_tree) {
     return;
   }
 
   // Ensure frame dimensions are sane.
-  if (layer_tree->frame_size().isEmpty() ||
-      layer_tree->device_pixel_ratio() <= 0.0f) {
+  if (layer_tree->frame_size().isEmpty() || device_pixel_ratio <= 0.0f) {
     return;
   }
 
-  animator_->Render(std::move(layer_tree));
+  animator_->Render(std::move(layer_tree), device_pixel_ratio);
 }
 
 void Engine::UpdateSemantics(SemanticsNodeUpdates update,
diff --git a/shell/common/engine.h b/shell/common/engine.h
index c6ff37eae37a5..04bbae3e7c1b9 100644
--- a/shell/common/engine.h
+++ b/shell/common/engine.h
@@ -895,7 +895,8 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
   std::string DefaultRouteName() override;
 
   // |RuntimeDelegate|
-  void Render(std::shared_ptr<flutter::LayerTree> layer_tree) override;
+  void Render(std::unique_ptr<flutter::LayerTree> layer_tree,
+              float device_pixel_ratio) override;
 
   // |RuntimeDelegate|
   void UpdateSemantics(SemanticsNodeUpdates update,
diff --git a/shell/common/engine_unittests.cc b/shell/common/engine_unittests.cc
index 3bfdd000c37eb..6d181b2773595 100644
--- a/shell/common/engine_unittests.cc
+++ b/shell/common/engine_unittests.cc
@@ -51,7 +51,7 @@ class MockRuntimeDelegate : public RuntimeDelegate {
   MOCK_METHOD0(ImplicitViewEnabled, bool());
   MOCK_METHOD0(DefaultRouteName, std::string());
   MOCK_METHOD1(ScheduleFrame, void(bool));
-  MOCK_METHOD1(Render, void(std::shared_ptr<flutter::LayerTree>));
+  MOCK_METHOD2(Render, void(std::unique_ptr<flutter::LayerTree>, float));
   MOCK_METHOD2(UpdateSemantics,
                void(SemanticsNodeUpdates, CustomAccessibilityActionUpdates));
   MOCK_METHOD1(HandlePlatformMessage, void(std::unique_ptr<PlatformMessage>));
diff --git a/shell/common/pipeline.h b/shell/common/pipeline.h
index 1de4498e7f08c..00e67d1a4261f 100644
--- a/shell/common/pipeline.h
+++ b/shell/common/pipeline.h
@@ -252,12 +252,15 @@ class Pipeline {
 };
 
 struct LayerTreeItem {
-  LayerTreeItem(std::shared_ptr<LayerTree> layer_tree,
-                std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder)
+  LayerTreeItem(std::unique_ptr<LayerTree> layer_tree,
+                std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder,
+                float device_pixel_ratio)
       : layer_tree(std::move(layer_tree)),
-        frame_timings_recorder(std::move(frame_timings_recorder)) {}
-  std::shared_ptr<LayerTree> layer_tree;
+        frame_timings_recorder(std::move(frame_timings_recorder)),
+        device_pixel_ratio(device_pixel_ratio) {}
+  std::unique_ptr<LayerTree> layer_tree;
   std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder;
+  float device_pixel_ratio;
 };
 
 using LayerTreePipeline = Pipeline<LayerTreeItem>;
diff --git a/shell/common/rasterizer.cc b/shell/common/rasterizer.cc
index 3b01c5c9bb0a9..3041e84d2706c 100644
--- a/shell/common/rasterizer.cc
+++ b/shell/common/rasterizer.cc
@@ -167,8 +167,8 @@ void Rasterizer::DrawLastLayerTree(
   if (!last_layer_tree_ || !surface_) {
     return;
   }
-  RasterStatus raster_status =
-      DrawToSurface(*frame_timings_recorder, *last_layer_tree_);
+  RasterStatus raster_status = DrawToSurface(
+      *frame_timings_recorder, *last_layer_tree_, last_device_pixel_ratio_);
 
   // EndFrame should perform cleanups for the external_view_embedder.
   if (external_view_embedder_ && external_view_embedder_->GetUsedThisFrame()) {
@@ -195,14 +195,15 @@ RasterStatus Rasterizer::Draw(
   RasterStatus raster_status = RasterStatus::kFailed;
   LayerTreePipeline::Consumer consumer =
       [&](std::unique_ptr<LayerTreeItem> item) {
-        std::shared_ptr<LayerTree> layer_tree = std::move(item->layer_tree);
+        std::unique_ptr<LayerTree> layer_tree = std::move(item->layer_tree);
         std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder =
             std::move(item->frame_timings_recorder);
+        float device_pixel_ratio = item->device_pixel_ratio;
         if (discard_callback(*layer_tree.get())) {
           raster_status = RasterStatus::kDiscarded;
         } else {
-          raster_status =
-              DoDraw(std::move(frame_timings_recorder), std::move(layer_tree));
+          raster_status = DoDraw(std::move(frame_timings_recorder),
+                                 std::move(layer_tree), device_pixel_ratio);
         }
       };
 
@@ -216,7 +217,8 @@ RasterStatus Rasterizer::Draw(
   bool should_resubmit_frame = ShouldResubmitFrame(raster_status);
   if (should_resubmit_frame) {
     auto resubmitted_layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(resubmitted_layer_tree_), std::move(resubmitted_recorder_));
+        std::move(resubmitted_layer_tree_), std::move(resubmitted_recorder_),
+        resubmitted_pixel_ratio_);
     auto front_continuation = pipeline->ProduceIfEmpty();
     PipelineProduceResult result =
         front_continuation.Complete(std::move(resubmitted_layer_tree_item));
@@ -375,7 +377,8 @@ fml::Milliseconds Rasterizer::GetFrameBudget() const {
 
 RasterStatus Rasterizer::DoDraw(
     std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder,
-    std::shared_ptr<flutter::LayerTree> layer_tree) {
+    std::unique_ptr<flutter::LayerTree> layer_tree,
+    float device_pixel_ratio) {
   TRACE_EVENT_WITH_FRAME_NUMBER(frame_timings_recorder, "flutter",
                                 "Rasterizer::DoDraw");
   FML_DCHECK(delegate_.GetTaskRunners()
@@ -390,10 +393,12 @@ RasterStatus Rasterizer::DoDraw(
   persistent_cache->ResetStoredNewShaders();
 
   RasterStatus raster_status =
-      DrawToSurface(*frame_timings_recorder, *layer_tree);
+      DrawToSurface(*frame_timings_recorder, *layer_tree, device_pixel_ratio);
   if (raster_status == RasterStatus::kSuccess) {
     last_layer_tree_ = std::move(layer_tree);
+    last_device_pixel_ratio_ = device_pixel_ratio;
   } else if (ShouldResubmitFrame(raster_status)) {
+    resubmitted_pixel_ratio_ = device_pixel_ratio;
     resubmitted_layer_tree_ = std::move(layer_tree);
     resubmitted_recorder_ = frame_timings_recorder->CloneUntil(
         FrameTimingsRecorder::State::kBuildEnd);
@@ -476,20 +481,22 @@ RasterStatus Rasterizer::DoDraw(
 
 RasterStatus Rasterizer::DrawToSurface(
     FrameTimingsRecorder& frame_timings_recorder,
-    flutter::LayerTree& layer_tree) {
+    flutter::LayerTree& layer_tree,
+    float device_pixel_ratio) {
   TRACE_EVENT0("flutter", "Rasterizer::DrawToSurface");
   FML_DCHECK(surface_);
 
   RasterStatus raster_status;
   if (surface_->AllowsDrawingWhenGpuDisabled()) {
-    raster_status = DrawToSurfaceUnsafe(frame_timings_recorder, layer_tree);
+    raster_status = DrawToSurfaceUnsafe(frame_timings_recorder, layer_tree,
+                                        device_pixel_ratio);
   } else {
     delegate_.GetIsGpuDisabledSyncSwitch()->Execute(
         fml::SyncSwitch::Handlers()
             .SetIfTrue([&] { raster_status = RasterStatus::kDiscarded; })
             .SetIfFalse([&] {
-              raster_status =
-                  DrawToSurfaceUnsafe(frame_timings_recorder, layer_tree);
+              raster_status = DrawToSurfaceUnsafe(
+                  frame_timings_recorder, layer_tree, device_pixel_ratio);
             }));
   }
 
@@ -501,7 +508,8 @@ RasterStatus Rasterizer::DrawToSurface(
 /// \see Rasterizer::DrawToSurface
 RasterStatus Rasterizer::DrawToSurfaceUnsafe(
     FrameTimingsRecorder& frame_timings_recorder,
-    flutter::LayerTree& layer_tree) {
+    flutter::LayerTree& layer_tree,
+    float device_pixel_ratio) {
   FML_DCHECK(surface_);
 
   compositor_context_->ui_time().SetLapTime(
@@ -512,8 +520,8 @@ RasterStatus Rasterizer::DrawToSurfaceUnsafe(
     FML_DCHECK(!external_view_embedder_->GetUsedThisFrame());
     external_view_embedder_->SetUsedThisFrame(true);
     external_view_embedder_->BeginFrame(
-        layer_tree.frame_size(), surface_->GetContext(),
-        layer_tree.device_pixel_ratio(), raster_thread_merger_);
+        layer_tree.frame_size(), surface_->GetContext(), device_pixel_ratio,
+        raster_thread_merger_);
     embedder_root_canvas = external_view_embedder_->GetRootCanvas();
   }
 
diff --git a/shell/common/rasterizer.h b/shell/common/rasterizer.h
index 23227f5d67618..b17242342c084 100644
--- a/shell/common/rasterizer.h
+++ b/shell/common/rasterizer.h
@@ -556,13 +556,16 @@ class Rasterizer final : public SnapshotDelegate,
 
   RasterStatus DoDraw(
       std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder,
-      std::shared_ptr<flutter::LayerTree> layer_tree);
+      std::unique_ptr<flutter::LayerTree> layer_tree,
+      float device_pixel_ratio);
 
   RasterStatus DrawToSurface(FrameTimingsRecorder& frame_timings_recorder,
-                             flutter::LayerTree& layer_tree);
+                             flutter::LayerTree& layer_tree,
+                             float device_pixel_ratio);
 
   RasterStatus DrawToSurfaceUnsafe(FrameTimingsRecorder& frame_timings_recorder,
-                                   flutter::LayerTree& layer_tree);
+                                   flutter::LayerTree& layer_tree,
+                                   float device_pixel_ratio);
 
   void FireNextFrameCallbackIfPresent();
 
@@ -576,12 +579,14 @@ class Rasterizer final : public SnapshotDelegate,
   std::unique_ptr<SnapshotSurfaceProducer> snapshot_surface_producer_;
   std::unique_ptr<flutter::CompositorContext> compositor_context_;
   // This is the last successfully rasterized layer tree.
-  std::shared_ptr<flutter::LayerTree> last_layer_tree_;
+  std::unique_ptr<flutter::LayerTree> last_layer_tree_;
+  float last_device_pixel_ratio_;
   // Set when we need attempt to rasterize the layer tree again. This layer_tree
   // has not successfully rasterized. This can happen due to the change in the
   // thread configuration. This will be inserted to the front of the pipeline.
-  std::shared_ptr<flutter::LayerTree> resubmitted_layer_tree_;
+  std::unique_ptr<flutter::LayerTree> resubmitted_layer_tree_;
   std::unique_ptr<FrameTimingsRecorder> resubmitted_recorder_;
+  float resubmitted_pixel_ratio_;
   fml::closure next_frame_callback_;
   bool user_override_resource_cache_bytes_;
   std::optional<size_t> max_cache_bytes_;
diff --git a/shell/common/rasterizer_unittests.cc b/shell/common/rasterizer_unittests.cc
index 6ab77b53401ba..a7b3429e45fad 100644
--- a/shell/common/rasterizer_unittests.cc
+++ b/shell/common/rasterizer_unittests.cc
@@ -27,6 +27,8 @@ using testing::ReturnRef;
 
 namespace flutter {
 namespace {
+constexpr float kDevicePixelRatio = 2.0f;
+
 class MockDelegate : public Rasterizer::Delegate {
  public:
   MOCK_METHOD1(OnFrameRasterized, void(const FrameTiming& frame_timing));
@@ -185,10 +187,12 @@ TEST(RasterizerTest,
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree =
+        std::make_unique<LayerTree>(/*config=*/LayerTree::Config(),
+                                    /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -250,10 +254,11 @@ TEST(
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -321,10 +326,10 @@ TEST(
   rasterizer->Setup(std::move(surface));
 
   auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-  auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                /*device_pixel_ratio=*/2.0f);
+  auto layer_tree = std::make_unique<LayerTree>(/*config=*/LayerTree::Config(),
+                                                /*frame_size=*/SkISize());
   auto layer_tree_item = std::make_unique<LayerTreeItem>(
-      std::move(layer_tree), CreateFinishedBuildRecorder());
+      std::move(layer_tree), CreateFinishedBuildRecorder(), kDevicePixelRatio);
   PipelineProduceResult result =
       pipeline->Produce().Complete(std::move(layer_tree_item));
   EXPECT_TRUE(result.success);
@@ -395,10 +400,10 @@ TEST(RasterizerTest,
   rasterizer->Setup(std::move(surface));
 
   auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-  auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                /*device_pixel_ratio=*/2.0f);
+  auto layer_tree = std::make_unique<LayerTree>(/*config=*/LayerTree::Config(),
+                                                /*frame_size=*/SkISize());
   auto layer_tree_item = std::make_unique<LayerTreeItem>(
-      std::move(layer_tree), CreateFinishedBuildRecorder());
+      std::move(layer_tree), CreateFinishedBuildRecorder(), kDevicePixelRatio);
   PipelineProduceResult result =
       pipeline->Produce().Complete(std::move(layer_tree_item));
   EXPECT_TRUE(result.success);
@@ -444,10 +449,11 @@ TEST(RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet) {
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -499,10 +505,11 @@ TEST(RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNotUsedThisFrame) {
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -601,10 +608,11 @@ TEST(RasterizerTest,
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -658,10 +666,11 @@ TEST(
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -715,10 +724,11 @@ TEST(
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -771,10 +781,11 @@ TEST(
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -826,10 +837,11 @@ TEST(
   fml::AutoResetWaitableEvent latch;
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder());
+        std::move(layer_tree), CreateFinishedBuildRecorder(),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
@@ -904,11 +916,11 @@ TEST(RasterizerTest,
     rasterizer->Setup(std::move(surface));
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
     for (int i = 0; i < 2; i++) {
-      auto layer_tree =
-          std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                      /*device_pixel_ratio=*/2.0f);
+      auto layer_tree = std::make_unique<LayerTree>(
+          /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
       auto layer_tree_item = std::make_unique<LayerTreeItem>(
-          std::move(layer_tree), CreateFinishedBuildRecorder(timestamps[i]));
+          std::move(layer_tree), CreateFinishedBuildRecorder(timestamps[i]),
+          kDevicePixelRatio);
       PipelineProduceResult result =
           pipeline->Produce().Complete(std::move(layer_tree_item));
       EXPECT_TRUE(result.success);
@@ -1075,11 +1087,11 @@ TEST(RasterizerTest, presentationTimeSetWhenVsyncTargetInFuture) {
     rasterizer->Setup(std::move(surface));
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
     for (int i = 0; i < 2; i++) {
-      auto layer_tree =
-          std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                      /*device_pixel_ratio=*/2.0f);
+      auto layer_tree = std::make_unique<LayerTree>(
+          /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
       auto layer_tree_item = std::make_unique<LayerTreeItem>(
-          std::move(layer_tree), CreateFinishedBuildRecorder(timestamps[i]));
+          std::move(layer_tree), CreateFinishedBuildRecorder(timestamps[i]),
+          kDevicePixelRatio);
       PipelineProduceResult result =
           pipeline->Produce().Complete(std::move(layer_tree_item));
       EXPECT_TRUE(result.success);
@@ -1155,10 +1167,11 @@ TEST(RasterizerTest, presentationTimeNotSetWhenVsyncTargetInPast) {
   thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
     rasterizer->Setup(std::move(surface));
     auto pipeline = std::make_shared<LayerTreePipeline>(/*depth=*/10);
-    auto layer_tree = std::make_shared<LayerTree>(/*frame_size=*/SkISize(),
-                                                  /*device_pixel_ratio=*/2.0f);
+    auto layer_tree = std::make_unique<LayerTree>(
+        /*config=*/LayerTree::Config(), /*frame_size=*/SkISize());
     auto layer_tree_item = std::make_unique<LayerTreeItem>(
-        std::move(layer_tree), CreateFinishedBuildRecorder(first_timestamp));
+        std::move(layer_tree), CreateFinishedBuildRecorder(first_timestamp),
+        kDevicePixelRatio);
     PipelineProduceResult result =
         pipeline->Produce().Complete(std::move(layer_tree_item));
     EXPECT_TRUE(result.success);
diff --git a/shell/common/shell_test.cc b/shell/common/shell_test.cc
index a799e6bcb4811..6cef594385a6c 100644
--- a/shell/common/shell_test.cc
+++ b/shell/common/shell_test.cc
@@ -197,18 +197,19 @@ void ShellTest::PumpOneFrame(Shell* shell,
   fml::WeakPtr<RuntimeDelegate> runtime_delegate = shell->weak_engine_;
   shell->GetTaskRunners().GetUITaskRunner()->PostTask(
       [&latch, runtime_delegate, &builder, viewport_metrics]() {
-        auto layer_tree = std::make_shared<LayerTree>(
-            SkISize::Make(viewport_metrics.physical_width,
-                          viewport_metrics.physical_height),
-            static_cast<float>(viewport_metrics.device_pixel_ratio));
         SkMatrix identity;
         identity.setIdentity();
         auto root_layer = std::make_shared<TransformLayer>(identity);
-        layer_tree->set_root_layer(root_layer);
+        auto layer_tree = std::make_unique<LayerTree>(
+            LayerTree::Config{.root_layer = root_layer},
+            SkISize::Make(viewport_metrics.physical_width,
+                          viewport_metrics.physical_height));
+        float device_pixel_ratio =
+            static_cast<float>(viewport_metrics.device_pixel_ratio);
         if (builder) {
           builder(root_layer);
         }
-        runtime_delegate->Render(std::move(layer_tree));
+        runtime_delegate->Render(std::move(layer_tree), device_pixel_ratio);
         latch.Signal();
       });
   latch.Wait();