Convert TabModelTest to use the public API of TabModel.

ios/chrome/browser/tabs/tab_model_unittest.mm

 // 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/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 89 matching lines @@
 
     session_window_.reset([[SessionWindowIOS alloc] init]);
     // Create tab model with just a dummy session service so the async state
     // saving doesn't trigger unless actually wanted.
     base::scoped_nsobject<TestSessionService> test_service(
         [[TestSessionService alloc] init]);
     tab_model_.reset([[TabModel alloc]
         initWithSessionWindow:session_window_.get()
                sessionService:test_service
                  browserState:chrome_browser_state_.get()]);
-    [tab_model_ setWebUsageEnabled:YES];
+    [tab_model_ setWebUsageEnabled:NO];
     [tab_model_ setPrimary:YES];
     tab_model_observer_.reset([[TabModelObserverPong alloc] init]);
     [tab_model_ addObserver:tab_model_observer_];
   }
 
   ~TabModelTest() override {
     [tab_model_ removeObserver:tab_model_observer_];
     [tab_model_ browserStateDestroyed];
   }
 
@@ skipping 47 matching lines @@
   base::mac::ScopedNSAutoreleasePool pool_;
   base::scoped_nsobject<TabModel> tab_model_;
   base::scoped_nsobject<TabModelObserverPong> tab_model_observer_;
 };
 
 TEST_F(TabModelTest, IsEmpty) {
   EXPECT_EQ([tab_model_ count], 0U);
   EXPECT_TRUE([tab_model_ isEmpty]);
   [tab_model_ insertTabWithURL:kURL
                       referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
                         opener:nil
-                       atIndex:0];
+                   openedByDOM:NO
+                       atIndex:0
+                  inBackground:YES];
   ASSERT_EQ(1U, [tab_model_ count]);
   EXPECT_FALSE([tab_model_ isEmpty]);
 }
 
 TEST_F(TabModelTest, InsertUrlSingle) {
   Tab* tab = [tab_model_ insertTabWithURL:kURL
                                  referrer:kReferrer
+                               transition:ui::PAGE_TRANSITION_TYPED
                                    opener:nil
-                                  atIndex:0];
+                              openedByDOM:NO
+                                  atIndex:0
+                             inBackground:YES];
   ASSERT_EQ(1U, [tab_model_ count]);
   EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]);
 }
 
 TEST_F(TabModelTest, InsertUrlMultiple) {
   Tab* tab0 = [tab_model_ insertTabWithURL:kURL
                                   referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
-                                   atIndex:0];
+                               openedByDOM:NO
+                                   atIndex:0
+                              inBackground:YES];
   Tab* tab1 = [tab_model_ insertTabWithURL:kURL
                                   referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
-                                   atIndex:0];
+                               openedByDOM:NO
+                                   atIndex:0
+                              inBackground:YES];
   Tab* tab2 = [tab_model_ insertTabWithURL:kURL
                                   referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
-                                   atIndex:1];
+                               openedByDOM:NO
+                                   atIndex:1
+                              inBackground:YES];
 
   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_ addTabWithURL:kURL referrer:kReferrer];
+  Tab* tab = [tab_model_ insertTabWithURL:kURL
+                                 referrer:kReferrer
+                               transition:ui::PAGE_TRANSITION_TYPED
+                                   opener:nil
+                              openedByDOM:NO
+                                  atIndex:[tab_model_ count]
+                             inBackground:YES];
   ASSERT_EQ(1U, [tab_model_ count]);
   EXPECT_NSEQ(tab, [tab_model_ tabAtIndex:0]);
 }
 
 TEST_F(TabModelTest, AppendUrlMultiple) {
-  Tab* tab0 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab1 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab2 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  Tab* tab0 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab1 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab2 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
 
   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_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab1 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab2 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  Tab* tab1 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab2 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
 
   [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_ addTabWithURL:kURL referrer:kReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab2 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  Tab* tab0 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  Tab* tab2 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
 
   [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_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab1 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  Tab* tab0 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab1 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   [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_ addTabWithURL:kURL referrer:kReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   [tab_model_ closeTabAtIndex:0];
 
   EXPECT_EQ(0U, [tab_model_ count]);
 }
 
 TEST_F(TabModelTest, RestoreSessionOnNTPTest) {
   Tab* tab = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL)
                                  referrer:kEmptyReferrer
+                               transition:ui::PAGE_TRANSITION_TYPED
                                    opener:nil
-                                  atIndex:0];
+                              openedByDOM:NO
+                                  atIndex:0
+                             inBackground:YES];
   base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow(3));
 
   RestoreSession(window.get());
   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:kEmptyReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
