Revert 66646 - Add "open as window" menu item to NTP app menu....

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2010 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/callback.h"
 #include "base/command_line.h"
@@ skipping 254 matching lines @@
                      Browser* browser,
                      bool synchronous,
                      bool clobber_existing_window,
                      bool always_create_tabbed_browser,
                      const std::vector<GURL>& urls_to_open)
       : profile_(profile),
         browser_(browser),
         synchronous_(synchronous),
         clobber_existing_window_(clobber_existing_window),
         always_create_tabbed_browser_(always_create_tabbed_browser),
-        urls_to_open_(urls_to_open) {
+        urls_to_open_(urls_to_open),
+        waiting_for_extension_service_(false) {
   }
 
   void Restore() {
     SessionService* session_service = profile_->GetSessionService();
     DCHECK(session_service);
     SessionService::SessionCallback* callback =
         NewCallback(this, &SessionRestoreImpl::OnGotSession);
     session_service->GetLastSession(&request_consumer_, callback);
 
     if (synchronous_) {
@@ skipping 45 matching lines @@
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     switch (type.value) {
       case NotificationType::BROWSER_CLOSED:
         delete this;
         return;
 
+      case NotificationType::EXTENSIONS_READY: {
+        if (!waiting_for_extension_service_)
+          return;
+
+        waiting_for_extension_service_ = false;
+        if (synchronous_) {
+          MessageLoop::current()->Quit();
+          return;
+        }
+        ProcessSessionWindows(&windows_);
+        return;
+      }
+
       default:
         NOTREACHED();
         break;
     }
   }
 
  private:
   // Invoked when done with creating all the tabs/browsers.
   //
   // |created_tabbed_browser| indicates whether a tabbed browser was created,
@@ skipping 24 matching lines @@
       // 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 (HasExtensionApps(*windows) && profile_->GetExtensionsService() &&
+        !profile_->GetExtensionsService()->is_ready()) {
+      // At least one tab is an app tab and the extension service hasn't
+      // finished loading. Wait to continue processing until the extensions
+      // service finishes loading.
+      registrar_.Add(this, NotificationType::EXTENSIONS_READY,
+                     Source<Profile>(profile_));
+      windows_.swap(*windows);
+      waiting_for_extension_service_ = true;
+      return;
+    }
+
     if (synchronous_) {
       // See comment above windows_ as to why we don't process immediately.
       windows_.swap(*windows);
       MessageLoop::current()->Quit();
       return;
     }
 
     ProcessSessionWindows(windows);
   }
 
+  // Returns true if any tab in |windows| has an application extension id.
+  bool HasExtensionApps(const std::vector<SessionWindow*>& windows) {
+    for (std::vector<SessionWindow*>::const_iterator i = windows.begin();
+         i != windows.end(); ++i) {
+      if (HasExtensionApps((*i)->tabs))
+        return true;
+    }
+
+    return false;
+  }
+
+  // Returns true if any tab in |tabs| has an application extension id.
+  bool HasExtensionApps(const std::vector<SessionTab*>& tabs) {
+    for (std::vector<SessionTab*>::const_iterator i = tabs.begin();
+         i != tabs.end(); ++i) {
+      if (!(*i)->extension_app_id.empty())
+        return true;
+    }
+
+    return false;
+  }
+
   void ProcessSessionWindows(std::vector<SessionWindow*>* windows) {
     if (windows->empty()) {
       // Restore was unsuccessful.
       FinishedTabCreation(false, false);
       return;
     }
 
     tab_loader_.reset(new TabLoader());
 
     Browser* current_browser =
@@ skipping 141 matching lines @@
 
   // 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_;
 
+  // If true, indicates at least one tab has an application extension id and
+  // we're waiting for the extension service to finish loading.
+  bool waiting_for_extension_service_;
+
   NotificationRegistrar registrar_;
 };
 
 }  // namespace
 
 // SessionRestore -------------------------------------------------------------
 
 static void Restore(Profile* profile,
                     Browser* browser,
                     bool synchronous,
@@ skipping 46 matching lines @@
 void SessionRestore::RestoreSessionSynchronously(
     Profile* profile,
     const std::vector<GURL>& urls_to_open) {
   Restore(profile, NULL, true, false, true, urls_to_open);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }