[Testing] CQ-CQ-700075-59167-59382-stoup

Author: ci_lynx

core/renderer/dom/element_manager.cc

@@ -989,6 +989,8 @@ void ElementManager::SetConfig(const std::shared_ptr<PageConfig> &config) {
           {.enable_native_schedule_create_view_async =
                config_->GetEnableNativeScheduleCreateViewAsyncAsBool()});
     }
+    enable_property_based_simple_style_ =
+        config_->GetEnablePropertyBasedSimpleStyle();
   }
 }
 

core/renderer/dom/element_manager.h

@@ -659,6 +659,9 @@ class ElementManager : public ElementContextDelegate {
 
   virtual bool IsDomTreeEnabled() { return dom_tree_enabled_; }
   bool GetEnableZIndex() { return config_ && config_->GetEnableZIndex(); }
+  bool EnablePropertyBasedSimpleStyle() const {
+    return enable_property_based_simple_style_;
+  }
 
   void InsertDirtyContext(BaseElementContainer *stacking_context) {
     dirty_stacking_contexts_.insert(stacking_context);
@@ -1306,6 +1309,7 @@ class ElementManager : public ElementContextDelegate {
   bool enable_fiber_element_memory_reporter_{false};
   bool enable_layout_in_element_mode_{false};
   bool enable_fragment_layer_render_{false};
+  bool enable_property_based_simple_style_{false};
 
   bool has_viewport_ready_{false};
   bool is_memory_collecting_{false};

core/renderer/dom/fiber/fiber_element.cc

@@ -44,6 +44,7 @@
 #include "core/renderer/dom/fiber/wrapper_element.h"
 #include "core/renderer/dom/fragment/fragment.h"
 #include "core/renderer/dom/list_component_info.h"
+#include "core/renderer/dom/style_resolver.h"
 #include "core/renderer/dom/vdom/radon/node_select_options.h"
 #include "core/renderer/dom/vdom/radon/node_selector.h"
 #include "core/renderer/page_proxy.h"
@@ -456,6 +457,11 @@ void FiberElement::SetStyleObjects(
   MarkDirty(kDirtyForceUpdate | kDirtyStyleObjects);
 }
 
+void FiberElement::UpdateSimpleStyles(tasm::StyleMap &&style_map) {
+  parsed_styles_map_ = std::move(style_map);
+  UpdateSimpleStyles(parsed_styles_map_);
+}
+
 void FiberElement::UpdateSimpleStyles(const tasm::StyleMap &style_map) {
   std::for_each(
       style_map.begin(), style_map.end(), [this](const auto &pair) -> void {
@@ -1492,9 +1498,16 @@ ParallelFlushReturn FiberElement::PrepareForCreateOrUpdate() {
 
   if (dirty_ & kDirtyStyleObjects) {
     TRACE_EVENT(LYNX_TRACE_CATEGORY, "FiberElement::HandleStyleObjects");
-    StyleResolver::ResolveStyleObjects(
-        last_style_objects_ ? last_style_objects_.get() : nullptr,
-        style_objects_ ? style_objects_.get() : nullptr, this);
+    if (element_manager_->EnablePropertyBasedSimpleStyle()) {
+      StyleResolver::ResolveStyleObjectsBasedOnExistingMap(
+          parsed_styles_map_, style_objects_ ? style_objects_.get() : nullptr,
+          this);
+    } else {
+      StyleResolver::ResolveStyleObjects(
+          last_style_objects_ ? last_style_objects_.get() : nullptr,
+          style_objects_ ? style_objects_.get() : nullptr, this);
+    }
+
     // Animation and Direction should be handled here
     dirty_ &= ~kDirtyStyleObjects;
   } else {

core/renderer/dom/fiber/fiber_element.h

@@ -565,7 +565,9 @@ class FiberElement : public Element,
    * @param style_map A constant reference to a tasm::StyleMap containing the
    *                  styles to be updated.
    */
-  void UpdateSimpleStyles(const tasm::StyleMap& style_map) override final;
+  void UpdateSimpleStyles(const tasm::StyleMap& style_map) final;
+
+  void UpdateSimpleStyles(tasm::StyleMap&& style_map) final;
 
   /**
    * @brief Reset the simple style associated with the specified CSS property

core/renderer/dom/style_resolver.cc

@@ -4,13 +4,14 @@
 
 #include "core/renderer/dom/style_resolver.h"
 
-#include <algorithm>
 #include <utility>
 
 #include "base/include/algorithm.h"
 #include "base/include/log/logging.h"
 #include "base/trace/native/trace_event.h"
+#include "core/renderer/css/css_property.h"
 #include "core/renderer/css/css_sheet.h"
+#include "core/renderer/css/css_value.h"
 #include "core/renderer/css/parser/css_string_parser.h"
 #include "core/renderer/dom/element.h"
 #include "core/renderer/dom/fiber/fiber_element.h"
@@ -140,6 +141,49 @@ void StyleResolver::ResolveStyleObjects(style::StyleObject** old_ptr,
   }
 }
 
+void StyleResolver::ResolveStyleObjectsBasedOnExistingMap(
+    const tasm::StyleMap& old_dcl_style, style::StyleObject** new_ptr,
+    style::SimpleStyleNode* target) {
+  // Early return if no new style objects and no existing styles
+  if (!new_ptr && old_dcl_style.empty()) {
+    return;
+  }
+
+  // Reserve space to avoid reallocations - estimate based on old + new
+  // properties
+  tasm::StyleMap resolved_property;
+  const size_t estimated_size = old_dcl_style.size() + (new_ptr ? 8 : 0);
+  resolved_property.reserve(estimated_size);
+
+  // Merge all properties from new style objects
+  if (new_ptr) {
+    for (auto** it = new_ptr; *it; ++it) {
+      (*it)->FromBinary();
+      resolved_property.merge((*it)->Properties());
+    }
+  }
+
+  // Update target only if we have resolved properties
+  if (!resolved_property.empty()) {
+    // Update to new style object.
+    // Reset any properties from old_dcl_style that don't exist in the new
+    // styles
+    for (const auto& [property_id, value] : old_dcl_style) {
+      if (!resolved_property.contains(property_id)) {
+        target->ResetSimpleStyle(property_id);
+      }
+    }
+
+    target->UpdateSimpleStyles(std::move(resolved_property));
+
+  } else {
+    // Reset every styles, since the new styleObject array is empty.
+    for (const auto& [property_id, value] : old_dcl_style) {
+      target->ResetSimpleStyle(property_id);
+    }
+  }
+}
+
 ElementManager* StyleResolver::manager() const {
   return element()->element_manager();
 }

core/renderer/dom/style_resolver.h

@@ -13,6 +13,7 @@
 #include "base/include/vector.h"
 #include "core/base/lynx_export.h"
 #include "core/renderer/css/css_fragment.h"
+#include "core/renderer/css/css_property.h"
 #include "core/renderer/css/css_selector_constants.h"
 #include "core/renderer/css/css_variable_handler.h"
 #include "core/renderer/css/dynamic_css_styles_manager.h"
@@ -61,6 +62,10 @@ class StyleResolver {
                                   style::StyleObject** new_ptr,
                                   style::SimpleStyleNode* target);
 
+  static void ResolveStyleObjectsBasedOnExistingMap(
+      const tasm::StyleMap& old_dcl_style, style::StyleObject** new_ptr,
+      style::SimpleStyleNode* target);
+
  private:
   enum class PseudoClassType { kFocus, kHover, kActive };
 

core/renderer/dom/style_resolver_unittest.cc

@@ -13,6 +13,8 @@
 #include "core/renderer/dom/element_manager.h"
 #include "core/renderer/dom/fiber/component_element.h"
 #include "core/renderer/dom/fiber/view_element.h"
+#include "core/renderer/simple_styling/simple_style_node.h"
+#include "core/renderer/simple_styling/style_object.h"
 #include "core/renderer/tasm/react/testing/mock_painting_context.h"
 #include "core/shell/tasm_operation_queue.h"
 #include "core/shell/testing/mock_tasm_delegate.h"
@@ -29,6 +31,42 @@ static constexpr double kDefaultPhysicalPixelsPerLayoutUnit = 1.f;
 
 using namespace css;
 
+// Mock implementation of SimpleStyleNode for testing
+class MockSimpleStyleNode : public lynx::style::SimpleStyleNode {
+ public:
+  MockSimpleStyleNode() = default;
+  ~MockSimpleStyleNode() override = default;
+
+  void SetStyleObjects(std::unique_ptr<lynx::style::StyleObject*,
+                                       lynx::style::StyleObjectArrayDeleter>
+                           style_object) override {
+    // Not needed for this test
+  }
+
+  void UpdateSimpleStyles(const tasm::StyleMap& style_map) override {
+    current_styles_ = style_map;
+  }
+
+  void UpdateSimpleStyles(tasm::StyleMap&& style_map) override {
+    current_styles_ = std::move(style_map);
+  }
+
+  void ResetSimpleStyle(tasm::CSSPropertyID id) override {
+    current_styles_.erase(id);
+  }
+
+  // Helper method to get current styles for verification
+  const tasm::StyleMap& GetCurrentStyles() const { return current_styles_; }
+
+  // Helper method to check if a property exists
+  bool HasProperty(tasm::CSSPropertyID id) const {
+    return current_styles_.find(id) != current_styles_.end();
+  }
+
+ private:
+  tasm::StyleMap current_styles_;
+};
+
 class CSSPatchingTest : public ::testing::Test {
  public:
   CSSPatchingTest() {}
@@ -394,6 +432,145 @@ TEST_F(CSSPatchingTest, CSSSelectorDescendantSelectorScope) {
   EXPECT_EQ(new_value.GetPattern(), CSSValuePattern::PX);
   EXPECT_EQ(new_value.AsNumber(), 20);
 }
+
+TEST_F(CSSPatchingTest, ResolveStyleObjectsBasedOnExistingMap_EmptyOldAndNew) {
+  // Test case: Both old and new style maps are empty
+  tasm::StyleMap old_dcl_style;
+  MockSimpleStyleNode target;
+  target.UpdateSimpleStyles(old_dcl_style);
+
+  StyleResolver resolver;
+  resolver.ResolveStyleObjectsBasedOnExistingMap(old_dcl_style, nullptr,
+                                                 &target);
+
+  EXPECT_TRUE(target.GetCurrentStyles().empty());
+}
+
+TEST_F(CSSPatchingTest, ResolveStyleObjectsBasedOnExistingMap_OnlyOldStyles) {
+  // Test case: Only old styles exist, new styles are null
+  tasm::StyleMap old_dcl_style;
+  old_dcl_style[CSSPropertyID::kPropertyIDFontSize] =
+      CSSValue::MakePlainString("16px");
+  old_dcl_style[CSSPropertyID::kPropertyIDColor] =
+      CSSValue::MakePlainString("red");
+
+  MockSimpleStyleNode target;
+  target.UpdateSimpleStyles(old_dcl_style);
+
+  StyleResolver resolver;
+  resolver.ResolveStyleObjectsBasedOnExistingMap(old_dcl_style, nullptr,
+                                                 &target);
+
+  // All old styles should be reset since new styles are null
+  EXPECT_TRUE(target.GetCurrentStyles().empty());
+}
+
+TEST_F(CSSPatchingTest, ResolveStyleObjectsBasedOnExistingMap_OnlyNewStyles) {
+  // Test case: Only new styles exist, old styles are empty
+  tasm::StyleMap old_dcl_style;
+
+  // Create new style objects
+  tasm::StyleMap new_style_map1;
+  new_style_map1[CSSPropertyID::kPropertyIDFontSize] =
+      CSSValue::MakePlainString("18px");
+
+  tasm::StyleMap new_style_map2;
+  new_style_map2[CSSPropertyID::kPropertyIDColor] =
+      CSSValue::MakePlainString("blue");
+  new_style_map2[CSSPropertyID::kPropertyIDWidth] =
+      CSSValue::MakePlainString("100px");
+
+  auto style_obj1 =
+      fml::MakeRefCounted<lynx::style::StyleObject>(new_style_map1);
+  auto style_obj2 =
+      fml::MakeRefCounted<lynx::style::StyleObject>(new_style_map2);
+
+  lynx::style::StyleObject* new_ptr[] = {style_obj1.get(), style_obj2.get(),
+                                         nullptr};
+
+  MockSimpleStyleNode target;
+  target.UpdateSimpleStyles(old_dcl_style);
+
+  StyleResolver resolver;
+  resolver.ResolveStyleObjectsBasedOnExistingMap(old_dcl_style, new_ptr,
+                                                 &target);
+
+  // All new styles should be applied
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDFontSize));
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDColor));
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDWidth));
+  EXPECT_EQ(target.GetCurrentStyles().size(), 3u);
+}
+
+TEST_F(CSSPatchingTest,
+       ResolveStyleObjectsBasedOnExistingMap_OverlappingStyles) {
+  // Test case: Both old and new styles exist with some overlapping properties
+  tasm::StyleMap old_dcl_style;
+  old_dcl_style[CSSPropertyID::kPropertyIDFontSize] =
+      CSSValue::MakePlainString("16px");
+  old_dcl_style[CSSPropertyID::kPropertyIDColor] =
+      CSSValue::MakePlainString("red");
+  old_dcl_style[CSSPropertyID::kPropertyIDHeight] =
+      CSSValue::MakePlainString("50px");
+
+  // Create new style objects - font-size overlaps, color is new, height is not
+  // in new styles
+  tasm::StyleMap new_style_map1;
+  new_style_map1[CSSPropertyID::kPropertyIDFontSize] =
+      CSSValue::MakePlainString("18px");  // Overrides old
+
+  tasm::StyleMap new_style_map2;
+  new_style_map2[CSSPropertyID::kPropertyIDColor] =
+      CSSValue::MakePlainString("blue");  // Updates existing
+  new_style_map2[CSSPropertyID::kPropertyIDWidth] =
+      CSSValue::MakePlainString("100px");  // New property
+
+  auto style_obj1 =
+      fml::MakeRefCounted<lynx::style::StyleObject>(new_style_map1);
+  auto style_obj2 =
+      fml::MakeRefCounted<lynx::style::StyleObject>(new_style_map2);
+
+  lynx::style::StyleObject* new_ptr[] = {style_obj1.get(), style_obj2.get(),
+                                         nullptr};
+
+  MockSimpleStyleNode target;
+  target.UpdateSimpleStyles(old_dcl_style);
+
+  StyleResolver resolver;
+  resolver.ResolveStyleObjectsBasedOnExistingMap(old_dcl_style, new_ptr,
+                                                 &target);
+
+  // Check that overlapping properties are updated, new properties are added,
+  // and old ones are reset
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDFontSize));
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDColor));
+  EXPECT_TRUE(target.HasProperty(CSSPropertyID::kPropertyIDWidth));
+  EXPECT_FALSE(
+      target.HasProperty(CSSPropertyID::kPropertyIDHeight));  // Should be reset
+  EXPECT_EQ(target.GetCurrentStyles().size(), 3u);
+}
+
+TEST_F(CSSPatchingTest, ResolveStyleObjectsBasedOnExistingMap_EmptyNewStyles) {
+  // Test case: Old styles exist, but new styles array is empty (not null)
+  tasm::StyleMap old_dcl_style;
+  old_dcl_style[CSSPropertyID::kPropertyIDFontSize] =
+      CSSValue::MakePlainString("16px");
+  old_dcl_style[CSSPropertyID::kPropertyIDColor] =
+      CSSValue::MakePlainString("red");
+
+  // Empty new styles array (nullptr terminated)
+  lynx::style::StyleObject* new_ptr[] = {nullptr};
+
+  MockSimpleStyleNode target;
+  target.UpdateSimpleStyles(old_dcl_style);
+
+  StyleResolver resolver;
+  resolver.ResolveStyleObjectsBasedOnExistingMap(old_dcl_style, new_ptr,
+                                                 &target);
+
+  // All old styles should be reset since new styles are empty
+  EXPECT_TRUE(target.GetCurrentStyles().empty());
+}
 }  // namespace testing
 }  // namespace tasm
 }  // namespace lynx

core/renderer/simple_styling/simple_style_node.h

@@ -7,7 +7,7 @@
 
 #include <memory>
 
-#include "base/include/fml/memory/ref_counted.h"
+#include "base/include/fml/memory/ref_ptr.h"
 #include "core/renderer/css/css_property.h"
 
 namespace lynx::style {
@@ -22,6 +22,7 @@ class SimpleStyleNode {
   virtual void SetStyleObjects(
       std::unique_ptr<StyleObject*, StyleObjectArrayDeleter> style_object) = 0;
   virtual void UpdateSimpleStyles(const tasm::StyleMap& style_map) = 0;
+  virtual void UpdateSimpleStyles(tasm::StyleMap&& style_map) = 0;
   virtual void ResetSimpleStyle(tasm::CSSPropertyID id) = 0;
 };
 }  // namespace lynx::style

core/template_bundle/template_codec/binary_decoder/lynx_config.yml

@@ -1691,3 +1691,11 @@ enableCSSInlineVariables:
     - DECODE
   author: 'pilipala195'
   since: '3.6'
+enablePropertyBasedSimpleStyle:
+  description: SimpleStyle mode will incrementally update styles based on properties if this config set to TRUE. Otherwise it will incrementally update based on StyleObjects. The StyleObject based updating has a better performance but not allow StyleObjects bound to the same elememnt has intersect properties.
+  defaultValue: 'false'
+  valueType: bool
+  readSettings: false
+  readNative: false
+  author: 'zhongyr'
+  since: '3.5'