Revert of Moved NavigationManagerImpl serialization out of CRWSessionController.

ios/chrome/browser/sessions/session_window.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 "ios/chrome/browser/sessions/session_window.h"
 
 #include <list>
 #include <memory>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
-#import "base/mac/scoped_nsobject.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #import "ios/chrome/browser/sessions/NSCoder+Compatibility.h"
 #import "ios/chrome/browser/sessions/session_service.h"
 #import "ios/web/navigation/crw_session_controller.h"
 #import "ios/web/public/web_thread.h"
 #import "ios/web/web_state/web_state_impl.h"
 
 using web::WebStateImpl;
 
-// Serialization keys.
-NSString* const kSessionsKey = @"sessions";
-NSString* const kSelectedIndexKey = @"selectedIndex";
-
 @interface SessionWindowIOS () {
-  // Backing objects for properties of the same name.
-  base::scoped_nsobject<NSMutableArray> _sessions;
-  NSUInteger _selectedIndex;
+ @private
+  NSUInteger _selectedIndex;  // Currently selected session.
+  // For SessionWindows created via -initWithSessions:currentIndex:, the
+  // WebStateImpls in |_sessions| are owned by the calling code. When created
+  // via -initwithCoder:, the code which accepts the SessionWindow object
+  // should take or assign ownership of the contents of |_sessions|.
+  std::list<web::WebStateImpl*> _sessions;
 }
 
-// Returns whether |index| is valid for a session window with |sessionCount|
-// entries.
-- (BOOL)isIndex:(NSUInteger)index validForSessionCount:(NSUInteger)sessionCount;
+// For testing only. Empties _sessions.
+- (void)clearSessions;
 
 @end
 
 @implementation SessionWindowIOS
 
 @synthesize selectedIndex = _selectedIndex;
 
 - (id)init {
   if ((self = [super init])) {
-    _sessions.reset([[NSMutableArray alloc] init]);
     _selectedIndex = NSNotFound;
   }
   return self;
 }
 
