| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/bookmarks/bookmark_merged_surface_service.h" |
| |
| #include <memory> |
| |
| #include "base/containers/to_vector.h" |
| #include "base/functional/bind.h" |
| #include "base/scoped_observation.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/utf_ostream_operators.h" |
| #include "base/test/mock_callback.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/values.h" |
| #include "chrome/browser/bookmarks/bookmark_merged_surface_service_observer.h" |
| #include "chrome/browser/bookmarks/bookmark_model_factory.h" |
| #include "chrome/browser/bookmarks/bookmark_parent_folder_children.h" |
| #include "chrome/browser/bookmarks/bookmark_test_utils.h" |
| #include "components/bookmarks/browser/bookmark_model.h" |
| #include "components/bookmarks/browser/bookmark_node.h" |
| #include "components/bookmarks/managed/managed_bookmark_service.h" |
| #include "components/bookmarks/test/bookmark_test_helpers.h" |
| #include "components/bookmarks/test/test_bookmark_client.h" |
| #include "components/signin/public/base/signin_switches.h" |
| #include "components/sync_preferences/testing_pref_service_syncable.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "url/gurl.h" |
| |
| namespace { |
| |
| using PermanentFolderType = BookmarkParentFolder::PermanentFolderType; |
| using bookmarks::BookmarkNode; |
| using bookmarks::test::AddNodesFromModelString; |
| using bookmarks::test::ModelStringFromNode; |
| using testing::_; |
| using testing::InSequence; |
| using testing::Mock; |
| using testing::Pair; |
| using testing::UnorderedElementsAre; |
| |
| // Matcher for comparing `BookmarkParentFolderChildren` children to a vector of |
| // BookmarkNodes. |
| MATCHER_P(HasOrderedChildren, expected_children, "") { |
| if (arg.size() != expected_children.size()) { |
| *result_listener << "Expected " << expected_children.size() << " children, " |
| << "but got " << arg.size(); |
| return false; |
| } |
| |
| for (size_t i = 0; i < arg.size(); ++i) { |
| const BookmarkNode* child = arg[i]; |
| const BookmarkNode* expected_child = expected_children[i]; |
| if (child != expected_child) { |
| *result_listener << "Child at index " << i << " does not match. Expected " |
| << expected_child->GetTitledUrlNodeTitle() |
| << ", but got " << child->GetTitledUrlNodeTitle(); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| MATCHER_P(HasParent, parent, "") { |
| const BookmarkNode* node = arg.as_non_permanent_folder(); |
| if (!node) { |
| // `parent` can't be root. |
| return false; |
| } |
| CHECK(node->parent()); |
| return BookmarkParentFolder::FromFolderNode(node->parent()) == parent; |
| } |
| |
| class MockBookmarkMergedSurfaceServiceObserver |
| : public BookmarkMergedSurfaceServiceObserver { |
| public: |
| MOCK_METHOD(void, BookmarkMergedSurfaceServiceLoaded, ()); |
| |
| MOCK_METHOD(void, BookmarkMergedSurfaceServiceBeingDeleted, ()); |
| |
| MOCK_METHOD(void, |
| BookmarkNodeAdded, |
| (const BookmarkParentFolder& parent, size_t index)); |
| |
| MOCK_METHOD(void, |
| BookmarkNodesRemoved, |
| (const BookmarkParentFolder&, |
| (const base::flat_set<const BookmarkNode*>&))); |
| |
| MOCK_METHOD(void, |
| BookmarkNodeMoved, |
| (const BookmarkParentFolder&, |
| size_t, |
| const BookmarkParentFolder&, |
| size_t)); |
| |
| MOCK_METHOD(void, BookmarkNodeChanged, (const bookmarks::BookmarkNode*)); |
| |
| MOCK_METHOD(void, |
| BookmarkNodeFaviconChanged, |
| (const bookmarks::BookmarkNode*)); |
| |
| MOCK_METHOD(void, |
| BookmarkParentFolderChildrenReordered, |
| (const BookmarkParentFolder&)); |
| |
| MOCK_METHOD(void, BookmarkAllUserNodesRemoved, ()); |
| }; |
| |
| class BookmarkMergedSurfaceServiceTest : public testing::Test { |
| public: |
| void CreateBookmarkMergedSurfaceServiceWithManaged( |
| size_t managed_bookmarks_size) { |
| CreateBookmarkMergedSurfaceService(true, managed_bookmarks_size); |
| } |
| |
| void CreateBookmarkMergedSurfaceService(bool with_managed_node = false, |
| size_t managed_bookmarks_size = 0) { |
| std::unique_ptr<bookmarks::TestBookmarkClient> bookmark_client; |
| if (with_managed_node) { |
| CHECK(managed_bookmarks_size); |
| managed_bookmark_service_ = |
| CreateManagedBookmarkService(&prefs_, managed_bookmarks_size); |
| bookmark_client = std::make_unique<TestBookmarkClientWithManagedService>( |
| managed_bookmark_service_.get()); |
| } else { |
| bookmark_client = std::make_unique<bookmarks::TestBookmarkClient>(); |
| } |
| model_ = |
| std::make_unique<bookmarks::BookmarkModel>(std::move(bookmark_client)); |
| service_ = std::make_unique<BookmarkMergedSurfaceService>( |
| model_.get(), managed_bookmark_service_.get()); |
| service_->AddObserver(&mock_service_observer_); |
| model_->LoadEmptyForTest(); |
| service_->LoadForTesting({}); |
| } |
| |
| ~BookmarkMergedSurfaceServiceTest() override { |
| service_->RemoveObserver(&mock_service_observer_); |
| } |
| |
| BookmarkMergedSurfaceService& service() { return *service_; } |
| bookmarks::BookmarkModel& model() { return *model_; } |
| const BookmarkNode* managed_node() const { |
| return managed_bookmark_service_->managed_node(); |
| } |
| |
| void PerformMoveAction(Browser* browser, |
| const bookmarks::BookmarkNode* node, |
| const bookmarks::BookmarkNode* target_node, |
| size_t index) { |
| model_->Move(node, target_node, index); |
| } |
| |
| MockBookmarkMergedSurfaceServiceObserver& mock_service_observer() { |
| return mock_service_observer_; |
| } |
| |
| private: |
| base::test::ScopedFeatureList features_{ |
| switches::kSyncEnableBookmarksInTransportMode}; |
| sync_preferences::TestingPrefServiceSyncable prefs_; |
| std::unique_ptr<bookmarks::ManagedBookmarkService> managed_bookmark_service_; |
| std::unique_ptr<bookmarks::BookmarkModel> model_; |
| std::unique_ptr<BookmarkMergedSurfaceService> service_; |
| testing::NiceMock<MockBookmarkMergedSurfaceServiceObserver> |
| mock_service_observer_; |
| }; |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, IsNonDefaultOrderingTracked) { |
| const size_t kManagedBookmarksSize = 5; |
| CreateBookmarkMergedSurfaceServiceWithManaged(kManagedBookmarksSize); |
| EXPECT_FALSE(service().IsNonDefaultOrderingTracked( |
| BookmarkParentFolder::ManagedFolder())); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| |
| // Non permanent node. |
| BookmarkParentFolder non_permanent_folder( |
| BookmarkParentFolder::FromFolderNode( |
| model().bookmark_bar_node()->children()[3].get())); |
| EXPECT_FALSE(service().IsNonDefaultOrderingTracked(non_permanent_folder)); |
| |
| // No account nodes. |
| EXPECT_FALSE(service().IsNonDefaultOrderingTracked( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| |
| // Account nodes with empty child nodes. |
| model().CreateAccountPermanentFolders(); |
| EXPECT_FALSE(service().IsNonDefaultOrderingTracked( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| |
| // Default order. |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "4 5 "); |
| EXPECT_FALSE(service().IsNonDefaultOrderingTracked( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| |
| // Custom order. |
| service().Move(model().bookmark_bar_node()->children()[0].get(), |
| BookmarkParentFolder::BookmarkBarFolder(), 0u, |
| /*browser=*/nullptr); |
| EXPECT_TRUE(service().IsNonDefaultOrderingTracked( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, GetChildrenCount) { |
| const size_t kManagedBookmarksSize = 5; |
| CreateBookmarkMergedSurfaceServiceWithManaged(kManagedBookmarksSize); |
| EXPECT_EQ( |
| service().GetChildrenCount(BookmarkParentFolder::BookmarkBarFolder()), |
| 0u); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::OtherFolder()), |
| 0u); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::MobileFolder()), |
| 0u); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::ManagedFolder()), |
| kManagedBookmarksSize); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 f2:[ 6 ] ]"); |
| EXPECT_EQ( |
| service().GetChildrenCount(BookmarkParentFolder::BookmarkBarFolder()), |
| 4u); |
| const BookmarkNode* folder_f1 = |
| model().bookmark_bar_node()->children()[3].get(); |
| EXPECT_EQ(service().GetChildrenCount( |
| BookmarkParentFolder::FromFolderNode(folder_f1)), |
| 3u); |
| const BookmarkNode* folder_f2 = folder_f1->children()[2].get(); |
| EXPECT_EQ(service().GetChildrenCount( |
| BookmarkParentFolder::FromFolderNode(folder_f2)), |
| 1u); |
| |
| AddNodesFromModelString(&model(), model().other_node(), "1 2 3 "); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::OtherFolder()), |
| 3u); |
| |
| AddNodesFromModelString(&model(), model().mobile_node(), "4 5 6 "); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::MobileFolder()), |
| 3u); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, GetChildrenWithAccountNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| const BookmarkNode* local_bb_node = model().bookmark_bar_node(); |
| const BookmarkNode* account_bb_node = model().account_bookmark_bar_node(); |
| ASSERT_TRUE(account_bb_node); |
| |
| AddNodesFromModelString(&model(), local_bb_node, "1 2 3 f1:[ 4 5 f2:[ 6 ] ]"); |
| AddNodesFromModelString(&model(), account_bb_node, |
| "7 8 9 f3:[ 10 11 f4:[ 12 ] ]"); |
| ASSERT_FALSE(local_bb_node->children().empty()); |
| ASSERT_FALSE(account_bb_node->children().empty()); |
| |
| BookmarkParentFolder bb_folder(BookmarkParentFolder::BookmarkBarFolder()); |
| size_t expected_children_size = |
| local_bb_node->children().size() + account_bb_node->children().size(); |
| EXPECT_EQ(service().GetChildrenCount(bb_folder), expected_children_size); |
| |
| BookmarkParentFolderChildren children = service().GetChildren(bb_folder); |
| ASSERT_EQ(children.size(), expected_children_size); |
| |
| size_t index = 0; |
| size_t account_bb_node_children_size = account_bb_node->children().size(); |
| while (index < expected_children_size) { |
| const BookmarkNode* expected_bookmark_node = |
| index < account_bb_node_children_size |
| ? account_bb_node->children()[index].get() |
| : local_bb_node->children()[index - account_bb_node_children_size] |
| .get(); |
| EXPECT_EQ(children[index++], expected_bookmark_node); |
| } |
| |
| // Tests `GetNodeAtIndex()`. |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 0u), |
| account_bb_node->children()[0].get()); |
| EXPECT_EQ( |
| service().GetNodeAtIndex(bb_folder, account_bb_node_children_size - 1u), |
| account_bb_node->children().back().get()); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, account_bb_node_children_size), |
| local_bb_node->children()[0].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, expected_children_size - 1u), |
| local_bb_node->children().back().get()); |
| |
| // Tests `GetIndexOf()`. |
| index = 0; |
| for (const auto& node : account_bb_node->children()) { |
| EXPECT_EQ(service().GetIndexOf(node.get()), index++); |
| } |
| for (const auto& node : local_bb_node->children()) { |
| EXPECT_EQ(service().GetIndexOf(node.get()), index++); |
| } |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, ManagedNodeNull) { |
| CreateBookmarkMergedSurfaceService(); |
| EXPECT_EQ(service().GetChildrenCount(BookmarkParentFolder::ManagedFolder()), |
| 0u); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, GetIndexOf) { |
| CreateBookmarkMergedSurfaceServiceWithManaged(/*managed_bookmarks_size=*/3); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 "); |
| |
| const BookmarkNode* f1 = model().bookmark_bar_node()->children()[3].get(); |
| EXPECT_EQ(service().GetIndexOf(f1), 3u); |
| EXPECT_EQ(service().GetIndexOf(f1->children()[1].get()), 1u); |
| EXPECT_EQ(service().GetIndexOf(model().other_node()->children()[2].get()), |
| 2u); |
| |
| // Managed node. |
| EXPECT_EQ(service().GetIndexOf(managed_node()->children()[1].get()), 1u); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, GetNodeAtIndex) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 "); |
| |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::BookmarkBarFolder(); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 0), |
| model().bookmark_bar_node()->children()[0].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 3), |
| model().bookmark_bar_node()->children()[3].get()); |
| } |
| |
| { |
| const BookmarkNode* f1 = model().bookmark_bar_node()->children()[3].get(); |
| BookmarkParentFolder folder = BookmarkParentFolder::FromFolderNode(f1); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 0), f1->children()[0].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 1), f1->children()[1].get()); |
| } |
| |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::OtherFolder(); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 0), |
| model().other_node()->children()[0].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 2), |
| model().other_node()->children()[2].get()); |
| } |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, IsParentFolderManaged) { |
| CreateBookmarkMergedSurfaceServiceWithManaged(2); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "f1:[ 4 5 ]"); |
| |
| EXPECT_FALSE(service().IsParentFolderManaged( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| EXPECT_FALSE( |
| service().IsParentFolderManaged(BookmarkParentFolder::FromFolderNode( |
| model().bookmark_bar_node()->children()[0].get()))); |
| |
| EXPECT_TRUE( |
| service().IsParentFolderManaged(BookmarkParentFolder::ManagedFolder())); |
| const BookmarkNode* root_managed_node = managed_node(); |
| EXPECT_TRUE( |
| service().IsParentFolderManaged(BookmarkParentFolder::FromFolderNode( |
| root_managed_node->children()[0].get()))); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| IsParentFolderManagedNoManagedService) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "f1:[ 4 5 ]"); |
| EXPECT_FALSE( |
| service().IsParentFolderManaged(BookmarkParentFolder::FromFolderNode( |
| model().bookmark_bar_node()->children()[0].get()))); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveToPermanentFolder) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().other_node(), "4 5 6 "); |
| |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*old_index=*/1u, /*new_parent=*/BookmarkParentFolder::OtherFolder(), |
| /*new_index=*/1u)); |
| // Move node "2" in bookmark bar to be after "4" in other node. |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[1].get(); |
| service().Move(node, BookmarkParentFolder::OtherFolder(), 1, |
| /*browser=*/nullptr); |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "1 3 "); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), "4 2 5 6 "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| MoveToPermanentFolderWithAccountNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().other_node(), "4 5 6 "); |
| |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "A1 A2 A3 "); |
| AddNodesFromModelString(&model(), model().account_other_node(), "A4 A5 A6 "); |
| |
| InSequence s; |
| // Move from local bookmark bar to local other node. |
| // Move node "2" in bookmark bar to be after "4" in other node. |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[1].get(); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*old_index=*/4u, /*new_parent=*/BookmarkParentFolder::OtherFolder(), |
| /*new_index=*/1u)); |
| service().Move(node, BookmarkParentFolder::OtherFolder(), 1, |
| /*browser=*/nullptr); |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "1 3 "); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), "2 4 5 6 "); |
| EXPECT_EQ(service().GetIndexOf(node), 1u); |
| |
| // Move within bookmark bar. |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*old_index=*/4u, |
| /*new_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*new_index=*/1u)); |
| node = model().bookmark_bar_node()->children()[1].get(); |
| service().Move(node, BookmarkParentFolder::BookmarkBarFolder(), 1, |
| /*browser=*/nullptr); |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "3 1 "); |
| EXPECT_EQ(ModelStringFromNode(model().account_bookmark_bar_node()), |
| "A1 A2 A3 "); |
| // Expected order: "A1 3 A2 A3 1 " |
| EXPECT_EQ(service().GetIndexOf(node), 1u); |
| |
| // Move from account other node to account bookmark bar. |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::OtherFolder(), /*old_index=*/0u, |
| /*new_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*new_index=*/2u)); |
| node = model().account_other_node()->children()[0].get(); |
| service().Move(node, BookmarkParentFolder::BookmarkBarFolder(), 2, |
| /*browser=*/nullptr); |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "3 1 "); |
| EXPECT_EQ(ModelStringFromNode(model().account_bookmark_bar_node()), |
| "A1 A4 A2 A3 "); |
| EXPECT_EQ(ModelStringFromNode(model().account_other_node()), "A5 A6 "); |
| // Expected order: "A1 3 A4 A2 A3 1 " |
| EXPECT_EQ(service().GetIndexOf(node), 2u); |
| EXPECT_EQ( |
| service().GetNodeAtIndex(BookmarkParentFolder::BookmarkBarFolder(), 1u), |
| model().bookmark_bar_node()->children()[0].get()); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveIsNoOpWithAccountNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "A1 A2 A3 "); |
| |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeMoved(_, _, _, _)).Times(0); |
| |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| service().Move(service().GetNodeAtIndex(bb_folder, 0), bb_folder, 0, |
| /*browser=*/nullptr); |
| service().Move(service().GetNodeAtIndex(bb_folder, 0), bb_folder, 1, |
| /*browser=*/nullptr); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveIsNoOpWithoutAccountNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeMoved(_, _, _, _)).Times(0); |
| |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| service().Move(service().GetNodeAtIndex(bb_folder, 1), bb_folder, 1, |
| /*browser=*/nullptr); |
| service().Move(service().GetNodeAtIndex(bb_folder, 1), bb_folder, 2, |
| /*browser=*/nullptr); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveWithinBookmarkModelOnlyRequired) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "A1 A2 A3 "); |
| |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, /*old_index=*/0, |
| /*new_parent=*/bb_folder, /*new_index=*/1)); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, /*old_index=*/2, |
| /*new_parent=*/bb_folder, /*new_index=*/0)); |
| |
| service().Move(service().GetNodeAtIndex(bb_folder, 0), bb_folder, 2, |
| /*browser=*/nullptr); |
| service().Move(service().GetNodeAtIndex(bb_folder, 2), bb_folder, 0, |
| /*browser=*/nullptr); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, ScopedMoveChangeIsReset) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "A1 A2 A3 "); |
| |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, /*old_index=*/0, |
| /*new_parent=*/bb_folder, /*new_index=*/1)); |
| service().Move(service().GetNodeAtIndex(bb_folder, 0), bb_folder, 2, |
| /*browser=*/nullptr); |
| |
| // Move in bookmark model. |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, /*old_index=*/4, |
| /*new_parent=*/bb_folder, /*new_index=*/5)); |
| model().Move(model().bookmark_bar_node()->children()[1].get(), |
| model().bookmark_bar_node(), 3u); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveToBookmarkNode) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 "); |
| |
| // Move node "8" from other node to node "f1" after "4". |
| const BookmarkNode* node_to_move = model().other_node()->children()[2].get(); |
| const BookmarkParentFolder destination = BookmarkParentFolder::FromFolderNode( |
| model().bookmark_bar_node()->children()[3].get()); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/BookmarkParentFolder::OtherFolder(), |
| /*old_index=*/2u, |
| /*new_parent=*/destination, /*new_index=*/1u)); |
| service().Move(node_to_move, destination, 1, |
| /*browser=*/nullptr); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), |
| "1 2 3 f1:[ 4 8 5 ] "); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), "6 7 "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveFromAccountToLocalStorage) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "f1:[ 1 2 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "A1 A2 A3 "); |
| |
| const BookmarkNode* node = |
| model().account_bookmark_bar_node()->children()[0].get(); |
| const BookmarkNode* destination = |
| model().bookmark_bar_node()->children()[0].get(); |
| const BookmarkParentFolder destination_folder( |
| BookmarkParentFolder::FromFolderNode(destination)); |
| |
| // Bypass the move storage dialog and directly move the bookmark. |
| base::MockCallback< |
| BookmarkMergedSurfaceService::ShowMoveStorageDialogCallback> |
| move_storage_callback; |
| service().SetShowMoveStorageDialogCallbackForTesting( |
| move_storage_callback.Get()); |
| EXPECT_CALL(move_storage_callback, Run(testing::_, node, destination, 1)) |
| .WillOnce(testing::Invoke( |
| this, &BookmarkMergedSurfaceServiceTest::PerformMoveAction)); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*old_index=*/0u, |
| /*new_parent=*/destination_folder, /*new_index=*/1u)); |
| |
| service().Move(node, destination_folder, 1, /*browser=*/nullptr); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "f1:[ 1 A1 2 ] "); |
| EXPECT_EQ(ModelStringFromNode(model().account_bookmark_bar_node()), "A2 A3 "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, MoveFromLocalToAccountStorage) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "f1:[ A1 A2 ] "); |
| |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[0].get(); |
| const BookmarkNode* destination = |
| model().account_bookmark_bar_node()->children()[0].get(); |
| const BookmarkParentFolder destination_folder( |
| BookmarkParentFolder::FromFolderNode(destination)); |
| |
| // Bypass the move storage dialog and directly move the bookmark. |
| base::MockCallback< |
| BookmarkMergedSurfaceService::ShowMoveStorageDialogCallback> |
| move_storage_callback; |
| service().SetShowMoveStorageDialogCallbackForTesting( |
| move_storage_callback.Get()); |
| EXPECT_CALL(move_storage_callback, Run(testing::_, node, destination, 1)) |
| .WillOnce(testing::Invoke( |
| this, &BookmarkMergedSurfaceServiceTest::PerformMoveAction)); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::BookmarkBarFolder(), |
| /*old_index=*/1u, |
| /*new_parent=*/destination_folder, /*new_index=*/1u)); |
| |
| service().Move(node, destination_folder, 1, /*browser=*/nullptr); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "2 3 "); |
| EXPECT_EQ(ModelStringFromNode(model().account_bookmark_bar_node()), |
| "f1:[ A1 1 A2 ] "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, CopyBookmarkNodeData) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 f2:[ 9 ] "); |
| |
| // Copy node "f1" to "f2". |
| const BookmarkNode* node_to_copy = |
| model().bookmark_bar_node()->children()[3].get(); |
| const bookmarks::BookmarkNodeData::Element node_data(node_to_copy); |
| const BookmarkParentFolder destination = BookmarkParentFolder::FromFolderNode( |
| model().other_node()->children()[3].get()); |
| |
| // Register second observer. |
| MockBookmarkMergedSurfaceServiceObserver mock_service_observer2; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| obs2_{&mock_service_observer2}; |
| obs2_.Observe(&service()); |
| |
| InSequence sequence; |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(destination, 1u)); |
| EXPECT_CALL(mock_service_observer2, BookmarkNodeAdded(destination, 1u)); |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeAdded(HasParent(destination), 0u)); |
| EXPECT_CALL(mock_service_observer2, |
| BookmarkNodeAdded(HasParent(destination), 0u)); |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeAdded(HasParent(destination), 1u)); |
| EXPECT_CALL(mock_service_observer2, |
| BookmarkNodeAdded(HasParent(destination), 1u)); |
| |
| service().AddNodesAsCopiesOfNodeData({node_data}, destination, 1); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), |
| "1 2 3 f1:[ 4 5 ] "); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), |
| "6 7 8 f2:[ 9 f1:[ 4 5 ] ] "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, CopyBookmarkNodeDataMultipleNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 f2:[ 9 ] "); |
| |
| // Copy nodes "2" and "3" to "f2". |
| const BookmarkNode* n1 = model().bookmark_bar_node()->children()[1].get(); |
| const BookmarkNode* n2 = model().bookmark_bar_node()->children()[2].get(); |
| std::vector<bookmarks::BookmarkNodeData::Element> nodes_data; |
| nodes_data.emplace_back(n1); |
| nodes_data.emplace_back(n2); |
| |
| const BookmarkParentFolder destination = BookmarkParentFolder::FromFolderNode( |
| model().other_node()->children()[3].get()); |
| |
| InSequence sequence; |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(destination, 0u)); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(destination, 1u)); |
| |
| service().AddNodesAsCopiesOfNodeData(nodes_data, destination, 0); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), |
| "1 2 3 f1:[ 4 5 ] "); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), "6 7 8 f2:[ 2 3 9 ] "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, CopyBookmarkNodeToPermanentFolder) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().other_node(), |
| "6 7 8 f2:[ 9 f3:[ 1 ] 2 ] "); |
| |
| // Copy node "7" and "8" to bookmark bar. |
| std::vector<bookmarks::BookmarkNodeData::Element> nodes_data; |
| nodes_data.emplace_back(model().other_node()->children()[1].get()); |
| nodes_data.emplace_back(model().other_node()->children()[2].get()); |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| |
| { |
| InSequence sequence; |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 1u)); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 2u)); |
| |
| service().AddNodesAsCopiesOfNodeData(nodes_data, bb_folder, 1); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "1 7 8 2 3 "); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 1), |
| model().bookmark_bar_node()->children()[1].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 2), |
| model().bookmark_bar_node()->children()[2].get()); |
| } |
| |
| // New nodes are added to the account node. |
| model().CreateAccountPermanentFolders(); |
| // Copy node "6" and "F2" to bookmark bar. |
| nodes_data.clear(); |
| nodes_data.emplace_back(model().other_node()->children()[0].get()); |
| nodes_data.emplace_back(model().other_node()->children()[3].get()); |
| { |
| InSequence sequence; |
| // Register second observer. |
| MockBookmarkMergedSurfaceServiceObserver mock_service_observer2; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| obs2_{&mock_service_observer2}; |
| obs2_.Observe(&service()); |
| |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 2u)); |
| EXPECT_CALL(mock_service_observer2, BookmarkNodeAdded(bb_folder, 2u)); |
| |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 3u)); |
| EXPECT_CALL(mock_service_observer2, BookmarkNodeAdded(bb_folder, 3u)); |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeAdded(HasParent(bb_folder), 0u)); |
| EXPECT_CALL(mock_service_observer2, |
| BookmarkNodeAdded(HasParent(bb_folder), 0u)); |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeAdded(HasParent(bb_folder), 1u)); |
| EXPECT_CALL(mock_service_observer2, |
| BookmarkNodeAdded(HasParent(bb_folder), 1u)); |
| |
| BookmarkParentFolder obs1_expected_f3 = bb_folder; |
| BookmarkParentFolder obs2_expected_f3 = bb_folder; |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(_, 0u)) |
| .WillOnce(testing::SaveArg<0>(&obs1_expected_f3)); |
| EXPECT_CALL(mock_service_observer2, BookmarkNodeAdded(_, 0u)) |
| .WillOnce(testing::SaveArg<0>(&obs2_expected_f3)); |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeAdded(HasParent(bb_folder), 2u)); |
| EXPECT_CALL(mock_service_observer2, |
| BookmarkNodeAdded(HasParent(bb_folder), 2u)); |
| |
| service().AddNodesAsCopiesOfNodeData(nodes_data, bb_folder, 2); |
| |
| EXPECT_EQ(ModelStringFromNode(model().account_bookmark_bar_node()), |
| "6 f2:[ 9 f3:[ 1 ] 2 ] "); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 2), |
| model().account_bookmark_bar_node()->children()[0].get()); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 3), |
| model().account_bookmark_bar_node()->children()[1].get()); |
| EXPECT_EQ(obs1_expected_f3.as_non_permanent_folder(), |
| model() |
| .account_bookmark_bar_node() |
| ->children()[1] |
| ->children()[1] |
| .get()); |
| EXPECT_EQ(obs1_expected_f3, obs2_expected_f3); |
| } |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, ScopedAddNewNodesReset) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "1 2 3 "); |
| AddNodesFromModelString(&model(), model().other_node(), "6 7 8 f2:[ 9 ] "); |
| |
| // Copy node "7" to bookmark bar. |
| bookmarks::BookmarkNodeData::Element node_data( |
| model().other_node()->children()[1].get()); |
| const BookmarkParentFolder bb_folder( |
| BookmarkParentFolder::BookmarkBarFolder()); |
| InSequence sequence; |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 1u)); |
| service().AddNodesAsCopiesOfNodeData({node_data}, bb_folder, 1); |
| |
| EXPECT_EQ(ModelStringFromNode(model().bookmark_bar_node()), "1 7 2 3 "); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 1), |
| model().bookmark_bar_node()->children()[1].get()); |
| |
| // Copy node "1" to "f2". |
| const BookmarkNode* node_to_copy = |
| model().bookmark_bar_node()->children()[0].get(); |
| const BookmarkParentFolder destination = BookmarkParentFolder::FromFolderNode( |
| model().other_node()->children()[3].get()); |
| |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(destination, 1u)); |
| |
| service().AddNodesAsCopiesOfNodeData( |
| {bookmarks::BookmarkNodeData::Element(node_to_copy)}, destination, 1); |
| EXPECT_EQ(ModelStringFromNode(model().other_node()), "6 7 8 f2:[ 9 1 ] "); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetUnderlyingNodesForNonPermanentNode) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[3].get(); |
| BookmarkParentFolder folder = BookmarkParentFolder::FromFolderNode(node); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), UnorderedElementsAre(node)); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetUnderlyingNodesManagedPermanentNode) { |
| CreateBookmarkMergedSurfaceServiceWithManaged(/*managed_bookmarks_size=*/2); |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::ManagedFolder(); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), |
| UnorderedElementsAre(managed_node())); |
| } |
| |
| { |
| // Non permanent managed node. |
| const BookmarkNode* node = managed_node()->children()[0].get(); |
| BookmarkParentFolder folder = BookmarkParentFolder::FromFolderNode(node); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), |
| UnorderedElementsAre(node)); |
| } |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, GetUnderlyingNodesPermanentNode) { |
| CreateBookmarkMergedSurfaceService(); |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::BookmarkBarFolder(); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), |
| UnorderedElementsAre(model().bookmark_bar_node())); |
| } |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::OtherFolder(); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), |
| UnorderedElementsAre(model().other_node())); |
| } |
| { |
| BookmarkParentFolder folder = BookmarkParentFolder::MobileFolder(); |
| EXPECT_THAT(service().GetUnderlyingNodes(folder), |
| UnorderedElementsAre(model().mobile_node())); |
| } |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetDefaultParentForNewNodesForNonPermanentNode) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[3].get(); |
| BookmarkParentFolder folder = BookmarkParentFolder::FromFolderNode(node); |
| EXPECT_EQ(service().GetDefaultParentForNewNodes(folder), node); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetDefaultParentForNewNodesForPermanentNode) { |
| CreateBookmarkMergedSurfaceService(); |
| BookmarkParentFolder folder = BookmarkParentFolder::BookmarkBarFolder(); |
| EXPECT_EQ(service().GetDefaultParentForNewNodes(folder), |
| model().bookmark_bar_node()); |
| |
| model().CreateAccountPermanentFolders(); |
| EXPECT_EQ(service().GetDefaultParentForNewNodes(folder), |
| model().account_bookmark_bar_node()); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetParentForManagedNodeForPermanentManagedNode) { |
| CreateBookmarkMergedSurfaceServiceWithManaged(/*managed_bookmarks_size=*/3); |
| BookmarkParentFolder managed_folder = BookmarkParentFolder::ManagedFolder(); |
| EXPECT_EQ(service().GetParentForManagedNode(managed_folder), managed_node()); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| GetParentForManagedNodeForNonPermanentNode) { |
| CreateBookmarkMergedSurfaceServiceWithManaged(/*managed_bookmarks_size=*/1); |
| AddNodesFromModelString(&model(), managed_node(), "f1:[ f11:[ 4 ] 5 ] "); |
| // Fetch second node to get the folder since a node was already added at |
| // creation. |
| const BookmarkNode* managed_folder = |
| managed_node()->children()[1].get()->children()[0].get(); |
| ASSERT_TRUE(managed_folder->is_folder()); |
| ASSERT_FALSE(managed_folder->parent()->is_permanent_node()); |
| BookmarkParentFolder folder = |
| BookmarkParentFolder::FromFolderNode(managed_folder); |
| EXPECT_EQ(service().GetParentForManagedNode(folder), managed_folder); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeAdded) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| const BookmarkNode* local_bb_node = model().bookmark_bar_node(); |
| const BookmarkNode* account_bb_node = model().account_bookmark_bar_node(); |
| ASSERT_TRUE(account_bb_node); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| const GURL kUrl("http://foo.com"); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 0)); |
| const BookmarkNode* new_node = model().AddURL(local_bb_node, 0, u"L1", kUrl); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 0u), new_node); |
| |
| // Add node to the account. |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 0)); |
| new_node = model().AddURL(account_bb_node, 0, u"A1", kUrl); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 0u), new_node); |
| |
| // Add folder to `local_bb_node`. |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 2u)); |
| const BookmarkNode* folder_node = |
| model().AddFolder(local_bb_node, 1, u"title"); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 2u), folder_node); |
| |
| // Add another account node. |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(bb_folder, 1)); |
| new_node = model().AddURL(account_bb_node, 1, u"A2", kUrl); |
| EXPECT_EQ(service().GetNodeAtIndex(bb_folder, 1u), new_node); |
| |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(std::vector<const BookmarkNode*>{ |
| account_bb_node->children()[0].get(), |
| account_bb_node->children()[1].get(), |
| local_bb_node->children()[0].get(), |
| local_bb_node->children()[1].get()})); |
| |
| // Add new node to `folder_node`. |
| BookmarkParentFolder folder( |
| BookmarkParentFolder::FromFolderNode(folder_node)); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeAdded(folder, 0)); |
| new_node = model().AddURL(folder_node, 0, u"1", kUrl); |
| EXPECT_EQ(service().GetNodeAtIndex(folder, 0u), new_node); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeRemovedOrderingTracked) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| const BookmarkNode* local_bb_node = model().bookmark_bar_node(); |
| const BookmarkNode* account_bb_node = model().account_bookmark_bar_node(); |
| ASSERT_TRUE(account_bb_node); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), local_bb_node, "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), account_bb_node, "7 8 9 f3:[ 10 11 ] "); |
| |
| const auto& local_children = local_bb_node->children(); |
| const auto& account_children = account_bb_node->children(); |
| std::vector<const BookmarkNode*> expected_children{ |
| account_children[0].get(), account_children[1].get(), |
| account_children[2].get(), account_children[3].get(), |
| local_children[0].get(), local_children[1].get(), |
| local_children[2].get(), local_children[3].get()}; |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| |
| const BookmarkNode* node_to_remove = local_children[2].get(); |
| size_t across_storage_index = service().GetIndexOf(node_to_remove); |
| ASSERT_EQ(across_storage_index, 6u); |
| |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodesRemoved(bb_folder, UnorderedElementsAre(node_to_remove))); |
| expected_children.erase(expected_children.cbegin() + across_storage_index); |
| model().Remove(node_to_remove, bookmarks::metrics::BookmarkEditSource::kOther, |
| FROM_HERE); |
| Mock::VerifyAndClearExpectations(&mock_service_observer()); |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| |
| node_to_remove = account_children[1].get(); |
| across_storage_index = service().GetIndexOf(node_to_remove); |
| ASSERT_EQ(across_storage_index, 1u); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodesRemoved(bb_folder, UnorderedElementsAre(node_to_remove))); |
| expected_children.erase(expected_children.cbegin() + across_storage_index); |
| model().Remove(node_to_remove, bookmarks::metrics::BookmarkEditSource::kOther, |
| FROM_HERE); |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeRemovedCustomOrder) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| const BookmarkNode* local_bb_node = model().bookmark_bar_node(); |
| const BookmarkNode* account_bb_node = model().account_bookmark_bar_node(); |
| ASSERT_TRUE(account_bb_node); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), local_bb_node, "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), account_bb_node, "7 8 9 f3:[ 10 11 ] "); |
| const auto& local_children = local_bb_node->children(); |
| const auto& account_children = account_bb_node->children(); |
| std::vector<const BookmarkNode*> expected_children{ |
| account_children[0].get(), account_children[1].get(), |
| local_children[0].get(), local_children[1].get(), |
| account_children[2].get(), local_children[2].get(), |
| account_children[3].get(), local_children[3].get()}; |
| for (size_t i = 0; i < expected_children.size(); i++) { |
| service().Move(expected_children[i], bb_folder, i, /*browser=*/nullptr); |
| } |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| |
| const size_t index_node_to_remove = 1u; |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodesRemoved( |
| bb_folder, UnorderedElementsAre(account_children[1].get()))); |
| expected_children.erase(expected_children.cbegin() + index_node_to_remove); |
| model().Remove(account_children[1].get(), |
| bookmarks::metrics::BookmarkEditSource::kOther, FROM_HERE); |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeRemovedNonTrackedNode) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| |
| // Remove node "4". |
| const size_t index = 0; |
| const BookmarkNode* parent_node = |
| model().bookmark_bar_node()->children()[3].get(); |
| const BookmarkNode* node_to_remove = parent_node->children()[index].get(); |
| |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodesRemoved(BookmarkParentFolder::FromFolderNode(parent_node), |
| UnorderedElementsAre(node_to_remove))); |
| model().Remove(node_to_remove, bookmarks::metrics::BookmarkEditSource::kOther, |
| FROM_HERE); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeRemovedAccountNodeWithChildNodes) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| const auto& account_child_nodes = |
| model().account_bookmark_bar_node()->children(); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodesRemoved(bb_folder, |
| UnorderedElementsAre(account_child_nodes[0].get(), |
| account_child_nodes[1].get(), |
| account_child_nodes[2].get(), |
| account_child_nodes[3].get()))); |
| model().RemoveAccountPermanentFolders(); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeRemovedAccountNodeCustomOrder) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| const auto& local_children = model().bookmark_bar_node()->children(); |
| const auto& account_children = |
| model().account_bookmark_bar_node()->children(); |
| std::vector<const BookmarkNode*> expected_children{ |
| account_children[0].get(), account_children[1].get(), |
| local_children[0].get(), local_children[1].get(), |
| account_children[2].get(), local_children[2].get(), |
| account_children[3].get(), local_children[3].get()}; |
| for (size_t i = 0; i < expected_children.size(); i++) { |
| service().Move(expected_children[i], bb_folder, i, /*browser=*/nullptr); |
| } |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(expected_children)); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodesRemoved( |
| bb_folder, UnorderedElementsAre( |
| expected_children[0], expected_children[1], |
| expected_children[4], expected_children[6]))); |
| |
| expected_children.clear(); |
| model().RemoveAccountPermanentFolders(); |
| |
| EXPECT_THAT(service().GetChildren(bb_folder), |
| HasOrderedChildren(std::vector<const BookmarkNode*>{ |
| local_children[0].get(), local_children[1].get(), |
| local_children[2].get(), local_children[3].get()})); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeRemovedAccountNodeWithNoChildren) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodesRemoved(testing::_, testing::_)) |
| .Times(0); |
| |
| model().RemoveAccountPermanentFolders(); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeRemovedAccountNodeOrderingNotTracked) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "1 2 3 "); |
| const auto& account_child_nodes = |
| model().account_bookmark_bar_node()->children(); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodesRemoved(bb_folder, |
| UnorderedElementsAre(account_child_nodes[0].get(), |
| account_child_nodes[1].get(), |
| account_child_nodes[2].get()))); |
| model().RemoveAccountPermanentFolders(); |
| EXPECT_FALSE(service().GetChildrenCount(bb_folder)); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeMovedBetweenPermanentFolders) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| |
| AddNodesFromModelString(&model(), model().other_node(), "A B C "); |
| AddNodesFromModelString(&model(), model().account_other_node(), "D E F "); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| const size_t bb_folder_size = service().GetChildrenCount(bb_folder); |
| BookmarkParentFolder other_folder = BookmarkParentFolder::OtherFolder(); |
| const size_t other_folder_size = service().GetChildrenCount(other_folder); |
| |
| // Move from bookmark bar `f1` to other node after `B`. |
| const BookmarkNode* f1 = model().bookmark_bar_node()->children()[3].get(); |
| const size_t old_index = service().GetIndexOf(f1); |
| ASSERT_EQ(old_index, 7u); |
| |
| const size_t expected_new_index = 5u; |
| ASSERT_EQ(service().GetIndexOf(model().other_node()->children()[1].get()), |
| expected_new_index - 1); |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, old_index, |
| /*new_parent=*/other_folder, expected_new_index)); |
| model().Move(f1, model().other_node(), /*index*/ 2u); |
| EXPECT_EQ(service().GetChildrenCount(bb_folder), bb_folder_size - 1); |
| EXPECT_EQ(service().GetChildrenCount(other_folder), other_folder_size + 1); |
| EXPECT_EQ(service().GetIndexOf(f1), expected_new_index); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeMovedWithinSamePermanentFolder) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| |
| // Move `f1` to `account_bookmark_bar_node()` at the end. |
| const BookmarkNode* f1 = model().bookmark_bar_node()->children()[3].get(); |
| size_t old_index = service().GetIndexOf(f1); |
| ASSERT_EQ(old_index, 7u); |
| |
| size_t expected_new_index = 4u; |
| ASSERT_EQ(service().GetIndexOf( |
| model().account_bookmark_bar_node()->children()[3].get()), |
| expected_new_index - 1); |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, old_index, |
| /*new_parent=*/bb_folder, expected_new_index)); |
| model().Move(f1, model().account_bookmark_bar_node(), |
| /*index*/ 4u); |
| Mock::VerifyAndClearExpectations(&mock_service_observer()); |
| EXPECT_EQ(service().GetIndexOf(f1), expected_new_index); |
| |
| // Move within same parent folder. |
| const BookmarkNode* node = |
| model().account_bookmark_bar_node()->children()[1].get(); |
| old_index = service().GetIndexOf(node); |
| expected_new_index = 2u; |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, old_index, |
| /*new_parent=*/bb_folder, expected_new_index)); |
| model().Move(node, model().account_bookmark_bar_node(), 3u); |
| EXPECT_EQ(service().GetIndexOf(node), expected_new_index); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeMovedFromPermanentFolderToAFolder) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| const size_t bb_folder_size = service().GetChildrenCount(bb_folder); |
| |
| // Move `3` to `account_bookmark_bar_node()` at the end. |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[2].get(); |
| const BookmarkNode* f3 = |
| model().account_bookmark_bar_node()->children()[3].get(); |
| const size_t old_index = service().GetIndexOf(node); |
| ASSERT_EQ(old_index, 6u); |
| |
| const size_t expected_new_index = 1u; |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved(/*old_parent=*/bb_folder, old_index, |
| /*new_parent=*/BookmarkParentFolder::FromFolderNode(f3), |
| expected_new_index)); |
| model().Move(node, f3, expected_new_index); |
| EXPECT_EQ(service().GetChildrenCount(bb_folder), bb_folder_size - 1); |
| EXPECT_EQ(service().GetIndexOf(node), expected_new_index); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkNodeMovedFromFolderToPermanentFolder) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| |
| BookmarkParentFolder bb_folder = BookmarkParentFolder::BookmarkBarFolder(); |
| const size_t bb_folder_size = service().GetChildrenCount(bb_folder); |
| |
| // Move `4` from f1 to `account_bookmark_bar_node()` at index 1. |
| const BookmarkNode* old_parent = |
| model().bookmark_bar_node()->children()[3].get(); |
| const BookmarkNode* node = old_parent->children()[0].get(); |
| const size_t old_index = service().GetIndexOf(node); |
| ASSERT_EQ(old_index, 0u); |
| |
| const size_t expected_new_index = 4u; |
| EXPECT_CALL( |
| mock_service_observer(), |
| BookmarkNodeMoved( |
| /*old_parent=*/BookmarkParentFolder::FromFolderNode(old_parent), |
| old_index, /*new_parent=*/bb_folder, expected_new_index)); |
| model().Move(node, model().account_bookmark_bar_node(), expected_new_index); |
| EXPECT_EQ(service().GetChildrenCount(bb_folder), bb_folder_size + 1); |
| EXPECT_EQ(service().GetIndexOf(node), expected_new_index); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeChanged) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| const std::u16string kOriginalTitle(u"foo"); |
| const GURL kUrl("http://url.com"); |
| const BookmarkNode* node = model().bookmark_bar_node()->children()[0].get(); |
| |
| const std::u16string kNewTitle(u"goo"); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeChanged(node)); |
| model().SetTitle(node, kNewTitle, |
| bookmarks::metrics::BookmarkEditSource::kOther); |
| EXPECT_EQ(node->GetTitle(), kNewTitle); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkNodeFaviconChanged) { |
| CreateBookmarkMergedSurfaceService(); |
| const BookmarkNode* bookmark_bar_node = model().bookmark_bar_node(); |
| const std::u16string kTitle(u"foo"); |
| const GURL kPageURL("http://www.google.com"); |
| |
| const BookmarkNode* node = |
| model().AddURL(bookmark_bar_node, 0, kTitle, kPageURL); |
| |
| std::set<GURL> changed_page_urls; |
| changed_page_urls.insert(kPageURL); |
| EXPECT_CALL(mock_service_observer(), BookmarkNodeFaviconChanged(node)); |
| model().OnFaviconsChanged(changed_page_urls, GURL()); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, |
| BookmarkParentFolderChildrenReordered) { |
| CreateBookmarkMergedSurfaceService(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), "A B C D "); |
| const BookmarkNode* parent = model().bookmark_bar_node(); |
| |
| // Reorder bar node's bookmarks in reverse order. |
| std::vector<const BookmarkNode*> new_order = { |
| parent->children()[3].get(), |
| parent->children()[2].get(), |
| parent->children()[1].get(), |
| parent->children()[0].get(), |
| }; |
| |
| EXPECT_CALL(mock_service_observer(), |
| BookmarkParentFolderChildrenReordered( |
| BookmarkParentFolder::BookmarkBarFolder())); |
| model().ReorderChildren(parent, new_order); |
| } |
| |
| TEST_F(BookmarkMergedSurfaceServiceTest, BookmarkAllUserNodesRemoved) { |
| CreateBookmarkMergedSurfaceService(); |
| model().CreateAccountPermanentFolders(); |
| AddNodesFromModelString(&model(), model().bookmark_bar_node(), |
| "1 2 3 f1:[ 4 5 ] "); |
| AddNodesFromModelString(&model(), model().account_bookmark_bar_node(), |
| "7 8 9 f3:[ 10 11 ] "); |
| ASSERT_EQ( |
| service().GetChildrenCount(BookmarkParentFolder::BookmarkBarFolder()), |
| 8u); |
| |
| EXPECT_CALL(mock_service_observer(), BookmarkAllUserNodesRemoved); |
| model().RemoveAllUserBookmarks(FROM_HERE); |
| |
| EXPECT_EQ( |
| service().GetChildrenCount(BookmarkParentFolder::BookmarkBarFolder()), |
| 0u); |
| } |
| |
| TEST(BookmarkMergedSurfaceServiceLoadingTest, ModelLoadedFirst) { |
| std::unique_ptr<bookmarks::BookmarkModel> model = |
| std::make_unique<bookmarks::BookmarkModel>( |
| std::make_unique<bookmarks::TestBookmarkClient>()); |
| BookmarkMergedSurfaceService service(model.get(), |
| /*managed_bookmark_service=*/nullptr); |
| MockBookmarkMergedSurfaceServiceObserver mock_observer; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| scoped_mock_observer{&mock_observer}; |
| scoped_mock_observer.Observe(&service); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(0); |
| EXPECT_CALL(mock_observer, BookmarkNodeAdded).Times(0); |
| model->LoadEmptyForTest(); |
| // Notifications ignored while service is not loaded yet. |
| AddNodesFromModelString(model.get(), model->other_node(), "1 2 3 "); |
| Mock::VerifyAndClearExpectations(&mock_observer); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(1); |
| service.LoadForTesting({}); |
| |
| // Verify service is observing the bookmark model. |
| EXPECT_CALL(mock_observer, |
| BookmarkNodeAdded(BookmarkParentFolder::BookmarkBarFolder(), _)) |
| .Times(3); |
| AddNodesFromModelString(model.get(), model->bookmark_bar_node(), "1 2 3 "); |
| } |
| |
| TEST(BookmarkMergedSurfaceServiceLoadingTest, ServiceLoadedFirst) { |
| std::unique_ptr<bookmarks::BookmarkModel> model = |
| std::make_unique<bookmarks::BookmarkModel>( |
| std::make_unique<bookmarks::TestBookmarkClient>()); |
| BookmarkMergedSurfaceService service(model.get(), |
| /*managed_bookmark_service=*/nullptr); |
| MockBookmarkMergedSurfaceServiceObserver mock_observer; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| scoped_mock_observer{&mock_observer}; |
| scoped_mock_observer.Observe(&service); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(0); |
| service.LoadForTesting({}); |
| Mock::VerifyAndClearExpectations(&mock_observer); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(1); |
| model->LoadEmptyForTest(); |
| |
| // Verify service is observing the bookmark model. |
| EXPECT_CALL(mock_observer, |
| BookmarkNodeAdded(BookmarkParentFolder::BookmarkBarFolder(), _)) |
| .Times(3); |
| AddNodesFromModelString(model.get(), model->bookmark_bar_node(), "1 2 3 "); |
| } |
| |
| TEST(BookmarkMergedSurfaceServiceLoadingTest, IdsReassigned) { |
| std::unique_ptr<bookmarks::BookmarkModel> model = |
| std::make_unique<bookmarks::BookmarkModel>( |
| std::make_unique<bookmarks::TestBookmarkClient>()); |
| BookmarkMergedSurfaceService service(model.get(), |
| /*managed_bookmark_service=*/nullptr); |
| MockBookmarkMergedSurfaceServiceObserver mock_observer; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| scoped_mock_observer{&mock_observer}; |
| scoped_mock_observer.Observe(&service); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(1); |
| service.BookmarkModelLoaded(/*ids_reassigned=*/true); |
| model->LoadEmptyForTest(); |
| } |
| |
| TEST(BookmarkMergedSurfaceServiceLoadingTest, CustomOrder) { |
| base::test::ScopedFeatureList features{ |
| switches::kSyncEnableBookmarksInTransportMode}; |
| std::unique_ptr<bookmarks::BookmarkModel> model = |
| std::make_unique<bookmarks::BookmarkModel>( |
| std::make_unique<bookmarks::TestBookmarkClient>()); |
| BookmarkMergedSurfaceService service(model.get(), |
| /*managed_bookmark_service=*/nullptr); |
| MockBookmarkMergedSurfaceServiceObserver mock_observer; |
| base::ScopedObservation<BookmarkMergedSurfaceService, |
| BookmarkMergedSurfaceServiceObserver> |
| scoped_mock_observer{&mock_observer}; |
| scoped_mock_observer.Observe(&service); |
| |
| model->LoadEmptyForTest(); |
| model->CreateAccountPermanentFolders(); |
| AddNodesFromModelString(model.get(), model->bookmark_bar_node(), "1 "); |
| AddNodesFromModelString(model.get(), model->account_bookmark_bar_node(), |
| "4 5 "); |
| |
| EXPECT_CALL(mock_observer, BookmarkMergedSurfaceServiceLoaded()).Times(1); |
| service.LoadForTesting( |
| {{PermanentFolderType::kBookmarkBarNode, |
| {model->bookmark_bar_node()->children()[0]->id(), |
| model->account_bookmark_bar_node()->children()[0]->id(), |
| model->account_bookmark_bar_node()->children()[1]->id()}}}); |
| |
| EXPECT_EQ( |
| service.GetNodeAtIndex(BookmarkParentFolder::BookmarkBarFolder(), 0), |
| model->bookmark_bar_node()->children()[0].get()); |
| EXPECT_EQ( |
| service.GetNodeAtIndex(BookmarkParentFolder::BookmarkBarFolder(), 1), |
| model->account_bookmark_bar_node()->children()[0].get()); |
| } |
| |
| } // namespace |
