Connect

Author: dkwingsmt

lib/ui/compositing.dart

@@ -21,21 +21,21 @@ class Scene extends NativeFieldWrapperClass1 {
   /// Synchronously creates a handle to an image from this scene.
   ///
   /// {@macro dart.ui.painting.Picture.toImageSync}
-  Image toImageSync(int width, int height) {
+  Image toImageSync(int width, int height, [double pixelRatio = 1.0]) {
     if (width <= 0 || height <= 0) {
       throw Exception('Invalid image dimensions.');
     }
 
     final _Image image = _Image._();
-    final String? result =  _toImageSync(width, height, image);
+    final String? result =  _toImageSync(width, height, pixelRatio, image);
     if (result != null) {
       throw PictureRasterizationException._(result);
     }
     return Image._(image, image.width, image.height);
   }
 
-  @Native<Handle Function(Pointer<Void>, Uint32, Uint32, Handle)>(symbol: 'Scene::toImageSync')
-  external String? _toImageSync(int width, int height, _Image outImage);
+  @Native<Handle Function(Pointer<Void>, Uint32, Uint32, Double, Handle)>(symbol: 'Scene::toImageSync')
+  external String? _toImageSync(int width, int height, double pixelRatio, _Image outImage);
 
   /// Creates a raster image representation of the current state of the scene.
   ///
@@ -44,11 +44,11 @@ class Scene extends NativeFieldWrapperClass1 {
   /// Callers must dispose the [Image] when they are done with it. If the result
   /// will be shared with other methods or classes, [Image.clone] should be used
   /// and each handle created must be disposed.
-  Future<Image> toImage(int width, int height) {
+  Future<Image> toImage(int width, int height, [double pixelRatio = 1.0]) {
     if (width <= 0 || height <= 0) {
       throw Exception('Invalid image dimensions.');
     }
-    return _futurize((_Callback<Image?> callback) => _toImage(width, height, (_Image? image) {
+    return _futurize((_Callback<Image?> callback) => _toImage(width, height, pixelRatio, (_Image? image) {
         if (image == null) {
           callback(null);
         } else {
@@ -58,8 +58,8 @@ class Scene extends NativeFieldWrapperClass1 {
     );
   }
 
-  @Native<Handle Function(Pointer<Void>, Uint32, Uint32, Handle)>(symbol: 'Scene::toImage')
-  external String? _toImage(int width, int height, _Callback<_Image?> callback);
+  @Native<Handle Function(Pointer<Void>, Uint32, Uint32, Double, Handle)>(symbol: 'Scene::toImage')
+  external String? _toImage(int width, int height, double pixelRatio, _Callback<_Image?> callback);
 
   /// Releases the resources used by this scene.
   ///

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;
@@ -65,19 +58,22 @@ void Scene::dispose() {
 
 Dart_Handle Scene::toImageSync(uint32_t width,
                                uint32_t height,
+                               double pixel_ratio,
                                Dart_Handle raw_image_handle) {
   TRACE_EVENT0("flutter", "Scene::toImageSync");
 
   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,
+                           double pixel_ratio,
                            Dart_Handle raw_image_callback) {
   TRACE_EVENT0("flutter", "Scene::toImage");
 
@@ -86,7 +82,8 @@ Dart_Handle Scene::toImage(uint32_t width,
   }
 
   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,14 +27,17 @@ 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,
+                          double pixel_ratio,
                           Dart_Handle raw_image_handle);
 
   Dart_Handle toImage(uint32_t width,
                       uint32_t height,
+                      double pixel_ratio,
                       Dart_Handle raw_image_handle);
 
   void dispose();
@@ -47,14 +50,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/dart_ui.cc

@@ -293,8 +293,8 @@ typedef CanvasPath Path;
   V(SceneBuilder, setCheckerboardRasterCacheImages, 2) \
   V(SceneBuilder, setRasterizerTracingThreshold, 2)    \
   V(Scene, dispose, 1)                                 \
-  V(Scene, toImage, 4)                                 \
-  V(Scene, toImageSync, 4)                             \
+  V(Scene, toImage, 5)                                 \
+  V(Scene, toImageSync, 5)                             \
   V(SemanticsUpdateBuilder, build, 2)                  \
   V(SemanticsUpdateBuilder, updateCustomAction, 5)     \
   V(SemanticsUpdateBuilder, updateNode, 36)            \

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|