Fix tabs duplication when restoring last closed window.

chrome/browser/sessions/session_service.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_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 114 matching lines @@
       // from the dock or the menubar.
       && !app_controller_mac::IsOpeningNewWindow()
 #endif  // OS_MACOSX
       ) {
     return true;
   }
   return false;
 }
 
 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open) {
-  return RestoreIfNecessary(urls_to_open, NULL);
+  return RestoreIfNecessary(urls_to_open, NULL, false);
 }
 
 void SessionService::ResetFromCurrentBrowsers() {
   ScheduleResetCommands();
 }
 
 void SessionService::MoveCurrentSessionToLastSession() {
   pending_tab_close_ids_.clear();
   window_closing_ids_.clear();
   pending_window_close_ids_.clear();
@@ skipping 81 matching lines @@
     // In all cases we need to mark the tab as explicitly closed.
     ScheduleCommand(sessions::CreateTabClosedCommand(tab_id.id()));
   } else {
     // User closed the last tab in the last tabbed browser. Don't mark the
     // tab closed.
     pending_tab_close_ids_.insert(tab_id.id());
     has_open_trackable_browsers_ = false;
   }
 }
 
-void SessionService::WindowOpened(Browser* browser) {
+void SessionService::WindowOpened(Browser* browser, bool dont_restore) {
   if (!ShouldTrackBrowser(browser))
     return;
 
-  RestoreIfNecessary(std::vector<GURL>(), browser);
+  RestoreIfNecessary(std::vector<GURL>(), browser, dont_restore);
   SetWindowType(browser->session_id(),
                 browser->type(),
                 browser->is_app() ? TYPE_APP : TYPE_NORMAL);
   SetWindowAppName(browser->session_id(), browser->app_name());
 }
 
 void SessionService::WindowClosing(const SessionID& window_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
@@ skipping 318 matching lines @@
                                                               TYPE_APP)) {
       delete window;
       i = window_list->erase(i);
     } else {
       ++i;
     }
   }
 }
 
 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open,
-                                        Browser* browser) {
+                                        Browser* browser, bool dont_restore) {
   if (ShouldNewWindowStartSession()) {
     // We're going from no tabbed browsers to a tabbed browser (and not in
     // process startup), restore the last session.
     if (move_on_new_browser_) {
       // Make the current session the last.
       MoveCurrentSessionToLastSession();
       move_on_new_browser_ = false;
     }
     SessionStartupPref pref = StartupBrowserCreator::GetSessionStartupPref(
         *base::CommandLine::ForCurrentProcess(), profile());
-    if (pref.type == SessionStartupPref::LAST) {
+    if (pref.type == SessionStartupPref::LAST && !dont_restore) {
       SessionRestore::RestoreSession(
           profile(), browser,
           browser ? 0 : SessionRestore::ALWAYS_CREATE_TABBED_BROWSER,
           urls_to_open);
       return true;
     }
   }
   return false;
 }
 
@@ skipping 494 matching lines @@
   for (auto* browser : *BrowserList::GetInstance()) {
     if (browser->profile() == profile())
       return;
   }
   DeleteSessionOnlyData(profile());
 }
 
 sessions::BaseSessionService* SessionService::GetBaseSessionServiceForTest() {
   return base_session_service_.get();
 }