-                                   atIndex:0];
+                               openedByDOM:NO
+                                   atIndex:0
+                              inBackground:YES];
   Tab* tab1 = [tab_model_ insertTabWithURL:GURL(kChromeUINewTabURL)
                                   referrer:kEmptyReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
                                     opener:nil
-                                   atIndex:1];
+                               openedByDOM:NO
+                                   atIndex:1
+                              inBackground:YES];
   base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow(3));
 
   RestoreSession(window.get());
   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:kURL
                                  referrer:kEmptyReferrer
+                               transition:ui::PAGE_TRANSITION_TYPED
                                    opener:nil
-                                  atIndex:0];
+                              openedByDOM:NO
+                                  atIndex:0
+                             inBackground:YES];
   base::scoped_nsobject<SessionWindowIOS> window(CreateSessionWindow(3));
 
   RestoreSession(window.get());
   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_ addTabWithURL:kURL referrer:kReferrer];
-  [tab_model_ addTabWithURL:GURL("https://www.some.url2.com")
-                   referrer:kReferrer2];
-  [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:GURL("https://www.some.url2.com")
+                      referrer:kReferrer2
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   [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_ insertTabWithWebState:CreateWebState(@"opener", -1)
                                            atIndex:0];
   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_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   // Create parent tab.
   Tab* parent_tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                               atIndex:[tab_model_ count]];
   // Create child tab.
   Tab* child_tab =
       [tab_model_ insertTabWithWebState:CreateChildWebState(parent_tab)
                                 atIndex:[tab_model_ count]];
   // Create another unrelated tab.
   Tab* another_tab = [tab_model_ insertTabWithWebState:CreateWebState()
@@ skipping 16 matching lines @@
 
 TEST_F(TabModelTest, OpenersEmptyModel) {
   // Empty model.
   EXPECT_TRUE([tab_model_ isEmpty]);
   EXPECT_FALSE([tab_model_ nextTabWithOpener:nil afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:nil]);
 }
 
 TEST_F(TabModelTest, OpenersNothingOpenedGeneral) {
   // Start with a few tabs.
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   Tab* tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                        atIndex:[tab_model_ count]];
 
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   // All should fail since this hasn't opened anything else.
   EXPECT_FALSE([tab_model_ nextTabWithOpener:tab afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:tab]);
 
   // Add more items to the tab, expect the same results.
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+
   EXPECT_FALSE([tab_model_ nextTabWithOpener:tab afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:tab]);
 }
 
 TEST_F(TabModelTest, OpenersNothingOpenedFirst) {
   // Our tab is first.
   Tab* tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                        atIndex:[tab_model_ count]];
 
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   // All should fail since this hasn't opened anything else.
   EXPECT_FALSE([tab_model_ nextTabWithOpener:tab afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:tab]);
 }
 
 TEST_F(TabModelTest, OpenersNothingOpenedLast) {
   // Our tab is last.
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
   Tab* tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                        atIndex:[tab_model_ count]];
 
   // All should fail since this hasn't opened anything else.
   EXPECT_FALSE([tab_model_ nextTabWithOpener:tab afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:tab]);
 }
 
 TEST_F(TabModelTest, OpenersChildTabBeforeOpener) {
   Tab* parent_tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                               atIndex:[tab_model_ count]];
   // Insert child at start
   [tab_model_ insertTabWithWebState:CreateChildWebState(parent_tab) atIndex:0];
 
   // Insert a few more between them.
   [tab_model_ insertTabWithWebState:CreateWebState() atIndex:1];
   [tab_model_ insertTabWithWebState:CreateWebState() atIndex:1];
 
   EXPECT_FALSE([tab_model_ nextTabWithOpener:parent_tab afterTab:nil]);
   EXPECT_FALSE([tab_model_ lastTabWithOpener:parent_tab]);
 }
 
 TEST_F(TabModelTest, OpenersChildTabAfterOpener) {
   Tab* parent_tab = [tab_model_ insertTabWithWebState:CreateWebState()
                                               atIndex:[tab_model_ count]];
 
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
   // Insert two children at end.
   Tab* child_tab1 =
       [tab_model_ insertTabWithWebState:CreateChildWebState(parent_tab)
                                 atIndex:[tab_model_ count]];
   Tab* child_tab2 =
       [tab_model_ insertTabWithWebState:CreateChildWebState(parent_tab)
                                 atIndex:[tab_model_ count]];
 
   EXPECT_EQ([tab_model_ nextTabWithOpener:parent_tab afterTab:nil], child_tab1);
   EXPECT_EQ([tab_model_ nextTabWithOpener:parent_tab afterTab:child_tab1],
             child_tab2);
   EXPECT_EQ([tab_model_ lastTabWithOpener:parent_tab], child_tab2);
 }
 
 TEST_F(TabModelTest, AddWithOrderController) {
   // Create a few tabs with the controller at the front.
-  Tab* parent = [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  Tab* parent = [tab_model_ insertTabWithURL:kURL
+                                    referrer:kEmptyReferrer
+                                  transition:ui::PAGE_TRANSITION_TYPED
+                                      opener:nil
+                                 openedByDOM:NO
+                                     atIndex:[tab_model_ count]
+                                inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   // Add a new tab, it should be added behind the parent.
   Tab* child =
       [tab_model_ insertTabWithURL:kURL
                           referrer:kEmptyReferrer
                         transition:ui::PAGE_TRANSITION_LINK
                             opener:parent
                        openedByDOM:NO
                            atIndex:TabModelConstants::kTabPositionAutomatically
                       inBackground:NO];
@@ skipping 39 matching lines @@
                         transition:ui::PAGE_TRANSITION_LINK
                             opener:tab3
                        openedByDOM:NO
                            atIndex:TabModelConstants::kTabPositionAutomatically
                       inBackground:YES];
   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_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  Tab* parent = [tab_model_ insertTabWithURL:kURL
+                                    referrer:kEmptyReferrer
+                                  transition:ui::PAGE_TRANSITION_TYPED
+                                      opener:nil
+                                 openedByDOM:NO
+                                     atIndex:[tab_model_ count]
+                                inBackground:YES];
   // Force the history to update, as it is used to determine grouping.
-  ASSERT_TRUE([parent navigationManager]);
+  ASSERT_TRUE([parent navigationManagerImpl]);
   [[parent navigationManagerImpl]->GetSessionController() commitPendingItem];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   ASSERT_TRUE(chrome_browser_state_->CreateHistoryService(true));
 
   // Add a new tab, it should be added behind the parent.
   Tab* child1 =
       [tab_model_ insertTabWithURL:kURL
                           referrer:kEmptyReferrer
                         transition:ui::PAGE_TRANSITION_LINK
                             opener:parent
                        openedByDOM:NO
@@ skipping 12 matching lines @@
                        openedByDOM:NO
                            atIndex:TabModelConstants::kTabPositionAutomatically
                       inBackground:YES];
   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 webController] loadWithParams:parent_params];
