[Optimize][List] Implement list optimized anchor search algorithm

This commit mainly improves the accuracy of anchor point searching in list component:

1. Added weak_anchor_ref_ field in ItemHolder to store anchor reference ItemHolder for removed ItemHolders.

2. Update anchor reference ItemHolder for all removed on-screen ItemHolders before consuming diff info.

3. In list layout pass, if no valid anchor ItemHolder can be found from all on screen childre, we use the reference anchor ItemHolder as anchor ItemHolder in layout.

4. Add relative unittest and e2e tests.

issue: m-6795355659

Author: DwwWxx

core/renderer/ui_component/list/item_holder.h

@@ -8,6 +8,7 @@
 #include <array>
 #include <string>
 
+#include "base/include/flex_optional.h"
 #include "base/include/fml/memory/weak_ptr.h"
 #include "core/renderer/ui_component/list/list_types.h"
 
@@ -72,6 +73,15 @@ class ItemHolder : public fml::EnableWeakFromThis<ItemHolder> {
     sticky_top_ = sticky_top;
     sticky_bottom_ = sticky_bottom;
   }
+  void SetWeakAnchorRef(ItemHolder* item_holder) {
+    weak_anchor_ref_ = base::make_flex_optional(
+        item_holder ? item_holder->WeakFromThis() : fml::WeakPtr<ItemHolder>());
+  }
+  void ResetWeakAnchorRef() { weak_anchor_ref_.reset(); }
+  ItemHolder* GetAnchorRefHolder() const {
+    return weak_anchor_ref_ && (*weak_anchor_ref_) ? (*weak_anchor_ref_).get()
+                                                   : nullptr;
+  }
   void SetRecyclable(bool recyclable) { recyclable_ = recyclable; }
 
   const std::string& item_key() const { return item_key_; }
