Remove dead metrics code

Author: arbreng

flow/layers/fuchsia_layer_unittests.cc

@@ -275,8 +275,6 @@ std::unique_ptr<TestContext> InitTest() {
   // Init SceneUpdateContext.
   context->scene_update_context =
       std::make_unique<SceneUpdateContext>(context->session.get());
-  context->scene_update_context->set_metrics(
-      fidl::MakeOptional(fuchsia::ui::gfx::Metrics{1.f, 1.f, 1.f}));
 
   // Init PrerollContext.
   context->preroll_context = std::unique_ptr<PrerollContext>(new PrerollContext{

flow/layers/layer_tree.cc

@@ -11,12 +11,14 @@
 
 namespace flutter {
 
-LayerTree::LayerTree(const SkISize& frame_size, float frame_device_pixel_ratio)
+LayerTree::LayerTree(const SkISize& frame_size, float device_pixel_ratio)
     : frame_size_(frame_size),
-      frame_device_pixel_ratio_(frame_device_pixel_ratio),
+      device_pixel_ratio_(device_pixel_ratio),
       rasterizer_tracing_threshold_(0),
       checkerboard_raster_cache_images_(false),
-      checkerboard_offscreen_layers_(false) {}
+      checkerboard_offscreen_layers_(false) {
+  FML_CHECK(device_pixel_ratio_ != 0.0f);
+}
 
 void LayerTree::RecordBuildTime(fml::TimePoint build_start,
                                 fml::TimePoint target_time) {
@@ -51,7 +53,7 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
       frame.context().ui_time(),
       frame.context().texture_registry(),
       checkerboard_offscreen_layers_,
-      frame_device_pixel_ratio_};
+      device_pixel_ratio_};
 
   root_layer_->Preroll(&context, frame.root_surface_transformation());
   return context.surface_needs_readback;
@@ -62,19 +64,8 @@ void LayerTree::UpdateScene(SceneUpdateContext& context,
                             scenic::ContainerNode& container) {
   TRACE_EVENT0("flutter", "LayerTree::UpdateScene");
 
-  // Ensure the context is aware of the view metrics.
-  context.set_dimensions(frame_size_, frame_device_pixel_ratio_);
-
-  const auto& metrics = context.metrics();
-  FML_DCHECK(metrics->scale_x > 0.0f);
-  FML_DCHECK(metrics->scale_y > 0.0f);
-  FML_DCHECK(metrics->scale_z > 0.0f);
-
-  SceneUpdateContext::Transform transform(context,                  // context
-                                          1.0f / metrics->scale_x,  // X
-                                          1.0f / metrics->scale_y,  // Y
-                                          1.0f / metrics->scale_z   // Z
-  );
+  const float inv_dpr = 1.0f / device_pixel_ratio_;
+  SceneUpdateContext::Transform transform(context, inv_dpr, inv_dpr, 1.0f);
 
   SceneUpdateContext::Frame frame(
       context,
@@ -120,7 +111,7 @@ void LayerTree::Paint(CompositorContext::ScopedFrame& frame,
       frame.context().texture_registry(),
       ignore_raster_cache ? nullptr : &frame.context().raster_cache(),
       checkerboard_offscreen_layers_,
-      frame_device_pixel_ratio_};
+      device_pixel_ratio_};
 
   if (root_layer_->needs_painting())
     root_layer_->Paint(context);
@@ -144,18 +135,18 @@ sk_sp<SkPicture> LayerTree::Flatten(const SkRect& bounds) {
   root_surface_transformation.reset();
 
   PrerollContext preroll_context{
-      nullptr,                   // raster_cache (don't consult the cache)
-      nullptr,                   // gr_context  (used for the raster cache)
-      nullptr,                   // external view embedder
-      unused_stack,              // mutator stack
-      nullptr,                   // SkColorSpace* dst_color_space
-      kGiantRect,                // SkRect cull_rect
-      false,                     // layer reads from surface
-      unused_stopwatch,          // frame time (dont care)
-      unused_stopwatch,          // engine time (dont care)
-      unused_texture_registry,   // texture registry (not supported)
-      false,                     // checkerboard_offscreen_layers
-      frame_device_pixel_ratio_  // ratio between logical and physical
+      nullptr,                  // raster_cache (don't consult the cache)
+      nullptr,                  // gr_context  (used for the raster cache)
+      nullptr,                  // external view embedder
+      unused_stack,             // mutator stack
+      nullptr,                  // SkColorSpace* dst_color_space
+      kGiantRect,               // SkRect cull_rect
+      false,                    // layer reads from surface
+      unused_stopwatch,         // frame time (dont care)
+      unused_stopwatch,         // engine time (dont care)
+      unused_texture_registry,  // texture registry (not supported)
+      false,                    // checkerboard_offscreen_layers
+      device_pixel_ratio_       // ratio between logical and physical
   };
 
   SkISize canvas_size = canvas->getBaseLayerSize();
@@ -167,12 +158,12 @@ sk_sp<SkPicture> LayerTree::Flatten(const SkRect& bounds) {
       canvas,  // canvas
       nullptr,
       nullptr,
-      unused_stopwatch,          // frame time (dont care)
-      unused_stopwatch,          // engine time (dont care)
-      unused_texture_registry,   // texture registry (not supported)
-      nullptr,                   // raster cache
-      false,                     // checkerboard offscreen layers
-      frame_device_pixel_ratio_  // ratio between logical and physical
+      unused_stopwatch,         // frame time (dont care)
+      unused_stopwatch,         // engine time (dont care)
+      unused_texture_registry,  // texture registry (not supported)
+      nullptr,                  // raster cache
+      false,                    // checkerboard offscreen layers
+      device_pixel_ratio_       // ratio between logical and physical
   };
 
   // Even if we don't have a root layer, we still need to create an empty

flow/layers/layer_tree.h

@@ -20,7 +20,7 @@ namespace flutter {
 
 class LayerTree {
  public:
-  LayerTree(const SkISize& frame_size, float frame_device_pixel_ratio);
+  LayerTree(const SkISize& frame_size, float device_pixel_ratio);
 
   // Perform a preroll pass on the tree and return information about
   // the tree that affects rendering this frame.
@@ -49,7 +49,7 @@ class LayerTree {
   }
 
   const SkISize& frame_size() const { return frame_size_; }
-  float frame_device_pixel_ratio() const { return frame_device_pixel_ratio_; }
+  float device_pixel_ratio() const { return device_pixel_ratio_; }
 
   void RecordBuildTime(fml::TimePoint build_start, fml::TimePoint target_time);
   fml::TimePoint build_start() const { return build_start_; }
@@ -76,15 +76,13 @@ class LayerTree {
     checkerboard_offscreen_layers_ = checkerboard;
   }
 
-  double device_pixel_ratio() const { return frame_device_pixel_ratio_; }
-
  private:
   std::shared_ptr<Layer> root_layer_;
   fml::TimePoint build_start_;
   fml::TimePoint build_finish_;
   fml::TimePoint target_time_;
   SkISize frame_size_ = SkISize::MakeEmpty();  // Physical pixels.
-  float frame_device_pixel_ratio_ = 1.0f;  // Logical / Physical pixels ratio.
+  const float device_pixel_ratio_;  // Logical / Physical pixels ratio.
   uint32_t rasterizer_tracing_threshold_;
   bool checkerboard_raster_cache_images_;
   bool checkerboard_offscreen_layers_;

flow/scene_update_context.h

@@ -110,23 +110,8 @@ class SceneUpdateContext : public flutter::ExternalViewEmbedder {
   ~SceneUpdateContext() = default;
 
   scenic::Session* session() { return session_; }
-
   Entity* top_entity() { return top_entity_; }
 
-  bool has_metrics() const { return !!metrics_; }
-  void set_metrics(fuchsia::ui::gfx::MetricsPtr metrics) {
-    metrics_ = std::move(metrics);
-  }
-  const fuchsia::ui::gfx::MetricsPtr& metrics() const { return metrics_; }
-
-  void set_dimensions(const SkISize& frame_physical_size,
-                      float frame_device_pixel_ratio) {
-    frame_physical_size_ = frame_physical_size;
-    frame_device_pixel_ratio_ = frame_device_pixel_ratio;
-  }
-  const SkISize& frame_size() const { return frame_physical_size_; }
-  float frame_device_pixel_ratio() const { return frame_device_pixel_ratio_; }
-
   // The cumulative alpha value based on all the parent OpacityLayers.
   void set_alphaf(float alpha) { alpha_ = alpha; }
   float alphaf() { return alpha_; }
@@ -183,11 +168,6 @@ class SceneUpdateContext : public flutter::ExternalViewEmbedder {
 
   scenic::Session* const session_;
 
-  fuchsia::ui::gfx::MetricsPtr metrics_;
-  SkISize frame_physical_size_;
-  float frame_device_pixel_ratio_ =
-      1.0f;  // Ratio between logical and physical pixels.
-
   float alpha_ = 1.0f;
   float next_elevation_ = 0.0f;
 

shell/common/engine.cc

@@ -448,7 +448,7 @@ void Engine::Render(std::unique_ptr<flutter::LayerTree> layer_tree) {
 
   // Ensure frame dimensions are sane.
   if (layer_tree->frame_size().isEmpty() ||
-      layer_tree->frame_device_pixel_ratio() <= 0.0f)
+      layer_tree->device_pixel_ratio() <= 0.0f)
     return;
 
   animator_->Render(std::move(layer_tree));

shell/platform/fuchsia/flutter/compositor_context.cc

@@ -33,10 +33,6 @@ class ScopedFrame final : public flutter::CompositorContext::ScopedFrame {
 
   flutter::RasterStatus Raster(flutter::LayerTree& layer_tree,
                                bool ignore_raster_cache) override {
-    if (!session_connection_.has_metrics()) {
-      return flutter::RasterStatus::kSuccess;
-    }
-
     std::vector<flutter::SceneUpdateContext::PaintTask> frame_paint_tasks;
     std::vector<std::unique_ptr<SurfaceProducerSurface>> frame_surfaces;
 
@@ -102,12 +98,12 @@ class ScopedFrame final : public flutter::CompositorContext::ScopedFrame {
             context().texture_registry(),
             &context().raster_cache(),
             false,
-            layer_tree.frame_device_pixel_ratio()};
+            layer_tree.device_pixel_ratio()};
         canvas->restoreToCount(1);
         canvas->save();
         canvas->clear(task.background_color);
-        canvas->scale(layer_tree.frame_device_pixel_ratio() * task.scale_x,
-                      layer_tree.frame_device_pixel_ratio() * task.scale_y);
+        canvas->scale(layer_tree.device_pixel_ratio() * task.scale_x,
+                      layer_tree.device_pixel_ratio() * task.scale_y);
         canvas->translate(-task.paint_bounds.left(), -task.paint_bounds.top());
         for (flutter::Layer* layer : task.layers) {
           layer->Paint(paint_context);
@@ -145,11 +141,6 @@ CompositorContext::CompositorContext(
           [](auto) {},
           vsync_event_handle) {}
 
-void CompositorContext::OnSessionMetricsDidChange(
-    const fuchsia::ui::gfx::Metrics& metrics) {
-  session_connection_.set_metrics(metrics);
-}
-
 void CompositorContext::OnWireframeEnabled(bool enabled) {
   session_connection_.set_enable_wireframe(enabled);
 }

shell/platform/fuchsia/flutter/compositor_context.h

@@ -30,7 +30,6 @@ class CompositorContext final : public flutter::CompositorContext {
 
   ~CompositorContext() override;
 
-  void OnSessionMetricsDidChange(const fuchsia::ui::gfx::Metrics& metrics);
   void OnWireframeEnabled(bool enabled);
   void OnCreateView(int64_t view_id, bool hit_testable, bool focusable);
   void OnDestroyView(int64_t view_id);

shell/platform/fuchsia/flutter/engine.cc

@@ -93,10 +93,6 @@ Engine::Engine(Delegate& delegate,
   environment->GetServices(parent_environment_service_provider.NewRequest());
   environment.Unbind();
 
-  // We need to manually schedule a frame when the session metrics change.
-  OnMetricsUpdate on_session_metrics_change_callback = std::bind(
-      &Engine::OnSessionMetricsDidChange, this, std::placeholders::_1);
-
   OnEnableWireframe on_enable_wireframe_callback = std::bind(
       &Engine::OnDebugWireframeSettingsChanged, this, std::placeholders::_1);
 
@@ -137,8 +133,6 @@ Engine::Engine(Delegate& delegate,
            session_listener_request = std::move(session_listener_request),
            on_session_listener_error_callback =
                std::move(on_session_listener_error_callback),
-           on_session_metrics_change_callback =
-               std::move(on_session_metrics_change_callback),
            on_enable_wireframe_callback =
                std::move(on_enable_wireframe_callback),
            on_create_view_callback = std::move(on_create_view_callback),
@@ -156,7 +150,6 @@ Engine::Engine(Delegate& delegate,
                 std::move(parent_environment_service_provider),  // services
                 std::move(session_listener_request),  // session listener
                 std::move(on_session_listener_error_callback),
-                std::move(on_session_metrics_change_callback),
                 std::move(on_enable_wireframe_callback),
                 std::move(on_create_view_callback),
                 std::move(on_destroy_view_callback),
@@ -478,24 +471,6 @@ void Engine::Terminate() {
   // collected this object.
 }
 
-void Engine::OnSessionMetricsDidChange(
-    const fuchsia::ui::gfx::Metrics& metrics) {
-  if (!shell_) {
-    return;
-  }
-
-  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
-      [rasterizer = shell_->GetRasterizer(), metrics]() {
-        if (rasterizer) {
-          auto compositor_context =
-              reinterpret_cast<flutter_runner::CompositorContext*>(
-                  rasterizer->compositor_context());
-
-          compositor_context->OnSessionMetricsDidChange(metrics);
-        }
-      });
-}
-
 void Engine::OnDebugWireframeSettingsChanged(bool enabled) {
   if (!shell_) {
     return;

shell/platform/fuchsia/flutter/engine.h

@@ -71,7 +71,6 @@ class Engine final {
 
   void Terminate();
 
-  void OnSessionMetricsDidChange(const fuchsia::ui::gfx::Metrics& metrics);
   void OnDebugWireframeSettingsChanged(bool enabled);
   void OnCreateView(int64_t view_id, bool hit_testable, bool focusable);
   void OnDestroyView(int64_t view_id);