[ios] Allow having multiple session windows in a session.

ios/chrome/browser/sessions/session_service_ios.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_service_ios.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/critical_closure.h"
 #include "base/files/file_path.h"
+#include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
+#import "base/mac/foundation_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
+#import "ios/chrome/browser/sessions/session_ios.h"
 #import "ios/chrome/browser/sessions/session_window_ios.h"
 #import "ios/web/public/crw_navigation_item_storage.h"
 #import "ios/web/public/crw_session_certificate_policy_cache_storage.h"
 #import "ios/web/public/crw_session_storage.h"
 #include "ios/web/public/web_thread.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
@@ skipping 36 matching lines @@
   [self setClass:[CRWSessionCertificatePolicyCacheStorage class]
       forClassName:@"CRWSessionCertificatePolicyManager"];
 }
 
 @end
 
 @implementation SessionServiceIOS {
   // The SequencedTaskRunner on which File IO operations are performed.
   scoped_refptr<base::SequencedTaskRunner> _taskRunner;
 
-  // Maps session path to the pending session window for the delayed save
-  // behaviour.
-  NSMutableDictionary<NSString*, SessionWindowIOS*>* _pendingSessionWindows;
+  // Maps session path to the pending session for the delayed save behaviour.
+  NSMutableDictionary<NSString*, SessionIOS*>* _pendingSessions;
 }
 
 #pragma mark - NSObject overrides
 
 - (instancetype)init {
   base::SequencedWorkerPool* pool = web::WebThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> taskRunner =
       pool->GetSequencedTaskRunner(pool->GetSequenceToken());
   return [self initWithTaskRunner:taskRunner];
 }
 
 #pragma mark - Public interface
 
 + (SessionServiceIOS*)sharedService {
   static SessionServiceIOS* singleton = nil;
   if (!singleton) {
     singleton = [[[self class] alloc] init];
   }
   return singleton;
 }
 
 - (instancetype)initWithTaskRunner:
     (const scoped_refptr<base::SequencedTaskRunner>&)taskRunner {
   DCHECK(taskRunner);
   self = [super init];
   if (self) {
-    _pendingSessionWindows = [NSMutableDictionary dictionary];
+    _pendingSessions = [NSMutableDictionary dictionary];
     _taskRunner = taskRunner;
   }
   return self;
 }
 