@@ -87,6 +97,9 @@ class ItemHolder : public fml::EnableWeakFromThis<ItemHolder> {
   bool sticky() const { return sticky_top_ || sticky_bottom_; }
   bool sticky_top() const { return sticky_top_; }
   bool sticky_bottom() const { return sticky_bottom_; }
+  base::flex_optional<fml::WeakPtr<ItemHolder>> weak_anchor_ref() const {
+    return weak_anchor_ref_;
+  }
   bool recyclable() const { return recyclable_; }
 
   // Note: The comparator of ItemHolder should allow objects with the same
@@ -160,6 +173,7 @@ class ItemHolder : public fml::EnableWeakFromThis<ItemHolder> {
   // All layout Info of item holder.
   // The ItemHolder's index in data source.
   int index_{list::kInvalidIndex};
+  base::flex_optional<fml::WeakPtr<ItemHolder>> weak_anchor_ref_;
   // The ItemHold's key.
   std::string item_key_;
   // Whether the ItemHolder can be recycled.

core/renderer/ui_component/list/list_adapter.cc

@@ -258,6 +258,11 @@ void ListAdapter::UpdateItemHolderToLatest(
   if (!list_children_helper) {
     return;
   }
+  // Update anchor ref for removed on screen children.
+  // Note: This logic should be invoked before latest diff info being updated to
+  // all ItemHolders, so here UpdateAnchorRefItem() is invoked in the begin of
+  // UpdateItemHolderToLatest()
+  UpdateAnchorRefItem(list_children_helper);
 
   const auto& children = list_children_helper->children();
   const auto& attached_children = list_children_helper->attached_children();
@@ -317,6 +322,88 @@ void ListAdapter::UpdateItemHolderToLatest(
   }
 }
 
+void ListAdapter::UpdateAnchorRefItem(
+    ListChildrenHelper* list_children_helper) {
+  const auto& children = list_children_helper->children();
+  const auto& on_screen_children = list_children_helper->on_screen_children();
+  bool has_valid_diff = list_adapter_helper()->HasValidDiff();
+  bool should_search_ref_anchor = list_container_->ShouldSearchRefAnchor();
+  list::SearchRefAnchorStrategy search_strategy =
+      list_container_->search_ref_anchor_strategy();
+  std::unordered_map<ItemHolder*, ItemHolder*> tmp_anchor_ref_map;
+  if (has_valid_diff && should_search_ref_anchor &&
+      !on_screen_children.empty() && !children.empty()) {
+    list_children_helper->ForEachChild(
+        on_screen_children,
+        [this, list_children_helper, &children, &tmp_anchor_ref_map,
+         search_strategy](ItemHolder* on_screen_child) {
+          // We only need to update removed on screen child.
+          if (IsRemoved(on_screen_child)) {
+            auto weak_anchor_ref = on_screen_child->weak_anchor_ref();
+            if (!weak_anchor_ref) {
+              // (1) Removed child's weak_anchor_ref is never set.
+              if (auto it = children.find(on_screen_child);
+                  it != children.end()) {
+                ItemHolder* anchor_ref_child =
+                    list_children_helper->GetFirstChildFrom(
+                        children, on_screen_child,
+                        [this, on_screen_child](const ItemHolder* item_holder) {
+                          return item_holder != on_screen_child &&
+                                 !IsRemoved(item_holder);
+                        },
+                        search_strategy ==
+                            list::SearchRefAnchorStrategy::kToStart);
+                on_screen_child->SetWeakAnchorRef(anchor_ref_child);
+              } else {
+                // Unexpected case: child is not in children set.
+                NLIST_LOGE(
+                    "ListAdapter::UpdateItemHolderToLatest: on_screen_child is "
+                    "not at children set and it's weak_anchor_ref is never "
+                    "set: "
+                    "index="
+                    << on_screen_child->index()
+                    << ", item-key=" << on_screen_child->item_key());
+                on_screen_child->SetWeakAnchorRef(nullptr);
+              }
+            } else if (weak_anchor_ref && (*weak_anchor_ref)) {
+              // (2) Update weak_anchor_ref if needed.
+              ItemHolder* current_anchor_ref_child = (*weak_anchor_ref).get();
+              if (IsRemoved(current_anchor_ref_child)) {
+                // Current anchor ref child is removed, need to find a new
+                // anchor ref.
+                if (auto it = tmp_anchor_ref_map.find(current_anchor_ref_child);
+                    it != tmp_anchor_ref_map.end()) {
+                  // Fast find new ref anchor child from tmp_anchor_ref_map
+                  on_screen_child->SetWeakAnchorRef(it->second);
+                } else {
+                  if (auto it = children.find(current_anchor_ref_child);
+                      it != children.end()) {
+                    ItemHolder* new_anchor_ref_child =
+                        list_children_helper->GetFirstChildFrom(
+                            children, current_anchor_ref_child,
+                            [this, current_anchor_ref_child](
+                                const ItemHolder* item_holder) {
+                              return item_holder != current_anchor_ref_child &&
+                                     !IsRemoved(item_holder);
+                            },
+                            search_strategy ==
+                                list::SearchRefAnchorStrategy::kToStart);
+                    tmp_anchor_ref_map[current_anchor_ref_child] =
+                        new_anchor_ref_child;
+                    on_screen_child->SetWeakAnchorRef(new_anchor_ref_child);
+                  } else {
+                    tmp_anchor_ref_map[current_anchor_ref_child] = nullptr;
+                    on_screen_child->SetWeakAnchorRef(nullptr);
+                  }
+                }
+              }
+            }
+          }
+          return false;
+        });
+  }
+}
+
 // Mark all child ItemHolders's diff status.
 void ListAdapter::MarkChildHolderDirty() {
   TRACE_EVENT(LYNX_TRACE_CATEGORY, LIST_ADAPTER_MARK_CHILD_DIRTY);

core/renderer/ui_component/list/list_adapter.h

@@ -212,6 +212,8 @@ class ListAdapter : public AdapterHelper::Delegate {
 
   bool HasExpectedDiffAnimation() const;
 
+  void UpdateAnchorRefItem(ListChildrenHelper* list_children_helper);
+
  protected:
   Element* list_element_{nullptr};
   ListContainerImpl* list_container_{nullptr};

core/renderer/ui_component/list/list_adapter_unittest.cc

@@ -2,6 +2,9 @@
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
 
+#define private public
+#define protected public
+
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -13,7 +16,6 @@
 #include "core/renderer/dom/fiber/component_element.h"
 #include "core/renderer/dom/fiber/list_element.h"
 #include "core/renderer/tasm/react/testing/mock_painting_context.h"
-#include "core/renderer/ui_component/list/default_list_adapter.h"
 #include "core/renderer/ui_component/list/list_container_impl.h"
 #include "core/renderer/ui_component/list/testing/mock_diff_result.h"
 #include "core/renderer/ui_component/list/testing/mock_list_element.h"
@@ -36,9 +38,8 @@ class ListAdapterTest : public ::testing::Test {
   std::unique_ptr<lynx::tasm::ElementManager> manager;
   std::shared_ptr<::testing::NiceMock<test::MockTasmDelegate>> tasm_mediator;
   fml::RefPtr<list::MockListElement> list_element_ref;
-  std::unique_ptr<DefaultListAdapter> default_list_adapter;
   std::unique_ptr<ListContainerImpl> list_container;
-  std::unique_ptr<ListChildrenHelper> list_children_helper;
+  ListChildrenHelper* list_children_helper;
 
  protected:
   ListAdapterTest() = default;
@@ -63,22 +64,7 @@ class ListAdapterTest : public ::testing::Test {
                                   enqueue_component, component_at_indexes));
     list_container =
         std::make_unique<ListContainerImpl>(list_element_ref.get());
-    default_list_adapter = std::make_unique<DefaultListAdapter>(
-        list_container.get(), list_element_ref.get());
-    list_children_helper = std::make_unique<ListChildrenHelper>();
-  }
-
- public:
-  fml::RefPtr<Element> CreateListItemElement() {
-    static int32_t base_css_id = 0;
-    base::String component_id(std::to_string(++base_css_id));
-    base::String entry_name("__ListItem__");
-    base::String component_name("__ListItem__");
-    base::String path("/index/components/ListItem");
-    auto list_item_ref = manager->CreateFiberComponent(
-        component_id, base_css_id, entry_name, component_name, path);
-    list_element_ref->AddChildAt(list_item_ref, -1);
-    return list_item_ref;
+    list_children_helper = list_container->list_children_helper();
   }
 };  // ListAdapterTest
 
@@ -94,37 +80,46 @@ TEST_F(ListAdapterTest, DiffCase) {
       .sticky_bottoms = {7, 8},
       .full_spans = {0, 1, 7, 8},
   };
-  default_list_adapter->UpdateDataSource(
+  list_container->list_adapter_->UpdateDataSource(
       lepus_value(diff_result.GenerateDiffResult()));
-  EXPECT_EQ(default_list_adapter->list_adapter_helper()->item_keys().size(),
+  EXPECT_EQ(
+      list_container->list_adapter_->list_adapter_helper()->item_keys().size(),
+      diff_result.GetItemCount());
+  EXPECT_EQ(list_container->list_adapter_->list_adapter_helper()
+                ->item_key_map()
+                .size(),
             diff_result.GetItemCount());
-  EXPECT_EQ(default_list_adapter->list_adapter_helper()->item_key_map().size(),
+  EXPECT_EQ(list_container->list_adapter_->GetDataCount(),
             diff_result.GetItemCount());
-  EXPECT_EQ(default_list_adapter->GetDataCount(), diff_result.GetItemCount());
-  EXPECT_EQ(default_list_adapter->list_adapter_helper()
+  EXPECT_EQ(list_container->list_adapter_->list_adapter_helper()
                 ->estimated_heights_px()
                 .size(),
             diff_result.GetItemCount());
+  EXPECT_EQ(list_container->list_adapter_->list_adapter_helper()
+                ->estimated_sizes_px()
+                .size(),
+            diff_result.GetItemCount());
   EXPECT_EQ(
-      default_list_adapter->list_adapter_helper()->estimated_sizes_px().size(),
-      diff_result.GetItemCount());
-  EXPECT_EQ(default_list_adapter->list_adapter_helper()->full_spans().size(),
-            diff_result.full_spans.size());
-  EXPECT_EQ(default_list_adapter->list_adapter_helper()->sticky_tops().size(),
+      list_container->list_adapter_->list_adapter_helper()->full_spans().size(),
+      diff_result.full_spans.size());
+  EXPECT_EQ(list_container->list_adapter_->list_adapter_helper()
+                ->sticky_tops()
+                .size(),
             diff_result.sticky_tops.size());
-  EXPECT_EQ(default_list_adapter->GetStickyTops().size(),
+  EXPECT_EQ(list_container->list_adapter_->GetStickyTops().size(),
             diff_result.sticky_tops.size());
-  EXPECT_EQ(
-      default_list_adapter->list_adapter_helper()->sticky_bottoms().size(),
-      diff_result.sticky_bottoms.size());
-  EXPECT_EQ(default_list_adapter->GetStickyBottoms().size(),
+  EXPECT_EQ(list_container->list_adapter_->list_adapter_helper()
+                ->sticky_bottoms()
+                .size(),
+            diff_result.sticky_bottoms.size());
+  EXPECT_EQ(list_container->list_adapter_->GetStickyBottoms().size(),
             diff_result.sticky_bottoms.size());
-  EXPECT_TRUE(default_list_adapter->HasFullSpanItems());
-  default_list_adapter->UpdateItemHolderToLatest(list_children_helper.get());
+  EXPECT_TRUE(list_container->list_adapter_->HasFullSpanItems());
+  list_container->list_adapter_->UpdateItemHolderToLatest(list_children_helper);
   for (int index = 0; index < static_cast<int>(diff_result.GetItemCount());
        ++index) {
     ItemHolder* item_holder =
-        default_list_adapter->GetItemHolderForIndex(index);
+        list_container->list_adapter_->GetItemHolderForIndex(index);
     EXPECT_NE(item_holder, nullptr);
     if (index == 0 || index == 1) {
       EXPECT_TRUE(item_holder->sticky_top());
@@ -134,6 +129,121 @@ TEST_F(ListAdapterTest, DiffCase) {
   }
 }
 
+TEST_F(ListAdapterTest, UpdateAnchorRefItemTest) {
+  list_container->search_ref_anchor_strategy_ =
+      list::SearchRefAnchorStrategy::kToStart;
+  list::InsertAction insert_action;
+  list::RemoveAction remove_action;
+  list::UpdateAction update_action;
+  insert_action = {.insert_ops_ = {
+                       {.position_ = 0, "A_0", 100, false, false, false, false},
+                       {.position_ = 1, "B_1", 100, false, false, false, false},
+                       {.position_ = 2, "C_2", 100, false, false, false, false},
+                       {.position_ = 3, "D_3", 100, false, false, false, false},
+                       {.position_ = 4, "E_4", 100, false, false, false, false},
+                       {.position_ = 5, "F_5", 100, false, false, false, false},
+                       {.position_ = 6, "G_6", 100, false, false, false, false},
+                       {.position_ = 7, "H_7", 100, false, false, false, false},
+                       {.position_ = 8, "I_8", 100, false, false, false, false},
+                       {.position_ = 9, "J_9", 100, false, false, false, false},
+                   }};
+  list::FiberDiffResult fiber_diff_result_0{
+      .insert_action_ = insert_action,
+  };
+  list_container->list_adapter_->UpdateFiberDataSource(
+      lepus::Value(fiber_diff_result_0.Resolve()));
+  list_container->list_adapter_->UpdateItemHolderToLatest(list_children_helper);
+
+  // init on screen children: E_4, F_5, G_6, H_7
+  list_children_helper->on_screen_children_.insert(
+      list_container->GetItemHolderForIndex(4));
+  list_children_helper->on_screen_children_.insert(
+      list_container->GetItemHolderForIndex(5));
+  list_children_helper->on_screen_children_.insert(
+      list_container->GetItemHolderForIndex(6));
+  list_children_helper->on_screen_children_.insert(
+      list_container->GetItemHolderForIndex(7));
+
+  // remove C_2, E_4, F_5, H_7
+  // insert New_A_0, New_B_1, New_C_2, New_D_3
+  insert_action = {
+      .insert_ops_ = {
+          {.position_ = 2, "New_A_0", 100, false, false, false, false},
+          {.position_ = 3, "New_B_1", 100, false, false, false, false},
+          {.position_ = 4, "New_C_2", 100, false, false, false, false},
+          {.position_ = 5, "New_D_3", 100, false, false, false, false},
+      }};
+  remove_action = {
+      .remove_ops_ = {2, 4, 5, 7},
+  };
+  list::FiberDiffResult fiber_diff_result_1{
+      .insert_action_ = insert_action,
+      .remove_action_ = remove_action,
+  };
+  list_container->list_adapter_->UpdateFiberDataSource(
+      lepus::Value(fiber_diff_result_1.Resolve()));
+  list_container->list_adapter_->UpdateItemHolderToLatest(list_children_helper);
+
+  ItemHolder* holder_C2 =
+      list_container->list_adapter_->item_holder_map_->at("C_2").get();
+  ItemHolder* holder_E4 =
+      list_container->list_adapter_->item_holder_map_->at("E_4").get();
+  ItemHolder* holder_F5 =
+      list_container->list_adapter_->item_holder_map_->at("F_5").get();
+  ItemHolder* holder_G6 =
+      list_container->list_adapter_->item_holder_map_->at("G_6").get();
+  ItemHolder* holder_H7 =
+      list_container->list_adapter_->item_holder_map_->at("H_7").get();
+  // C_2 is not on screen children set, so it has no anchor ref item.
+  EXPECT_EQ(holder_C2->weak_anchor_ref().has_value(), false);
+  // E_4 and F_5 are on screen children set and they are removed in this diff,
+  // so they have anchor ref item with D_3.
+  EXPECT_EQ(holder_E4->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_E4->weak_anchor_ref().value()->item_key() == "D_3");
+  EXPECT_EQ(holder_F5->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_F5->weak_anchor_ref().value().get()->item_key() == "D_3");
+  // G_6 is not removed in this diff, so it has no anchor ref item.
+  EXPECT_EQ(holder_G6->weak_anchor_ref().has_value(), false);
+  // H_7 is on screen children set and removed in this diff, so it has anchor
+  // ref item with G_6.
+  EXPECT_EQ(holder_H7->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_H7->weak_anchor_ref().value().get()->item_key() == "G_6");
+
+  // remove D_3
+  remove_action = {
+      .remove_ops_ = {6},
+  };
+  list::FiberDiffResult fiber_diff_result_2{
+      .remove_action_ = remove_action,
+  };
+  list_container->list_adapter_->UpdateFiberDataSource(
+      lepus::Value(fiber_diff_result_2.Resolve()));
+  list_container->list_adapter_->UpdateItemHolderToLatest(list_children_helper);
+  // D_3 is removed in this diff, so E_4 and F_5 should update anchor ref item
+  // to New_D_3.
+  EXPECT_EQ(holder_E4->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_E4->weak_anchor_ref().value()->item_key() == "New_D_3");
+  EXPECT_EQ(holder_F5->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_F5->weak_anchor_ref().value()->item_key() == "New_D_3");
+
+  // remove G_6
+  remove_action = {
+      .remove_ops_ = {6},
+  };
+  list::FiberDiffResult fiber_diff_result_3{
+      .remove_action_ = remove_action,
+  };
+  list_container->list_adapter_->UpdateFiberDataSource(
+      lepus::Value(fiber_diff_result_3.Resolve()));
+  list_container->list_adapter_->UpdateItemHolderToLatest(list_children_helper);
+  // G_6 is removed in this diff, so G_6 and H_7 should update anchor ref item
+  // to New_G_6.
+  EXPECT_EQ(holder_G6->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_G6->weak_anchor_ref().value()->item_key() == "New_D_3");
+  EXPECT_EQ(holder_H7->weak_anchor_ref().has_value(), true);
+  EXPECT_TRUE(holder_H7->weak_anchor_ref().value()->item_key() == "New_D_3");
+}
+
 }  // namespace testing
 }  // namespace tasm
 }  // namespace lynx