Right before dart_ui.cc

Author: dkwingsmt

lib/ui/compositing/scene.cc

@@ -40,13 +40,6 @@ 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();
-  device_pixel_ratio_ = static_cast<float>(viewport_metrics.device_pixel_ratio);
-
   layer_tree_config_ = std::make_unique<LayerTree::Config>();
   layer_tree_config_->root_layer = std::move(rootLayer);
   layer_tree_config_->rasterizer_tracing_threshold = rasterizerTracingThreshold;
@@ -67,26 +60,30 @@ Dart_Handle Scene::toImageSync(uint32_t width,
                                uint32_t height,
                                Dart_Handle raw_image_handle) {
   TRACE_EVENT0("flutter", "Scene::toImageSync");
+  double pixel_ratio = 1.0f;  // TODO(dkwingsmt)
 
   if (!layer_tree_config_) {
     return tonic::ToDart("Scene's layer tree has been taken away.");
   }
 
-  Scene::RasterizeToImage(width, height, raw_image_handle);
+  Scene::RasterizeToImage(width, height, static_cast<float>(pixel_ratio),
+                          raw_image_handle);
   return Dart_Null();
 }
 
 Dart_Handle Scene::toImage(uint32_t width,
                            uint32_t height,
                            Dart_Handle raw_image_callback) {
   TRACE_EVENT0("flutter", "Scene::toImage");
+  double pixel_ratio = 1.0f;  // TODO(dkwingsmt)
 
   if (!layer_tree_config_) {
     return tonic::ToDart("Scene's layer tree has been taken away.");
   }
 
   return Picture::RasterizeLayerTreeToImage(
-      BuildLayerTree(width, height, device_pixel_ratio_), raw_image_callback);
+      BuildLayerTree(width, height, static_cast<float>(pixel_ratio)),
+      raw_image_callback);
 }
 
 static sk_sp<DlImage> CreateDeferredImage(
@@ -114,6 +111,7 @@ static sk_sp<DlImage> CreateDeferredImage(
 
 void Scene::RasterizeToImage(uint32_t width,
                              uint32_t height,
+                             float pixel_ratio,
                              Dart_Handle raw_image_handle) {
   auto* dart_state = UIDartState::Current();
   if (!dart_state) {
@@ -126,17 +124,17 @@ void Scene::RasterizeToImage(uint32_t width,
   auto image = CanvasImage::Create();
   auto dl_image = CreateDeferredImage(
       dart_state->IsImpellerEnabled(),
-      BuildLayerTree(width, height, device_pixel_ratio_),
-      std::move(snapshot_delegate), std::move(raster_task_runner),
-      std::move(unref_queue));
+      BuildLayerTree(width, height, pixel_ratio), std::move(snapshot_delegate),
+      std::move(raster_task_runner), std::move(unref_queue));
   image->set_image(dl_image);
   image->AssociateWithDartWrapper(raw_image_handle);
 }
 
 std::unique_ptr<flutter::LayerTree> Scene::takeLayerTree(uint64_t width,
-                                                         uint64_t height) {
+                                                         uint64_t height,
+                                                         float pixel_ratio) {
   if (layer_tree_config_ != nullptr) {
-    auto layer_tree = BuildLayerTree(width, height, device_pixel_ratio_);
+    auto layer_tree = BuildLayerTree(width, height, pixel_ratio);
     // TODO(dkwingsmt): We don't need to reset here. But certain unit tests test
     // it. Let's keep it this way for now.
     layer_tree_config_.reset();
@@ -149,6 +147,7 @@ std::unique_ptr<flutter::LayerTree> Scene::takeLayerTree(uint64_t width,
 std::unique_ptr<LayerTree> Scene::BuildLayerTree(uint32_t width,
                                                  uint32_t height,
                                                  float pixel_ratio) {
+  FML_CHECK(layer_tree_config_ != nullptr);
   return std::make_unique<LayerTree>(*layer_tree_config_,
                                      SkISize::Make(width, height), pixel_ratio);
 }

lib/ui/compositing/scene.h

@@ -27,7 +27,8 @@ class Scene : public RefCountedDartWrappable<Scene> {
                      bool checkerboardOffscreenLayers);
 
   std::unique_ptr<flutter::LayerTree> takeLayerTree(uint64_t width,
-                                                    uint64_t height);
+                                                    uint64_t height,
+                                                    float pixel_ratio);
 
   Dart_Handle toImageSync(uint32_t width,
                           uint32_t height,
@@ -47,14 +48,15 @@ class Scene : public RefCountedDartWrappable<Scene> {
 
   void RasterizeToImage(uint32_t width,
                         uint32_t height,
+                        float pixel_ratio,
                         Dart_Handle raw_image_handle);
 
   std::unique_ptr<LayerTree> BuildLayerTree(uint32_t width,
                                             uint32_t height,
                                             float pixel_ratio);
 
+  // No longer valid after calling `takeLayerTreeConfig`.
   std::unique_ptr<flutter::LayerTree::Config> layer_tree_config_;
-  float device_pixel_ratio_;
 };
 
 }  // namespace flutter

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(100, 100));
+        EXPECT_FALSE(retained_scene->takeLayerTree(100, 100, 1.0f));
         retained_scene->Release();
         retained_scene = nullptr;
         message_latch->Signal();

lib/ui/painting/picture.cc

@@ -125,6 +125,7 @@ Dart_Handle Picture::RasterizeToImage(const sk_sp<DisplayList>& display_list,
 Dart_Handle Picture::RasterizeLayerTreeToImage(
     std::unique_ptr<LayerTree> layer_tree,
     Dart_Handle 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);
@@ -135,6 +136,9 @@ Dart_Handle Picture::DoRasterizeToImage(const sk_sp<DisplayList>& display_list,
                                         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");
   }
@@ -198,10 +202,11 @@ Dart_Handle Picture::DoRasterizeToImage(const sk_sp<DisplayList>& display_list,
   fml::TaskRunner::RunNowOrPostTask(
       raster_task_runner,
       fml::MakeCopyable([ui_task_runner, snapshot_delegate, display_list,
-                         picture_bounds, ui_task,
+                         &picture_bounds, ui_task,
                          layer_tree = std::move(layer_tree)]() mutable {
         sk_sp<DlImage> image;
         if (layer_tree) {
+          FML_DCHECK(picture_bounds == layer_tree->frame_size());
           auto display_list = layer_tree->Flatten(
               SkRect::MakeWH(picture_bounds.width(), picture_bounds.height()),
               snapshot_delegate->GetTextureRegistry(),

lib/ui/painting/picture.h

@@ -52,9 +52,10 @@ class Picture : public RefCountedDartWrappable<Picture> {
       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.
+  // 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,

runtime/runtime_controller.cc

@@ -325,7 +325,8 @@ void RuntimeController::Render(Scene* scene) {
   }
   const auto& viewport_metrics = window->viewport_metrics();
   client_.Render(scene->takeLayerTree(viewport_metrics.physical_width,
-                                      viewport_metrics.physical_height));
+                                      viewport_metrics.physical_height,
+                                      viewport_metrics.device_pixel_ratio));
 }
 
 // |PlatformConfigurationClient|