-#pragma mark - Accessors
-
-- (NSArray*)sessions {
-  return [NSArray arrayWithArray:_sessions];
+- (id)initWithCoder:(NSCoder*)aDecoder {
+  self = [super init];
+  if (self) {
+    DCHECK([aDecoder isKindOfClass:[SessionWindowUnarchiver class]]);
+    ios::ChromeBrowserState* browserState =
+        static_cast<SessionWindowUnarchiver*>(aDecoder).browserState;
+    DCHECK(browserState);
+    _selectedIndex = [aDecoder cr_decodeIndexForKey:@"selectedIndex"];
+    base::scoped_nsobject<NSArray> decodedSessionControllers(
+        [[aDecoder decodeObjectForKey:@"sessions"] retain]);
+    for (CRWSessionController* sc in decodedSessionControllers.get()) {
+      WebStateImpl* webState = new WebStateImpl(browserState);
+      webState->GetNavigationManagerImpl().SetSessionController(sc);
+      _sessions.push_back(webState);
+    }
+    DCHECK((_sessions.size() && _selectedIndex < _sessions.size()) ||
+           (_sessions.empty() && _selectedIndex == NSNotFound));
+    // If index is somehow corrupted, reset it to zero.
+    // (note that if |_selectedIndex| == |_sessions.size()|, that's
+    // incorrect because the maximum index of a vector of size |n| is |n-1|).
+    // Empty sessions should have |_selectedIndex| values of NSNotFound.
+    if (_sessions.empty()) {
+      _selectedIndex = NSNotFound;
+    } else if (_selectedIndex >= _sessions.size()) {
+      _selectedIndex = 0;
+    }
+  }
+  return self;
 }
 
-- (void)setSelectedIndex:(NSUInteger)selectedIndex {
-  DCHECK([self isIndex:selectedIndex validForSessionCount:[_sessions count]]);
-  _selectedIndex = selectedIndex;
+- (void)dealloc {
+  DCHECK(_sessions.empty());
+  [super dealloc];
 }
 
-#pragma mark - Public
+- (void)clearSessions {
+  while (self.unclaimedSessions) {
+    std::unique_ptr<WebStateImpl> webState = [self nextSession];
+    webState.reset();
+  }
+}
 
-- (void)addSerializedSession:(CRWNavigationManagerStorage*)session {
-  [_sessions addObject:session];
+- (void)encodeWithCoder:(NSCoder*)aCoder {
+  // Destructively pull all of the WebStateImpls out of |_sessions| and hand
+  // off their sessionControllers for archiving. When encoding is complete,
+  // all of the objects in |_sessions| have been destroyed.
+  NSMutableArray* sessionControllers =
+      [NSMutableArray arrayWithCapacity:_sessions.size()];
+  while (self.unclaimedSessions) {
+    std::unique_ptr<WebStateImpl> webState = [self nextSession];
+    CRWSessionController* sessionController =
+        webState->GetNavigationManagerImpl().GetSessionController();
+    [sessionControllers addObject:sessionController];
+
+    // NOTE: WebStateImpl must be destroyed on the UI thread for safety
+    // reasons.
+    web::WebThread::DeleteSoon(web::WebThread::UI, FROM_HERE,
+                               webState.release());
+  }
+
+  [aCoder cr_encodeIndex:_selectedIndex forKey:@"selectedIndex"];
+  [aCoder encodeObject:sessionControllers forKey:@"sessions"];
+}
+
+- (void)addSession:(std::unique_ptr<web::WebStateImpl>)session {
+  DCHECK(session->GetNavigationManagerImpl().GetSessionController());
+  _sessions.push_back(session.release());
   // Set the selected index to 0 (this session) if this is the first session
   // added.
   if (_selectedIndex == NSNotFound)
     _selectedIndex = 0;
 }
 
-- (void)clearSessions {
-  [_sessions removeAllObjects];
-  _selectedIndex = NSNotFound;
+- (void)setSelectedIndex:(NSUInteger)selectedIndex {
+  DCHECK((_sessions.size() && selectedIndex < _sessions.size()) ||
+         (_sessions.empty() && selectedIndex == NSNotFound));
+  _selectedIndex = selectedIndex;
 }
 
-#pragma mark - NSCoding
-
-- (id)initWithCoder:(NSCoder*)aDecoder {
-  self = [super init];
-  if (self) {
-    DCHECK([aDecoder isKindOfClass:[SessionWindowUnarchiver class]]);
-    _selectedIndex = [aDecoder cr_decodeIndexForKey:kSelectedIndexKey];
-    _sessions.reset([[aDecoder decodeObjectForKey:kSessionsKey] retain]);
-    DCHECK(
-        [self isIndex:_selectedIndex validForSessionCount:[_sessions count]]);
-    // If index is somehow corrupted, reset it to zero.
-    // (note that if |_selectedIndex| == |_sessions.size()|, that's
-    // incorrect because the maximum index of a vector of size |n| is |n-1|).
-    // Empty sessions should have |_selectedIndex| values of NSNotFound.
-    if (![_sessions count]) {
-      _selectedIndex = NSNotFound;
-    } else if (_selectedIndex >= [_sessions count]) {
-      _selectedIndex = 0;
-    }
-  }
-  return self;
+- (std::unique_ptr<web::WebStateImpl>)nextSession {
+  std::unique_ptr<web::WebStateImpl> session(_sessions.front());
+  _sessions.pop_front();
+  return session;
 }
 
-- (void)encodeWithCoder:(NSCoder*)aCoder {
-  [aCoder cr_encodeIndex:_selectedIndex forKey:kSelectedIndexKey];
-  [aCoder encodeObject:_sessions forKey:kSessionsKey];
+- (NSUInteger)unclaimedSessions {
+  return _sessions.size();
 }
 
 #pragma mark -
-
-- (BOOL)isIndex:(NSUInteger)index
-    validForSessionCount:(NSUInteger)sessionCount {
-  return (sessionCount && index < sessionCount) ||
-         (!sessionCount && index == NSNotFound);
-}
+#pragma mark Debugging conveniences.
 
 - (NSString*)description {
+  NSMutableArray* sessionControllers =
+      [NSMutableArray arrayWithCapacity:_sessions.size()];
+  for (auto it = _sessions.begin(); it != _sessions.end(); ++it) {
+    CRWSessionController* sessionController =
+        (*it)->GetNavigationManagerImpl().GetSessionController();
+    [sessionControllers addObject:sessionController];
+  }
+
   return [NSString stringWithFormat:@"selected index: %" PRIuNS
                                      "\nsessions:\n%@\n",
-                                    _selectedIndex, _sessions.get()];
+                                    _selectedIndex, sessionControllers];
 }
 
 @end