| // Copyright 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #import <objc/runtime.h> |
| |
| #include "base/files/file_path.h" |
| #include "base/run_loop.h" |
| #include "base/strings/sys_string_conversions.h" |
| #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h" |
| #include "ios/chrome/browser/browser_state/test_chrome_browser_state_manager.h" |
| #include "ios/chrome/browser/chrome_url_constants.h" |
| #include "ios/chrome/browser/infobars/infobar_manager_impl.h" |
| #include "ios/chrome/browser/sessions/ios_chrome_session_tab_helper.h" |
| #import "ios/chrome/browser/sessions/session_ios.h" |
| #import "ios/chrome/browser/sessions/session_window_ios.h" |
| #import "ios/chrome/browser/sessions/test_session_service.h" |
| #import "ios/chrome/browser/tabs/legacy_tab_helper.h" |
| #import "ios/chrome/browser/tabs/tab.h" |
| #import "ios/chrome/browser/tabs/tab_helper_util.h" |
| #import "ios/chrome/browser/tabs/tab_model.h" |
| #import "ios/chrome/browser/tabs/tab_model_observer.h" |
| #import "ios/chrome/browser/tabs/tab_private.h" |
| #import "ios/chrome/browser/web/chrome_web_client.h" |
| #import "ios/chrome/browser/web_state_list/web_state_list.h" |
| #import "ios/chrome/browser/web_state_list/web_state_opener.h" |
| #include "ios/chrome/test/ios_chrome_scoped_testing_chrome_browser_state_manager.h" |
| #import "ios/web/navigation/navigation_manager_impl.h" |
| #import "ios/web/public/crw_session_storage.h" |
| #import "ios/web/public/navigation_manager.h" |
| #include "ios/web/public/referrer.h" |
| #import "ios/web/public/serializable_user_data_manager.h" |
| #include "ios/web/public/test/scoped_testing_web_client.h" |
| #include "ios/web/public/test/test_web_thread_bundle.h" |
| #include "ios/web/public/web_thread.h" |
| #import "ios/web/navigation/navigation_manager_impl.h" |
| #import "ios/web/web_state/web_state_impl.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/gtest_mac.h" |
| #include "testing/platform_test.h" |
| #import "third_party/ocmock/OCMock/OCMock.h" |
| #include "third_party/ocmock/gtest_support.h" |
| |
| #if !defined(__has_feature) || !__has_feature(objc_arc) |
| #error "This file requires ARC support." |
| #endif |
| |
| // Defines a TabModelObserver for use in unittests. This class can be used to |
| // test if an observer method was called or not. |
| @interface TabModelObserverPong : NSObject<TabModelObserver> { |
| // TODO(crbug.com/661989): Add tests for the other observer methods. |
| BOOL tabMovedWasCalled_; |
| } |
| @property(nonatomic, assign) BOOL tabMovedWasCalled; |
| @end |
| |
| @implementation TabModelObserverPong |
| @synthesize tabMovedWasCalled = tabMovedWasCalled_; |
| |
| - (void)tabModel:(TabModel*)model |
| didMoveTab:(Tab*)tab |
| fromIndex:(NSUInteger)fromIndex |
| toIndex:(NSUInteger)toIndex { |
| tabMovedWasCalled_ = YES; |
| } |
| |
| @end |
| |
| namespace { |
| |
| const char kURL1[] = "https://www.some.url.com"; |
| const char kURL2[] = "https://www.some.url2.com"; |
| |
| class TabModelTest : public PlatformTest { |
| public: |
| TabModelTest() |
| : scoped_browser_state_manager_( |
| std::make_unique<TestChromeBrowserStateManager>(base::FilePath())), |
| web_client_(std::make_unique<ChromeWebClient>()) { |
| DCHECK_CURRENTLY_ON(web::WebThread::UI); |
| |
| TestChromeBrowserState::Builder test_cbs_builder; |
| chrome_browser_state_ = test_cbs_builder.Build(); |
| |
| session_window_ = [[SessionWindowIOS alloc] init]; |
| |
| // Create tab model with just a dummy session service so the async state |
| // saving doesn't trigger unless actually wanted. |
| SetTabModel(CreateTabModel([[TestSessionService alloc] init], nil)); |
| } |
| |
| ~TabModelTest() override = default; |
| |
| void TearDown() override { |
| SetTabModel(nil); |
| PlatformTest::TearDown(); |
| } |
| |
| void SetTabModel(TabModel* tab_model) { |
| if (tab_model_) { |
| @autoreleasepool { |
| [tab_model_ browserStateDestroyed]; |
| tab_model_ = nil; |
| } |
| } |
| |
| tab_model_ = tab_model; |
| } |
| |
| TabModel* CreateTabModel(SessionServiceIOS* session_service, |
| SessionWindowIOS* session_window) { |
| TabModel* tab_model([[TabModel alloc] |
| initWithSessionWindow:session_window |
| sessionService:session_service |
| browserState:chrome_browser_state_.get()]); |
| [tab_model setWebUsageEnabled:NO]; |
| [tab_model setPrimary:YES]; |
| return tab_model; |
| } |
| |
| protected: |
| // Creates a session window with entries named "restored window 1", |
| // "restored window 2" and "restored window 3" and the second entry |
| // marked as selected. |
| SessionWindowIOS* CreateSessionWindow() { |
| NSMutableArray<CRWSessionStorage*>* sessions = [NSMutableArray array]; |
| for (int i = 0; i < 3; i++) { |
| CRWSessionStorage* session_storage = [[CRWSessionStorage alloc] init]; |
| session_storage.lastCommittedItemIndex = -1; |
| [sessions addObject:session_storage]; |
| } |
| return [[SessionWindowIOS alloc] initWithSessions:sessions selectedIndex:1]; |
| } |
| |
| web::TestWebThreadBundle thread_bundle_; |
| IOSChromeScopedTestingChromeBrowserStateManager scoped_browser_state_manager_; |
| web::ScopedTestingWebClient web_client_; |
| SessionWindowIOS* session_window_; |
| std::unique_ptr<TestChromeBrowserState> chrome_browser_state_; |
| TabModel* tab_model_; |
| }; |
| |
| TEST_F(TabModelTest, IsEmpty) { |
| EXPECT_EQ([tab_model_ count], 0U); |
| EXPECT_TRUE([tab_model_ isEmpty]); |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| ASSERT_EQ(1U, [tab_model_ count]); |
| EXPECT_FALSE([tab_model_ isEmpty]); |
| } |
| |
| TEST_F(TabModelTest, InsertUrlSingle) { |
| Tab* tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| ASSERT_EQ(1U, [tab_model_ count]); |
| EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]); |
| } |
| |
| TEST_F(TabModelTest, InsertUrlMultiple) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:1 |
| inBackground:NO]; |
| |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:2]); |
| } |
| |
| TEST_F(TabModelTest, AppendUrlSingle) { |
| Tab* tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| ASSERT_EQ(1U, [tab_model_ count]); |
| EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]); |
| } |
| |
| TEST_F(TabModelTest, AppendUrlMultiple) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:2]); |
| } |
| |
| TEST_F(TabModelTest, CloseTabAtIndexBeginning) { |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| [tab_model_ closeTabAtIndex:0]; |
| |
| ASSERT_EQ(2U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| } |
| |
| TEST_F(TabModelTest, CloseTabAtIndexMiddle) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| [tab_model_ closeTabAtIndex:1]; |
| |
| ASSERT_EQ(2U, [tab_model_ count]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| } |
| |
| TEST_F(TabModelTest, CloseTabAtIndexLast) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| [tab_model_ closeTabAtIndex:2]; |
| |
| ASSERT_EQ(2U, [tab_model_ count]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:1]); |
| } |
| |
| TEST_F(TabModelTest, CloseTabAtIndexOnlyOne) { |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| [tab_model_ closeTabAtIndex:0]; |
| |
| EXPECT_EQ(0U, [tab_model_ count]); |
| } |
| |
| TEST_F(TabModelTest, RestoreSessionOnNTPTest) { |
| Tab* tab = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| web::WebStateImpl* web_state = static_cast<web::WebStateImpl*>(tab.webState); |
| web_state->GetNavigationManagerImpl().CommitPendingItem(); |
| |
| SessionWindowIOS* window(CreateSessionWindow()); |
| [tab_model_ restoreSessionWindow:window]; |
| |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ([tab_model_ tabAtIndex:1], [tab_model_ currentTab]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:2]); |
| } |
| |
| TEST_F(TabModelTest, RestoreSessionOn2NtpTest) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| web::WebStateImpl* web_state = static_cast<web::WebStateImpl*>(tab0.webState); |
| web_state->GetNavigationManagerImpl().CommitPendingItem(); |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:1 |
| inBackground:NO]; |
| web_state = static_cast<web::WebStateImpl*>(tab1.webState); |
| web_state->GetNavigationManagerImpl().CommitPendingItem(); |
| |
| SessionWindowIOS* window(CreateSessionWindow()); |
| [tab_model_ restoreSessionWindow:window]; |
| |
| ASSERT_EQ(5U, [tab_model_ count]); |
| EXPECT_NSEQ([tab_model_ tabAtIndex:3], [tab_model_ currentTab]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:2]); |
| EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:3]); |
| EXPECT_NSNE(tab0, [tab_model_ tabAtIndex:4]); |
| EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:2]); |
| EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:3]); |
| EXPECT_NSNE(tab1, [tab_model_ tabAtIndex:4]); |
| } |
| |
| TEST_F(TabModelTest, RestoreSessionOnAnyTest) { |
| Tab* tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| web::WebStateImpl* web_state = static_cast<web::WebStateImpl*>(tab.webState); |
| web_state->GetNavigationManagerImpl().CommitPendingItem(); |
| |
| SessionWindowIOS* window(CreateSessionWindow()); |
| [tab_model_ restoreSessionWindow:window]; |
| |
| ASSERT_EQ(4U, [tab_model_ count]); |
| EXPECT_NSEQ([tab_model_ tabAtIndex:2], [tab_model_ currentTab]); |
| EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:2]); |
| EXPECT_NSNE(tab, [tab_model_ tabAtIndex:3]); |
| } |
| |
| TEST_F(TabModelTest, CloseAllTabs) { |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL2) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| [tab_model_ closeAllTabs]; |
| |
| EXPECT_EQ(0U, [tab_model_ count]); |
| } |
| |
| TEST_F(TabModelTest, CloseAllTabsWithNoTabs) { |
| [tab_model_ closeAllTabs]; |
| |
| EXPECT_EQ(0U, [tab_model_ count]); |
| } |
| |
| TEST_F(TabModelTest, InsertWithSessionController) { |
| EXPECT_EQ([tab_model_ count], 0U); |
| EXPECT_TRUE([tab_model_ isEmpty]); |
| |
| Tab* new_tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| EXPECT_EQ([tab_model_ count], 1U); |
| [tab_model_ setCurrentTab:new_tab]; |
| Tab* current_tab = [tab_model_ currentTab]; |
| EXPECT_TRUE(current_tab); |
| } |
| |
| TEST_F(TabModelTest, OpenerOfTab) { |
| // Start off with a couple tabs. |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Create parent tab. |
| Tab* parent_tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Create child tab. |
| Tab* child_tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:parent_tab |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Create another unrelated tab. |
| Tab* another_tab = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Create another child of the first tab. |
| Tab* child_tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:parent_tab |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| EXPECT_FALSE([tab_model_ openerOfTab:parent_tab]); |
| EXPECT_FALSE([tab_model_ openerOfTab:another_tab]); |
| EXPECT_EQ(parent_tab, [tab_model_ openerOfTab:child_tab]); |
| EXPECT_EQ(parent_tab, [tab_model_ openerOfTab:child_tab2]); |
| } |
| |
| TEST_F(TabModelTest, OpenerOfTabEmptyModel) { |
| EXPECT_FALSE([tab_model_ openerOfTab:nil]); |
| } |
| |
| TEST_F(TabModelTest, AddWithOrderController) { |
| // Create a few tabs with the controller at the front. |
| Tab* parent = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Add a new tab, it should be added behind the parent. |
| Tab* child = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 0U); |
| EXPECT_EQ([tab_model_ indexOfTab:child], 1U); |
| |
| // Add another new tab without a parent, should go at the end. |
| Tab* tab = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:nil |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:tab], [tab_model_ count] - 1); |
| |
| // Same for a tab that's not opened via a LINK transition. |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:tab2], [tab_model_ count] - 1); |
| |
| // Add a tab in the background. It should appear behind the opening tab. |
| Tab* tab3 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:tab |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:tab3], [tab_model_ indexOfTab:tab] + 1); |
| |
| // Add another background tab behind the one we just opened. |
| Tab* tab4 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:tab3 |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:tab4], [tab_model_ indexOfTab:tab3] + 1); |
| } |
| |
| TEST_F(TabModelTest, AddWithOrderControllerAndGrouping) { |
| // Create a few tabs with the controller at the front. |
| Tab* parent = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| // Force the history to update, as it is used to determine grouping. |
| ASSERT_TRUE([parent navigationManagerImpl]); |
| [parent navigationManagerImpl]->CommitPendingItem(); |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| ASSERT_TRUE(chrome_browser_state_->CreateHistoryService(true)); |
| |
| // Add a new tab, it should be added behind the parent. |
| Tab* child1 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 0U); |
| EXPECT_EQ([tab_model_ indexOfTab:child1], 1U); |
| |
| // Add a second child tab in the background. It should be added behind the |
| // first child. |
| Tab* child2 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:child2], 2U); |
| |
| // Navigate the parent tab to a new URL. It should not change any ordering. |
| web::NavigationManager::WebLoadParams parent_params( |
| GURL("http://www.espn.com")); |
| parent_params.transition_type = ui::PAGE_TRANSITION_TYPED; |
| [parent navigationManager]->LoadURLWithParams(parent_params); |
| ASSERT_TRUE([parent navigationManagerImpl]); |
| [parent navigationManagerImpl]->CommitPendingItem(); |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 0U); |
| |
| // Add a new tab. It should be added behind the parent. It should not be added |
| // after the previous two children. |
| Tab* child3 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:child3], 1U); |
| |
| // Add a fourt child tab in the background. It should be added behind the |
| // third child. |
| Tab* child4 = |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:TabModelConstants::kTabPositionAutomatically |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:child4], 2U); |
| |
| // The first two children should have been moved to the right. |
| EXPECT_EQ([tab_model_ indexOfTab:child1], 3U); |
| EXPECT_EQ([tab_model_ indexOfTab:child2], 4U); |
| |
| // Now add a non-owned tab and make sure it is added at the end. |
| Tab* nonChild = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:nonChild], [tab_model_ count] - 1); |
| } |
| |
| TEST_F(TabModelTest, AddWithLinkTransitionAndIndex) { |
| // Create a few tabs with the controller at the front. |
| Tab* parent = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| // Force the history to update, as it is used to determine grouping. |
| ASSERT_TRUE([parent navigationManagerImpl]); |
| [parent navigationManagerImpl]->CommitPendingItem(); |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| ASSERT_TRUE(chrome_browser_state_->CreateHistoryService(true)); |
| |
| // Add a new tab, it should be added before the parent since the index |
| // parameter has been specified with a valid value. |
| Tab* child1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 1U); |
| EXPECT_EQ([tab_model_ indexOfTab:child1], 0U); |
| |
| // Add a new tab, it should be added at the beginning of the stack because |
| // the index parameter has been specified with a valid value. |
| Tab* child2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 2U); |
| EXPECT_EQ([tab_model_ indexOfTab:child1], 1U); |
| EXPECT_EQ([tab_model_ indexOfTab:child2], 0U); |
| |
| // Add a new tab, it should be added at position 1 because the index parameter |
| // has been specified with a valid value. |
| Tab* child3 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_LINK |
| opener:parent |
| openedByDOM:NO |
| atIndex:1 |
| inBackground:NO]; |
| EXPECT_EQ([tab_model_ indexOfTab:parent], 3U); |
| EXPECT_EQ([tab_model_ indexOfTab:child1], 2U); |
| EXPECT_EQ([tab_model_ indexOfTab:child3], 1U); |
| EXPECT_EQ([tab_model_ indexOfTab:child2], 0U); |
| } |
| |
| TEST_F(TabModelTest, MoveTabs) { |
| Tab* tab0 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| Tab* tab2 = [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| |
| // Basic sanity checks before moving on. |
| ASSERT_EQ(3U, [tab_model_ count]); |
| ASSERT_NSEQ(tab0, [tab_model_ tabAtIndex:0]); |
| ASSERT_NSEQ(tab1, [tab_model_ tabAtIndex:1]); |
| ASSERT_NSEQ(tab2, [tab_model_ tabAtIndex:2]); |
| |
| // Check that observer methods are called. |
| TabModelObserverPong* tab_model_observer; |
| tab_model_observer = [[TabModelObserverPong alloc] init]; |
| [tab_model_ addObserver:tab_model_observer]; |
| |
| // Move a tab from index 1 to index 0 (move tab left by one). |
| [tab_model_observer setTabMovedWasCalled:NO]; |
| [tab_model_ moveTab:[tab_model_ tabAtIndex:1] toIndex:0]; |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:2]); |
| EXPECT_TRUE([tab_model_observer tabMovedWasCalled]); |
| |
| // Move a tab from index 1 to index 2 (move tab right by one). |
| [tab_model_observer setTabMovedWasCalled:NO]; |
| [tab_model_ moveTab:[tab_model_ tabAtIndex:1] toIndex:2]; |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:2]); |
| EXPECT_TRUE([tab_model_observer tabMovedWasCalled]); |
| |
| // Move a tab from index 0 to index 2 (move tab right by more than one). |
| [tab_model_observer setTabMovedWasCalled:NO]; |
| [tab_model_ moveTab:[tab_model_ tabAtIndex:0] toIndex:2]; |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:2]); |
| EXPECT_TRUE([tab_model_observer tabMovedWasCalled]); |
| |
| // Move a tab from index 2 to index 0 (move tab left by more than one). |
| [tab_model_observer setTabMovedWasCalled:NO]; |
| [tab_model_ moveTab:[tab_model_ tabAtIndex:2] toIndex:0]; |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:2]); |
| EXPECT_TRUE([tab_model_observer tabMovedWasCalled]); |
| |
| // Move a tab from index 2 to index 2 (move tab to the same index). |
| [tab_model_observer setTabMovedWasCalled:NO]; |
| [tab_model_ moveTab:[tab_model_ tabAtIndex:2] toIndex:2]; |
| ASSERT_EQ(3U, [tab_model_ count]); |
| EXPECT_NSEQ(tab1, [tab_model_ tabAtIndex:0]); |
| EXPECT_NSEQ(tab2, [tab_model_ tabAtIndex:1]); |
| EXPECT_NSEQ(tab0, [tab_model_ tabAtIndex:2]); |
| EXPECT_FALSE([tab_model_observer tabMovedWasCalled]); |
| |
| // TabModel asserts that there are no observer when it is deallocated, |
| // so remove the observer before the end of the method. |
| [tab_model_ removeObserver:tab_model_observer]; |
| } |
| |
| TEST_F(TabModelTest, ParentTabModel) { |
| std::unique_ptr<web::WebState> web_state = web::WebState::Create( |
| web::WebState::CreateParams(chrome_browser_state_.get())); |
| AttachTabHelpers(web_state.get(), /*for_prerender=*/false); |
| |
| Tab* tab = LegacyTabHelper::GetTabForWebState(web_state.get()); |
| EXPECT_NSEQ(nil, [tab parentTabModel]); |
| |
| [tab_model_ webStateList]->InsertWebState(0, std::move(web_state), |
| WebStateList::INSERT_FORCE_INDEX, |
| WebStateOpener()); |
| EXPECT_NSEQ(tab_model_, [tab parentTabModel]); |
| } |
| |
| TEST_F(TabModelTest, TabCreatedOnInsertion) { |
| std::unique_ptr<web::WebState> web_state = web::WebState::Create( |
| web::WebState::CreateParams(chrome_browser_state_.get())); |
| |
| EXPECT_NSEQ(nil, LegacyTabHelper::GetTabForWebState(web_state.get())); |
| |
| web::WebState* web_state_ptr = web_state.get(); |
| [tab_model_ webStateList]->InsertWebState(0, std::move(web_state), |
| WebStateList::INSERT_FORCE_INDEX, |
| WebStateOpener()); |
| EXPECT_NSNE(nil, LegacyTabHelper::GetTabForWebState(web_state_ptr)); |
| } |
| |
| TEST_F(TabModelTest, PersistSelectionChange) { |
| NSString* stashPath = |
| base::SysUTF8ToNSString(chrome_browser_state_->GetStatePath().value()); |
| |
| // Reset the TabModel with a custom SessionServiceIOS (to control whether |
| // data is saved to disk). |
| TestSessionService* test_session_service = [[TestSessionService alloc] init]; |
| SetTabModel(CreateTabModel(test_session_service, nil)); |
| |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:nil |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:[tab_model_ tabAtIndex:0] |
| openedByDOM:NO |
| atIndex:[tab_model_ count] |
| inBackground:NO]; |
| [tab_model_ insertTabWithURL:GURL(kURL1) |
| referrer:web::Referrer() |
| transition:ui::PAGE_TRANSITION_TYPED |
| opener:[tab_model_ tabAtIndex:1] |
| openedByDOM:NO |
| atIndex:0 |
| inBackground:NO]; |
| |
| ASSERT_EQ(3U, [tab_model_ count]); |
| [tab_model_ setCurrentTab:[tab_model_ tabAtIndex:1]]; |
| |
| EXPECT_EQ(nil, [tab_model_ openerOfTab:[tab_model_ tabAtIndex:1]]); |
| EXPECT_EQ([tab_model_ tabAtIndex:1], |
| [tab_model_ openerOfTab:[tab_model_ tabAtIndex:2]]); |
| EXPECT_EQ([tab_model_ tabAtIndex:2], |
| [tab_model_ openerOfTab:[tab_model_ tabAtIndex:0]]); |
| |
| // Force state to flush to disk on the main thread so it can be immediately |
| // tested below. |
| [test_session_service setPerformIO:YES]; |
| [tab_model_ saveSessionImmediately:YES]; |
| [test_session_service setPerformIO:NO]; |
| |
| NSString* state_path = base::SysUTF8ToNSString( |
| chrome_browser_state_->GetStatePath().AsUTF8Unsafe()); |
| SessionIOS* session = |
| [test_session_service loadSessionFromDirectory:state_path]; |
| ASSERT_EQ(1u, session.sessionWindows.count); |
| SessionWindowIOS* session_window = session.sessionWindows[0]; |
| |
| // Create tab model from saved session. |
| SetTabModel(CreateTabModel(test_session_service, session_window)); |
| |
| ASSERT_EQ(3u, [tab_model_ count]); |
| |
| EXPECT_EQ([tab_model_ tabAtIndex:1], [tab_model_ currentTab]); |
| EXPECT_EQ(nil, [tab_model_ openerOfTab:[tab_model_ tabAtIndex:1]]); |
| EXPECT_EQ([tab_model_ tabAtIndex:1], |
| [tab_model_ openerOfTab:[tab_model_ tabAtIndex:2]]); |
| EXPECT_EQ([tab_model_ tabAtIndex:2], |
| [tab_model_ openerOfTab:[tab_model_ tabAtIndex:0]]); |
| |
| // Clean up. |
| EXPECT_TRUE([[NSFileManager defaultManager] removeItemAtPath:stashPath |
| error:nullptr]); |
| } |
| |
| } // anonymous namespace |