-- (void)saveSessionWindow:(SessionWindowIOS*)sessionWindow
-                directory:(NSString*)directory
-              immediately:(BOOL)immediately {
+- (void)saveSession:(SessionIOS*)session
+          directory:(NSString*)directory
+        immediately:(BOOL)immediately {
   NSString* sessionPath = [[self class] sessionPathForDirectory:directory];
-  BOOL hadPendingSession =
-      [_pendingSessionWindows objectForKey:sessionPath] != nil;
-  [_pendingSessionWindows setObject:sessionWindow forKey:sessionPath];
+  BOOL hadPendingSession = [_pendingSessions objectForKey:sessionPath] != nil;
+  [_pendingSessions setObject:session forKey:sessionPath];
   if (immediately) {
     [NSObject cancelPreviousPerformRequestsWithTarget:self];
     [self performSaveToPathInBackground:sessionPath];
   } else if (!hadPendingSession) {
     // If there wasn't previously a delayed save pending for |sessionPath|,
     // enqueue one now.
     [self performSelector:@selector(performSaveToPathInBackground:)
                withObject:sessionPath
                afterDelay:kSaveDelay];
   }
 }
 
-- (SessionWindowIOS*)loadSessionWindowFromDirectory:(NSString*)directory {
+- (SessionIOS*)loadSessionFromDirectory:(NSString*)directory {
   NSString* sessionPath = [[self class] sessionPathForDirectory:directory];
-  return [self loadSessionWindowFromPath:sessionPath];
+  return [self loadSessionFromPath:sessionPath];
 }
 
-- (SessionWindowIOS*)loadSessionWindowFromPath:(NSString*)sessionPath {
+- (SessionIOS*)loadSessionFromPath:(NSString*)sessionPath {
+  NSObject<NSCoding>* rootObject = nil;
   @try {
     NSData* data = [NSData dataWithContentsOfFile:sessionPath];
     if (!data)
       return nil;
 
     NSKeyedUnarchiver* unarchiver =
         [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
 
     // Register compatibility aliases to support legacy saved sessions.
     [unarchiver cr_registerCompatibilityAliases];
-    return [unarchiver decodeObjectForKey:kRootObjectKey];
+    rootObject = [unarchiver decodeObjectForKey:kRootObjectKey];
   } @catch (NSException* exception) {
     NOTREACHED() << "Error loading session file: "
                  << base::SysNSStringToUTF8(sessionPath) << ": "
                  << base::SysNSStringToUTF8([exception reason]);
+  }
+
+  if (!rootObject)
     return nil;
+
+  // Support for legacy saved session that contained a single SessionWindowIOS
+  // object as the root object (pre-M-59).
+  if ([rootObject isKindOfClass:[SessionWindowIOS class]]) {
+    return [[SessionIOS alloc] initWithWindows:@[
+      base::mac::ObjCCastStrict<SessionWindowIOS>(rootObject)
+    ]];
   }
+
+  return base::mac::ObjCCastStrict<SessionIOS>(rootObject);
 }
 
 - (void)deleteLastSessionFileInDirectory:(NSString*)directory {
   NSString* sessionPath = [[self class] sessionPathForDirectory:directory];
   _taskRunner->PostTask(
       FROM_HERE, base::BindBlockArc(^{
         base::ThreadRestrictions::AssertIOAllowed();
         NSFileManager* fileManager = [NSFileManager defaultManager];
         if (![fileManager fileExistsAtPath:sessionPath])
           return;
 
         NSError* error = nil;
         if (![fileManager removeItemAtPath:sessionPath error:nil])
           CHECK(false) << "Unable to delete session file: "
                        << base::SysNSStringToUTF8(sessionPath) << ": "
                        << base::SysNSStringToUTF8([error description]);
       }));
 }
 
 + (NSString*)sessionPathForDirectory:(NSString*)directory {
   return [directory stringByAppendingPathComponent:@"session.plist"];
 }
 
 #pragma mark - Private methods
 
 // Do the work of saving on a background thread.
 - (void)performSaveToPathInBackground:(NSString*)sessionPath {
   DCHECK(sessionPath);
-  DCHECK([_pendingSessionWindows objectForKey:sessionPath] != nil);
+  DCHECK([_pendingSessions objectForKey:sessionPath] != nil);
 
   // Serialize to NSData on the main thread to avoid accessing potentially
   // non-threadsafe objects on a background thread.
-  SessionWindowIOS* sessionWindow =
-      [_pendingSessionWindows objectForKey:sessionPath];
-  [_pendingSessionWindows removeObjectForKey:sessionPath];
+  SessionIOS* session = [_pendingSessions objectForKey:sessionPath];
+  [_pendingSessions removeObjectForKey:sessionPath];
 
   @try {
-    NSData* sessionData =
-        [NSKeyedArchiver archivedDataWithRootObject:sessionWindow];
+    NSData* sessionData = [NSKeyedArchiver archivedDataWithRootObject:session];
     _taskRunner->PostTask(
         FROM_HERE, base::MakeCriticalClosure(base::BindBlockArc(^{
           [self performSaveSessionData:sessionData sessionPath:sessionPath];
         })));
   } @catch (NSException* exception) {
     NOTREACHED() << "Error serializing session for path: "
                  << base::SysNSStringToUTF8(sessionPath) << ": "
                  << base::SysNSStringToUTF8([exception description]);
     return;
   }
@@ skipping 37 matching lines @@
 
   if (![sessionData writeToFile:sessionPath options:options error:&error]) {
     NOTREACHED() << "Error writing session file: "
                  << base::SysNSStringToUTF8(sessionPath) << ": "
                  << base::SysNSStringToUTF8([error description]);
     return;
   }
 }
 
 @end