[ios] Refactor SessionServiceIOS to remove dependency on BrowserState.

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 66 matching lines @@
   TabModelTest()
       : scoped_browser_state_manager_(
             base::MakeUnique<TestChromeBrowserStateManager>(base::FilePath())),
         web_client_(base::MakeUnique<ChromeWebClient>()) {
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
 
     TestChromeBrowserState::Builder test_cbs_builder;
     chrome_browser_state_ = test_cbs_builder.Build();
 
     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:NO];
-    [tab_model_ setPrimary:YES];
+    SetTabModel(
+        CreateTabModel([[[TestSessionService alloc] init] autorelease], nil));
   }
 
   ~TabModelTest() override {
     [tab_model_ browserStateDestroyed];
   }
 
+  void SetTabModel(base::scoped_nsobject<TabModel> tab_model) {
+    if (tab_model_) {
+      @autoreleasepool {
+        [tab_model_ browserStateDestroyed];
+        tab_model_.reset();
+      }
+    }
+
+    tab_model_ = tab_model;
+  }
+
+  base::scoped_nsobject<TabModel> CreateTabModel(
+      SessionServiceIOS* session_service,
+      SessionWindowIOS* session_window) {
+    base::scoped_nsobject<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.
   base::scoped_nsobject<SessionWindowIOS> CreateSessionWindow() {
     NSMutableArray<CRWSessionStorage*>* sessions = [NSMutableArray array];
     for (int i = 0; i < 3; i++) {
       CRWSessionStorage* session_storage =
           [[[CRWSessionStorage alloc] init] autorelease];
       [sessions addObject:session_storage];
@@ skipping 971 matching lines @@
 
   web::WebState* web_state_ptr = web_state.get();
   [tab_model_ webStateList]->InsertWebState(0, std::move(web_state));
   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).
+  base::scoped_nsobject<TestSessionService> test_session_service(
+      [[TestSessionService alloc] init]);
+  SetTabModel(CreateTabModel(test_session_service.get(), 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
@@ skipping 13 matching lines @@
   [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.
-  SessionWindowIOS* window = [tab_model_ windowForSavingSession];
-  [[SessionServiceIOS sharedService] performSaveWindow:window
-                                           toDirectory:stashPath];
-  [tab_model_ browserStateDestroyed];
-  tab_model_.reset();
+  [test_session_service setPerformIO:YES];
+  [tab_model_ saveSessionImmediately:YES];
+  [test_session_service setPerformIO:NO];
 
-  // Restoring TabModel session sends asynchronous tasks to IO thread, wait
-  // for them to complete after destroying the TabModel.
-  base::RunLoop().RunUntilIdle();
-
-  SessionWindowIOS* sessionWindow = [[SessionServiceIOS sharedService]
-      loadWindowForBrowserState:chrome_browser_state_.get()];
+  NSString* state_path = base::SysUTF8ToNSString(
+      chrome_browser_state_->GetStatePath().AsUTF8Unsafe());
+  NSString* session_path =
+      [test_session_service sessionPathForDirectory:state_path];
+  SessionWindowIOS* session_window =
+      [test_session_service loadSessionWindowFromPath:session_path];
 
   // Create tab model from saved session.
-  base::scoped_nsobject<TestSessionService> test_service(
-      [[TestSessionService alloc] init]);
+  SetTabModel(CreateTabModel(test_session_service.get(), session_window));
 
-  tab_model_.reset([[TabModel alloc]
-      initWithSessionWindow:sessionWindow
-             sessionService:test_service
-               browserState:chrome_browser_state_.get()]);
   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