[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 503 matching lines @@
         // Loads are scheduled for each restored tab unless the tab is going to
         // be selected as ShowBrowser() will load the selected tab.
         bool is_selected_tab = (i == selected_tab_index);
         WebContents* contents = RestoreTab(tab, i, browser, is_selected_tab);
 
         // RestoreTab can return nullptr if |tab| doesn't have valid data.
         if (!contents)
           continue;
 
         RestoredTab restored_tab(contents, is_selected_tab,
-                                 tab.extension_app_id.empty(), tab.pinned);
+                                 tab.extension_app_id.empty(), tab.pinned,
+                                 tab.last_activation_time);
         created_contents->push_back(restored_tab);
 
         // If this isn't the selected tab, there's nothing else to do.
         if (!is_selected_tab)
           continue;
 
         ShowBrowser(browser, browser->tab_strip_model()->GetIndexOfWebContents(
                                  contents));
         // TODO(sky): remove. For debugging 368236.
         CHECK_EQ(browser->tab_strip_model()->GetActiveWebContents(), contents);
       }
     } else {
       // If the browser already has tabs, we want to restore the new ones after
       // the existing ones. E.g. this happens in Win8 Metro where we merge
       // windows or when launching a hosted app from the app launcher.
       int tab_index_offset = initial_tab_count;
       for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
         const sessions::SessionTab& tab = *(window.tabs[i]);
         // Always schedule loads as we will not be calling ShowBrowser().
         WebContents* contents =
             RestoreTab(tab, tab_index_offset + i, browser, false);
         if (contents) {
           RestoredTab restored_tab(contents, false,
-                                   tab.extension_app_id.empty(), tab.pinned);
+                                   tab.extension_app_id.empty(), tab.pinned,
+                                   tab.last_activation_time);
           created_contents->push_back(restored_tab);
         }
       }
     }
   }
 
   // |tab_index| is ignored for pinned tabs which will always be pushed behind
   // the last existing pinned tab.
   // |tab_loader_| will schedule this tab for loading if |is_selected_tab| is
   // false.
@@ skipping 25 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 activation time. By default, the activation 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.
+    web_contents->SetLastActiveTime(tab.last_activation_time);

[sky, 2015/05/12 21:25:29]

It's my understanding there is no guarantee that timeticks increases across a
reboot. I suspect if you have your machine running for a long time, reboot, then
tab.last_activation_time could be very far in the future.

[Georges Khalil, 2015/05/15 16:55:30]

You are right, if the OS reboots, TimeTicks become irrelevant. Landed another CL
that changes WebContents::last_active_time to Time instead of TimeTicks. This
should fix it as we're using Time now. I also changed last_activation_time to
last_active_time for consistency with WebContents.

[sky, 2015/05/18 15:53:28]

I think time ticks is safer as blocks can go back. You just need to sanitize the
time ticks value when restoring.

[Georges Khalil, 2015/05/19 19:32:15]

I'm not sure how we could sanitize time ticks, as they're relative to the OS
session. The fact that the clock can change (daylight, for example), is not that
big of a deal, as we will still be able to order them correctly. And worst case,
the order won't be perfect, which is no worse than the original way of doing
things.

If you have a good way of sanitizing time ticks, that would be great (I'd have
to revert my TimeTicks==>Time patch, but not a big deal :) )

[sky, 2015/05/19 19:55:16]

After you've read the data in all we care about is relative order. You could
achieve this by sorting the original time ticks you read in, and assigning new
values based on sort position and current time ticks.

[gab, 2015/05/20 17:08:57]

I'm not convinced that this is true. For example, we could decide to stop
loading any tab whose latest timestamp is X days/hours behind the latest
shutdown.

I also agree with Georges that small order flips in tabs that have almost the
same timestamp but for which the clock has somehow jumped slightly backward and
introduced an ordering flip are mostly irrelevant.

+
     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;