Add unittests checking that old saved session can be restored.

ios/chrome/browser/sessions/session_service.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.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
@@ skipping 17 matching lines @@
 // |catch| so as to allow exception-expecting C++ code to build properly when
 // language support for exceptions is not present.  These macros interfere
 // with the use of |@try| and |@catch| in Objective-C files such as this one.
 // Undefine these macros here, after everything has been #included, since
 // there will be no C++ uses and only Objective-C uses from this point on.
 #undef try
 #undef catch
 
 const NSTimeInterval kSaveDelay = 2.5;  // Value taken from Desktop Chrome.
 
-@interface SessionWindowUnarchiver () {
-  ios::ChromeBrowserState* _browserState;
-}
+@interface SessionWindowUnarchiver ()
+
+// Register compatibility aliases to support loading serialised sessions
+// informations when the serialised classes are renamed.
++ (void)registerCompatibilityAliases;
 
 @end
 
 @implementation SessionWindowUnarchiver
 
-@synthesize browserState = _browserState;  // weak
+@synthesize browserState = _browserState;
 
-- (id)initForReadingWithData:(NSData*)data
-                browserState:(ios::ChromeBrowserState*)browserState {
+- (instancetype)initForReadingWithData:(NSData*)data
+                          browserState:(ios::ChromeBrowserState*)browserState {
   if (self = [super initForReadingWithData:data]) {
     _browserState = browserState;
   }
   return self;
 }
 
+- (instancetype)initForReadingWithData:(NSData*)data {
+  return [self initForReadingWithData:data browserState:nullptr];
+}
+
++ (void)initialize {
+  [super initialize];
+  [self registerCompatibilityAliases];
+}
+
+// When adding a new compatibility alias here, create a new crbug to track its
+// removal and mark it with a release at least one year after the introduction
+// of the alias.
++ (void)registerCompatibilityAliases {
+  // TODO(crbug.com/661633): those aliases where introduced between M57 and
+  // M58, so remove them after M67 has shipped to stable.
+  [SessionWindowUnarchiver setClass:[CRWSessionCertificatePolicyManager class]
+                       forClassName:@"SessionCertificatePolicyManager"];
+  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
+                       forClassName:@"SessionController"];
+  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
+                       forClassName:@"CRWSessionController"];
+  [SessionWindowUnarchiver setClass:[CRWNavigationItemStorage class]
+                       forClassName:@"SessionEntry"];
+  [SessionWindowUnarchiver setClass:[CRWNavigationItemStorage class]
+                       forClassName:@"CRWSessionEntry"];
+  [SessionWindowUnarchiver setClass:[SessionWindowIOS class]
+                       forClassName:@"SessionWindow"];
+
+  // TODO(crbug.com/661633): this alias was introduced between M58 and M59, so
+  // remove it after M68 has shipped to stable.
+  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
+                       forClassName:@"CRWNavigationManagerStorage"];
+}
+
 @end
 
 @interface SessionServiceIOS () {
- @private
   // The SequencedTaskRunner on which File IO operations are performed.
-  scoped_refptr<base::SequencedTaskRunner> taskRunner_;
+  scoped_refptr<base::SequencedTaskRunner> _taskRunner;
 
   // Maps save directories to the pending SessionWindow for the delayed
   // save behavior.
-  base::scoped_nsobject<NSMutableDictionary> pendingWindows_;
+  base::scoped_nsobject<NSMutableDictionary> _pendingWindows;
 }
 
 - (void)performSaveToDirectoryInBackground:(NSString*)directory;

[kkhorimoto, 2017/03/07 05:13:53]

Since we're cleaning up this class, can you add a comment to this declaration?

[sdefresne, 2017/03/07 17:58:17]

Done.

-- (void)performSaveWindow:(SessionWindowIOS*)window
-              toDirectory:(NSString*)directory;
 @end
 
 @implementation SessionServiceIOS
 
 + (SessionServiceIOS*)sharedService {
   static SessionServiceIOS* singleton = nil;
   if (!singleton) {
     singleton = [[[self class] alloc] init];
   }
   return singleton;
 }
 
