Rename is_not_selected_tab to is_selected_tab in SessionRestore::RestoreTab

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 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 955 matching lines @@
                            int initial_tab_count,
                            int selected_tab_index) {
     VLOG(1) << "RestoreTabsToBrowser " << window.tabs.size();
     DCHECK(!window.tabs.empty());
     if (initial_tab_count == 0) {
       for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
         const SessionTab& tab = *(window.tabs[i]);
 
         // Loads are scheduled for each restored tab unless the tab is going to
         // be selected as ShowBrowser() will load the selected tab.
-        bool is_not_selected_tab = (i != selected_tab_index);
+        bool is_selected_tab = (i == selected_tab_index);
         WebContents* restored_tab =
-            RestoreTab(tab, i, browser, is_not_selected_tab);
+            RestoreTab(tab, i, browser, is_selected_tab);
 
         // RestoreTab can return NULL if |tab| doesn't have valid data.
         if (!restored_tab)
           continue;
 
         // If this isn't the selected tab, there's nothing else to do.
-        if (is_not_selected_tab)
+        if (!is_selected_tab)
           continue;
 
         ShowBrowser(
             browser,
             browser->tab_strip_model()->GetIndexOfWebContents(restored_tab));
         // TODO(sky): remove. For debugging 368236.
         CHECK_EQ(browser->tab_strip_model()->GetActiveWebContents(),
                  restored_tab);
         tab_loader_->TabIsLoading(&browser->tab_strip_model()
                                        ->GetActiveWebContents()
                                        ->GetController());
       }
     } 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 SessionTab& tab = *(window.tabs[i]);
         // Always schedule loads as we will not be calling ShowBrowser().
-        RestoreTab(tab, tab_index_offset + i, browser, true);
+        RestoreTab(tab, tab_index_offset + i, browser, false);
       }
     }
   }
 
   // |tab_index| is ignored for pinned tabs which will always be pushed behind
   // the last existing pinned tab.
-  // |schedule_load| will let |tab_loader_| know that it should schedule this
-  // tab for loading.
+  // |tab_loader_| will schedule this tab for loading if |is_selected_tab| is
+  // false.
   WebContents* RestoreTab(const SessionTab& tab,
                           const int tab_index,
                           Browser* browser,
-                          bool schedule_load) {
+                          bool is_selected_tab) {
     // It's possible (particularly for foreign sessions) to receive a tab
     // without valid navigations. In that case, just skip it.
     // See crbug.com/154129.
     if (tab.navigations.empty())
       return NULL;
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index,
                  static_cast<int>(tab.navigations.size() - 1)));
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     // Associate sessionStorage (if any) to the restored tab.
     scoped_refptr<content::SessionStorageNamespace> session_storage_namespace;
     if (!tab.session_storage_persistent_id.empty()) {
       session_storage_namespace =
           content::BrowserContext::GetDefaultStoragePartition(profile_)->
               GetDOMStorageContext()->RecreateSessionStorage(
                   tab.session_storage_persistent_id);
     }
 
     WebContents* web_contents =
         chrome::AddRestoredTab(browser,
                                tab.navigations,
                                tab_index,
                                selected_index,
                                tab.extension_app_id,
-                               !schedule_load,  // select
+                               is_selected_tab,  // 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(!schedule_load || web_contents->GetController().NeedsReload());
+    DCHECK(is_selected_tab || web_contents->GetController().NeedsReload());
 
     // Set up the file access rights for the selected navigation entry.
     const int id = web_contents->GetRenderProcessHost()->GetID();
     const content::PageState& page_state =
         tab.navigations.at(selected_index).page_state();
     const std::vector<base::FilePath>& file_paths =
         page_state.GetReferencedFiles();
     for (std::vector<base::FilePath>::const_iterator file = file_paths.begin();
          file != file_paths.end(); ++file) {
       content::ChildProcessSecurityPolicy::GetInstance()->GrantReadFile(id,
                                                                         *file);
     }
 
-    if (schedule_load)
+    if (!is_selected_tab)
       tab_loader_->ScheduleLoad(&web_contents->GetController());
     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()) {
@@ skipping 213 matching lines @@
   if (!active_session_restorers)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->synchronous())
       return true;
   }
   return false;
 }