-  ASSERT_TRUE([parent navigationManager]);
+  ASSERT_TRUE([parent navigationManagerImpl]);
   [[parent navigationManagerImpl]->GetSessionController() 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:kURL
                           referrer:kEmptyReferrer
                         transition:ui::PAGE_TRANSITION_LINK
                             opener:parent
@@ skipping 12 matching lines @@
                        openedByDOM:NO
                            atIndex:TabModelConstants::kTabPositionAutomatically
                       inBackground:YES];
   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_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  Tab* nonChild = [tab_model_ insertTabWithURL:kURL
+                                      referrer:kEmptyReferrer
+                                    transition:ui::PAGE_TRANSITION_TYPED
+                                        opener:nil
+                                   openedByDOM:NO
+                                       atIndex:[tab_model_ count]
+                                  inBackground:YES];
   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_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  Tab* parent = [tab_model_ insertTabWithURL:kURL
+                                    referrer:kEmptyReferrer
+                                  transition:ui::PAGE_TRANSITION_TYPED
+                                      opener:nil
+                                 openedByDOM:NO
+                                     atIndex:[tab_model_ count]
+                                inBackground:YES];
   // Force the history to update, as it is used to determine grouping.
-  ASSERT_TRUE([parent navigationManager]);
+  ASSERT_TRUE([parent navigationManagerImpl]);
   [[parent navigationManagerImpl]->GetSessionController() commitPendingItem];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