-- (id)init {
+- (instancetype)init {
   self = [super init];
   if (self) {
-    pendingWindows_.reset([[NSMutableDictionary alloc] init]);
+    _pendingWindows.reset([[NSMutableDictionary alloc] init]);
     auto* pool = web::WebThread::GetBlockingPool();
-    taskRunner_ = pool->GetSequencedTaskRunner(pool->GetSequenceToken());
+    _taskRunner = pool->GetSequencedTaskRunner(pool->GetSequenceToken());
   }
   return self;
 }
 
 // Returns the path of the session file.
 - (NSString*)sessionFilePathForDirectory:(NSString*)directory {
   return [directory stringByAppendingPathComponent:@"session.plist"];
 }
 
 // Do the work of saving on a background thread. Assumes |window| is threadsafe.
 - (void)performSaveToDirectoryInBackground:(NSString*)directory {
   DCHECK(directory);
-  DCHECK([pendingWindows_ objectForKey:directory] != nil);
+  DCHECK([_pendingWindows objectForKey:directory] != nil);
   UIBackgroundTaskIdentifier identifier = [[UIApplication sharedApplication]
       beginBackgroundTaskWithExpirationHandler:^{
       }];
   DCHECK(identifier != UIBackgroundTaskInvalid);
 
   // Put the window into a local var so it can be retained for the block, yet
   // we can remove it from the dictionary to allow queuing another save.
   SessionWindowIOS* localWindow =
-      [[pendingWindows_ objectForKey:directory] retain];
-  [pendingWindows_ removeObjectForKey:directory];
+      [[_pendingWindows objectForKey:directory] retain];
+  [_pendingWindows removeObjectForKey:directory];
 
-  taskRunner_->PostTask(
+  _taskRunner->PostTask(
       FROM_HERE, base::BindBlock(^{
         @try {
           [self performSaveWindow:localWindow toDirectory:directory];
         } @catch (NSException* e) {
           // Do nothing.
         }
         [localWindow release];
         [[UIApplication sharedApplication] endBackgroundTask:identifier];
       }));
 }
@@ skipping 48 matching lines @@
 }
 
 - (void)saveWindow:(SessionWindowIOS*)window
     forBrowserState:(ios::ChromeBrowserState*)browserState
         immediately:(BOOL)immediately {
   NSString* stashPath =
       base::SysUTF8ToNSString(browserState->GetStatePath().value());
   // If there's an existing session window for |stashPath|, clear it before it's
   // replaced.
   SessionWindowIOS* pendingSession = base::mac::ObjCCast<SessionWindowIOS>(
-      [pendingWindows_ objectForKey:stashPath]);
+      [_pendingWindows objectForKey:stashPath]);
   [pendingSession clearSessions];
   // Set |window| as the pending save for |stashPath|.
-  [pendingWindows_ setObject:window forKey:stashPath];
+  [_pendingWindows setObject:window forKey:stashPath];
   if (immediately) {
     [NSObject cancelPreviousPerformRequestsWithTarget:self];
     [self performSaveToDirectoryInBackground:stashPath];
   } else if (!pendingSession) {
     // If there wasn't previously a delayed save pending for |stashPath|,
     // enqueue one now.
     [self performSelector:@selector(performSaveToDirectoryInBackground:)
                withObject:stashPath
                afterDelay:kSaveDelay];
   }
 }
 
 - (SessionWindowIOS*)loadWindowForBrowserState:
     (ios::ChromeBrowserState*)browserState {
   NSString* stashPath =
       base::SysUTF8ToNSString(browserState->GetStatePath().value());
   SessionWindowIOS* window =
       [self loadWindowFromPath:[self sessionFilePathForDirectory:stashPath]
                forBrowserState:browserState];
   return window;
 }
 
 - (SessionWindowIOS*)loadWindowFromPath:(NSString*)path
                         forBrowserState:(ios::ChromeBrowserState*)browserState {
-  // HACK: Handle the case where we had to change the class name of a persisted
-  // class on disk.
-  [SessionWindowUnarchiver setClass:[CRWSessionCertificatePolicyManager class]
-                       forClassName:@"SessionCertificatePolicyManager"];
-  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
-                       forClassName:@"SessionController"];
-  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
-                       forClassName:@"CRWSessionController"];
-  [SessionWindowUnarchiver setClass:[CRWSessionStorage class]
-                       forClassName:@"CRWNavigationManagerStorage"];
-  [SessionWindowUnarchiver setClass:[CRWNavigationItemStorage class]
-                       forClassName:@"SessionEntry"];
-  [SessionWindowUnarchiver setClass:[CRWNavigationItemStorage class]
-                       forClassName:@"CRWSessionEntry"];
-  // TODO(crbug.com/661633): Remove this hack.
-  [SessionWindowUnarchiver setClass:[SessionWindowIOS class]
-                       forClassName:@"SessionWindow"];
   SessionWindowIOS* window = nil;
   @try {
     NSData* data = [NSData dataWithContentsOfFile:path];
     if (data) {
       base::scoped_nsobject<SessionWindowUnarchiver> unarchiver([
           [SessionWindowUnarchiver alloc] initForReadingWithData:data
                                                     browserState:browserState]);
       window = [[[unarchiver decodeObjectForKey:@"root"] retain] autorelease];
     }
   } @catch (NSException* exception) {
-    DLOG(ERROR) << "Error loading session.plist";
+    DLOG(ERROR) << "Error loading session file.";
   }
   return window;
 }
 
 // Deletes the file containing the commands for the last session in the given
 // browserState directory.
 - (void)deleteLastSession:(NSString*)directory {
   NSString* sessionFile = [self sessionFilePathForDirectory:directory];
-  taskRunner_->PostTask(
+  _taskRunner->PostTask(
       FROM_HERE, base::BindBlock(^{
         base::ThreadRestrictions::AssertIOAllowed();
         NSFileManager* fileManager = [NSFileManager defaultManager];
         if (![fileManager fileExistsAtPath:sessionFile])
           return;
         if (![fileManager removeItemAtPath:sessionFile error:nil])
           CHECK(false) << "Unable to delete session file.";
       }));
 }
 
 @end