Changes synchronous session restore to create windows after nested...

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2006-2008 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 <vector>
 
 #include "base/command_line.h"
 #include "base/scoped_ptr.h"
+#include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 163 matching lines @@
 
   void Restore() {
     SessionService* session_service = profile_->GetSessionService();
     DCHECK(session_service);
     SessionService::LastSessionCallback* callback =
         NewCallback(this, &SessionRestoreImpl::OnGotSession);
     session_service->GetLastSession(&request_consumer_, callback);
 
     if (synchronous_) {
       MessageLoop::current()->Run();
+      ProcessSessionWindows(&windows_);
       delete this;
       return;
     }
 
     if (browser_) {
       registrar_.Add(this, NotificationType::BROWSER_CLOSED,
                      Source<Browser>(browser_));
     }
   }
 
   ~SessionRestoreImpl() {
+    STLDeleteElements(&windows_);
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     if (type != NotificationType::BROWSER_CLOSED) {
       NOTREACHED();
       return;
     }
     delete this;
@@ skipping 16 matching lines @@
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Add an empty URL, which is treated as opening the users home
         // page.
         urls_to_open_.push_back(GURL());
       }
       AppendURLsToBrowser(browser, urls_to_open_, honor_pin_tabs);
       browser->window()->Show();
     }
 
-    if (synchronous_)
-      MessageLoop::current()->Quit();
-
     if (succeeded) {
       DCHECK(tab_loader_.get());
       // TabLoader delets itself when done loading.
       tab_loader_.release()->LoadTabs();
     }
 
     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.
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     }
   }
 
   void OnGotSession(SessionService::Handle handle,
                     std::vector<SessionWindow*>* windows) {
+    if (synchronous_) {
+      // See comment above windows_ as to why we don't process immediately.
+      windows_.swap(*windows);
+      MessageLoop::current()->Quit();
+      return;
+    }
+    ProcessSessionWindows(windows);
+  }
+
+  void ProcessSessionWindows(std::vector<SessionWindow*>* windows) {
     if (windows->empty()) {
       // Restore was unsuccessful.
       FinishedTabCreation(false, false);
       return;
     }
 
     tab_loader_.reset(new TabLoader());
 
     Browser* current_browser =
         browser_ ? browser_ : BrowserList::GetLastActive();
@@ skipping 139 matching lines @@
 
   // Set of URLs to open in addition to those restored from the session.
   std::vector<GURL> urls_to_open_;
 
   // Used to get the session.
   CancelableRequestConsumer request_consumer_;
 
   // Responsible for loading the tabs.
   scoped_ptr<TabLoader> tab_loader_;
 
+  // When synchronous we run a nested message loop. To avoid creating windows
+  // from the nested message loop (which can make exiting the nested message
+  // loop take a while) we cache the SessionWindows here and create the actual
+  // windows when the nested message loop exits.
+  std::vector<SessionWindow*> windows_;
+
   NotificationRegistrar registrar_;
 };
 
 }  // namespace
 
 // SessionRestore -------------------------------------------------------------
 
 // static
 size_t SessionRestore::num_tabs_to_load_ = 0;
 
@@ skipping 29 matching lines @@
   Restore(profile, browser, false, clobber_existing_window,
           always_create_tabbed_browser, urls_to_open);
 }
 
 // static
 void SessionRestore::RestoreSessionSynchronously(
     Profile* profile,
     const std::vector<GURL>& urls_to_open) {
   Restore(profile, NULL, true, false, true, urls_to_open);
 }