-  [tab_model_ addTabWithURL:kURL referrer:kEmptyReferrer];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
+  [tab_model_ insertTabWithURL:kURL
+                      referrer:kEmptyReferrer
+                    transition:ui::PAGE_TRANSITION_TYPED
+                        opener:nil
+                   openedByDOM:NO
+                       atIndex:[tab_model_ count]
+                  inBackground:YES];
 
   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:kURL
                                     referrer:kEmptyReferrer
                                   transition:ui::PAGE_TRANSITION_LINK
                                       opener:parent
                                  openedByDOM:NO
@@ skipping 24 matching lines @@
                                  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_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab1 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
-  Tab* tab2 = [tab_model_ addTabWithURL:kURL referrer:kReferrer];
+  Tab* tab0 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab1 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
+  Tab* tab2 = [tab_model_ insertTabWithURL:kURL
+                                  referrer:kReferrer
+                                transition:ui::PAGE_TRANSITION_TYPED
+                                    opener:nil
+                               openedByDOM:NO
+                                   atIndex:[tab_model_ count]
+                              inBackground:YES];
 
   // 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]);
 
   // 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];
@@ skipping 68 matching lines @@
   base::mac::ScopedNSAutoreleasePool pool;
 
   NSString* stashPath =
       base::SysUTF8ToNSString(chrome_browser_state->GetStatePath().value());
 
   base::scoped_nsobject<TabModel> model([[TabModel alloc]
       initWithSessionWindow:session_window_.get()
              sessionService:[SessionServiceIOS sharedService]
                browserState:chrome_browser_state.get()]);
 
-  [model addTabWithURL:kURL referrer:kReferrer];
   [model insertTabWithURL:kURL
                  referrer:kReferrer
-                   opener:[model tabAtIndex:0]
-                  atIndex:[model count]];
+               transition:ui::PAGE_TRANSITION_TYPED
+                   opener:nil
+              openedByDOM:NO
+                  atIndex:[model count]
+             inBackground:YES];
   [model insertTabWithURL:kURL
                  referrer:kReferrer
+               transition:ui::PAGE_TRANSITION_TYPED
+                   opener:[model tabAtIndex:0]
+              openedByDOM:NO
+                  atIndex:[model count]
+             inBackground:YES];
+  [model insertTabWithURL:kURL
+                 referrer:kReferrer
+               transition:ui::PAGE_TRANSITION_TYPED
                    opener:[model tabAtIndex:1]
-                  atIndex:0];
+              openedByDOM:NO
+                  atIndex:0
+             inBackground:YES];
 
   ASSERT_EQ(3U, [model count]);
   [model setCurrentTab:[model tabAtIndex:1]];
 
   EXPECT_EQ(nil, [model openerOfTab:[model tabAtIndex:1]]);
   EXPECT_EQ([model tabAtIndex:1], [model openerOfTab:[model tabAtIndex:2]]);
   EXPECT_EQ([model tabAtIndex:2], [model openerOfTab:[model tabAtIndex:0]]);
 
   // Force state to flush to disk on the main thread so it can be immediately
   // tested below.
@@ skipping 31 matching lines @@
   // Restoring TabModel session sends asynchronous tasks to IO thread, wait
   // for them to complete after destroying the TabModel.
   base::RunLoop().RunUntilIdle();
 
   // Clean up.
   EXPECT_TRUE([[NSFileManager defaultManager] removeItemAtPath:stashPath
                                                          error:nullptr]);
 }
 
 }  // anonymous namespace