[Impeller] Fix nullopt access in GetSubpassCoverage.

Author: bdero

impeller/entity/entity_pass.cc

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// FLUTTER_NOLINT: https://github.com/flutter/flutter/issues/132129
-
 #include "impeller/entity/entity_pass.h"
 
 #include <memory>
@@ -97,19 +95,20 @@ size_t EntityPass::GetSubpassesDepth() const {
 
 std::optional<Rect> EntityPass::GetElementsCoverage(
     std::optional<Rect> coverage_limit) const {
-  std::optional<Rect> result;
+  std::optional<Rect> accumulated_coverage;
   for (const auto& element : elements_) {
-    std::optional<Rect> coverage;
+    std::optional<Rect> element_coverage;
 
     if (auto entity = std::get_if<Entity>(&element)) {
-      coverage = entity->GetCoverage();
+      element_coverage = entity->GetCoverage();
 
       // When the coverage limit is std::nullopt, that means there is no limit,
       // as opposed to empty coverage.
-      if (coverage.has_value() && coverage_limit.has_value()) {
+      if (element_coverage.has_value() && coverage_limit.has_value()) {
         const auto* filter = entity->GetContents()->AsFilter();
         if (!filter || filter->IsTranslationOnly()) {
-          coverage = coverage->Intersection(coverage_limit.value());
+          element_coverage =
+              element_coverage->Intersection(coverage_limit.value());
         }
       }
     } else if (auto subpass_ptr =
@@ -122,17 +121,18 @@ std::optional<Rect> EntityPass::GetElementsCoverage(
       // If the current pass elements have any coverage so far and there's a
       // backdrop filter, then incorporate the backdrop filter in the
       // pre-filtered coverage of the subpass.
-      if (result.has_value() && subpass.backdrop_filter_proc_) {
+      if (accumulated_coverage.has_value() && subpass.backdrop_filter_proc_) {
         std::shared_ptr<FilterContents> backdrop_filter =
-            subpass.backdrop_filter_proc_(FilterInput::Make(result.value()),
-                                          subpass.xformation_,
-                                          Entity::RenderingMode::kSubpass);
+            subpass.backdrop_filter_proc_(
+                FilterInput::Make(accumulated_coverage.value()),
+                subpass.xformation_, Entity::RenderingMode::kSubpass);
         if (backdrop_filter) {
           auto backdrop_coverage = backdrop_filter->GetCoverage({});
-          backdrop_coverage->origin += result->origin;
           if (backdrop_coverage.has_value()) {
+            backdrop_coverage->origin += accumulated_coverage->origin;
             if (unfiltered_coverage.has_value()) {
-              unfiltered_coverage = coverage->Union(*backdrop_coverage);
+              unfiltered_coverage =
+                  unfiltered_coverage->Union(*backdrop_coverage);
             } else {
               unfiltered_coverage = backdrop_coverage;
             }
@@ -161,29 +161,31 @@ std::optional<Rect> EntityPass::GetElementsCoverage(
       if (image_filter) {
         Entity subpass_entity;
         subpass_entity.SetTransformation(subpass.xformation_);
-        coverage = image_filter->GetCoverage(subpass_entity);
+        element_coverage = image_filter->GetCoverage(subpass_entity);
       } else {
-        coverage = unfiltered_coverage;
+        element_coverage = unfiltered_coverage;
       }
 
-      if (coverage.has_value() && coverage_limit.has_value() &&
+      if (element_coverage.has_value() && coverage_limit.has_value() &&
           (!image_filter || image_filter->IsTranslationOnly())) {
-        coverage = coverage->Intersection(coverage_limit.value());
+        element_coverage =
+            element_coverage->Intersection(coverage_limit.value());
       }
     } else {
       FML_UNREACHABLE();
     }
 
-    if (!result.has_value() && coverage.has_value()) {
-      result = coverage;
+    if (!accumulated_coverage.has_value() && element_coverage.has_value()) {
+      accumulated_coverage = element_coverage;
       continue;
     }
-    if (!coverage.has_value()) {
+    if (!element_coverage.has_value()) {
       continue;
     }
-    result = result->Union(coverage.value());
+    accumulated_coverage =
+        accumulated_coverage->Union(element_coverage.value());
   }
-  return result;
+  return accumulated_coverage;
 }
 
 std::optional<Rect> EntityPass::GetSubpassCoverage(
@@ -760,13 +762,17 @@ bool EntityPass::RenderElement(Entity& element_entity,
   // rendered output will actually be used, and so we set this to the current
   // clip coverage (which is the max clip bounds). The contents may
   // optionally use this hint to avoid unnecessary rendering work.
-  if (element_entity.GetContents()->GetCoverageHint().has_value()) {
+  auto element_coverage_hint = element_entity.GetContents()->GetCoverageHint();
+  if (element_coverage_hint.has_value() &&
+      // If the `current_clip_coverage` is `std::nullopt`, just fall into the
+      // else case and let std::nullopt get assigned as the coverage hint.
+      current_clip_coverage.has_value()) {
     // If the element already has a coverage hint (because its an advanced
     // blend), then we need to intersect the clip coverage hint with the
     // existing coverage hint.
     element_entity.GetContents()->SetCoverageHint(
-        current_clip_coverage->Intersection(
-            element_entity.GetContents()->GetCoverageHint().value()));
+        element_coverage_hint.value().Intersection(
+            current_clip_coverage.value()));
   } else {
     element_entity.GetContents()->SetCoverageHint(current_clip_coverage);
   }