[Session restore] Add MRU logic to loading of background pages.

chrome/browser/sessions/session_restore.cc

 // 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.
 
 #include "chrome/browser/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
@@ skipping 279 matching lines @@
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Open the new tab page.
         urls_to_open_.push_back(GURL(chrome::kChromeUINewTabURL));
       }
       AppendURLsToBrowser(browser, urls_to_open_);
       browser->window()->Show();
     }
 
     if (succeeded) {
+      if (SessionRestore::GetSmartRestoreMode() !=
+          SessionRestore::SMART_RESTORE_MODE_OFF) {
+        if (SessionRestore::GetSmartRestoreMode() ==
+            SessionRestore::SMART_RESTORE_MODE_MRU) {
+          // Sanitize the last active time by keeping the same time lapse
+          // between tabs. The latest tab will have its time set to Now() while
+          // the rest of the tabs will have theirs set earlier.
+          base::TimeTicks now = base::TimeTicks::Now();
+          base::TimeTicks highest_time = base::TimeTicks::UnixEpoch();
+          for (const auto& tab : *contents_created) {
+            if (tab.contents()->GetLastActiveTime() > highest_time)
+              highest_time = tab.contents()->GetLastActiveTime();
+          }
+          for (const auto& tab : *contents_created) {
+            base::TimeDelta delta =
+                highest_time - tab.contents()->GetLastActiveTime();
+            tab.contents()->SetLastActiveTime(now - delta);
+          }
+        }
+        std::stable_sort(contents_created->begin(), contents_created->end());
+      }
       // Start Loading tabs.
-      if (SessionRestore::GetSmartRestoreMode() !=
-          SessionRestore::SMART_RESTORE_MODE_OFF)
-        std::stable_sort(contents_created->begin(), contents_created->end());
       SessionRestoreDelegate::RestoreTabs(*contents_created, restore_started_);
     }
 
     if (!synchronous_) {
       // If we're not synchronous we need to delete ourself.
       // NOTE: we must use DeleteLater here as most likely we're in a callback
       // from the history service which doesn't deal well with deleting the
       // object it is notifying.
       base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 
@@ skipping 270 matching lines @@
     WebContents* web_contents = chrome::AddRestoredTab(
         browser, tab.navigations, tab_index, selected_index,
         tab.extension_app_id,
         false,  // select
         tab.pinned, true, session_storage_namespace.get(),
         tab.user_agent_override);
     // Regression check: check that the tab didn't start loading right away. The
     // focused tab will be loaded by Browser, and TabLoader will load the rest.
     DCHECK(web_contents->GetController().NeedsReload());
 
+    // Restore the saved last active time since by default, the last active time
+    // of a WebContent is initially set to the creation time of the tab, which
+    // is not necessarly the same as the loading time. This makes sure that the
+    // state is preserved between restores. Also, since TimeTicks only make
+    // sense in their current session, these values are sanitized later on
+    // (before we start loading background tabs).
+    if (SessionRestore::GetSmartRestoreMode() ==
+        SessionRestore::SMART_RESTORE_MODE_MRU) {
+      web_contents->SetLastActiveTime(tab.last_active_time);

[sky, 2015/05/22 03:00:19]

I don't like pushing potentially bogus times to the webcontents. I would rather
you do the sanitizing first.

[Georges Khalil, 2015/05/22 20:14:09]

That was done because otherwise, by the time we sanitized the values, the wrong
ones had already been saved.

I worked around this by sanitizing the values earlier.

+    }
+
     return web_contents;
   }
 
   Browser* CreateRestoredBrowser(Browser::Type type,
                                  gfx::Rect bounds,
                                  ui::WindowShowState show_state,
                                  const std::string& app_name) {
     Browser::CreateParams params(type, profile_, host_desktop_type_);
     if (!app_name.empty()) {
       const bool trusted_source = true;  // We only store trusted app windows.
@@ skipping 221 matching lines @@
   if (prioritize_tabs == "mru")
     return SMART_RESTORE_MODE_MRU;
   if (prioritize_tabs == "simple")
     return SMART_RESTORE_MODE_SIMPLE;
   return SMART_RESTORE_MODE_OFF;
 }
 
 // static
 base::CallbackList<void(int)>*
     SessionRestore::on_session_restored_callbacks_ = nullptr;