Fixes bug where triggering session restore while the browser was...

chrome/test/ui_test_utils.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/test/ui_test_utils.h"
 
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
@@ skipping 196 matching lines @@
   // The number of downloads to wait on completing.
   size_t wait_count_;
 
   // Whether an internal message loop has been started and must be quit upon
   // all downloads completing.
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadsCompleteObserver);
 };
 
-// Used to block until an application modal dialog is shown.
-class AppModalDialogObserver : public NotificationObserver {
- public:
-  AppModalDialogObserver() : dialog_(NULL) {}
-
-  AppModalDialog* WaitForAppModalDialog() {
-    registrar_.Add(this, NotificationType::APP_MODAL_DIALOG_SHOWN,
-                   NotificationService::AllSources());
-    dialog_ = NULL;
-    ui_test_utils::RunMessageLoop();
-    DCHECK(dialog_);
-    return dialog_;
-  }
-
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) {
-    if (type == NotificationType::APP_MODAL_DIALOG_SHOWN) {
-      registrar_.Remove(this, NotificationType::APP_MODAL_DIALOG_SHOWN,
-                        NotificationService::AllSources());
-      dialog_ = Source<AppModalDialog>(source).ptr();
-      MessageLoopForUI::current()->Quit();
-    } else {
-      NOTREACHED();
-    }
-  }
-
- private:
-  NotificationRegistrar registrar_;
-
-  AppModalDialog* dialog_;
-
-  DISALLOW_COPY_AND_ASSIGN(AppModalDialogObserver);
-};
-
 template <class T>
 class SimpleNotificationObserver : public NotificationObserver {
  public:
   SimpleNotificationObserver(NotificationType notification_type,
                              T* source) {
     registrar_.Add(this, notification_type, Source<T>(source));
     ui_test_utils::RunMessageLoop();
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     MessageLoopForUI::current()->Quit();
   }
 
  private:
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleNotificationObserver);
 };
 
+// SimpleNotificationObserver that waits for a single notification. When the
+// notification is observer the source (of type S) is recorded and the message
+// loop stopped. Use |source()| to access the source after the constructor
+// returns.
+template <class S>
+class SimpleNotificationObserverWithSource : public NotificationObserver {
+ public:
+  SimpleNotificationObserverWithSource(NotificationType notification_type,
+                                       const NotificationSource& source)
+      : source_(NULL) {
+    registrar_.Add(this, notification_type, source);
+    ui_test_utils::RunMessageLoop();
+  }
+
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) {
+    source_ = Source<S>(source).ptr();
+
+    // Remove observer now, so that if there any other notifications we don't
+    // clobber source_.
+    registrar_.RemoveAll();
+
+    MessageLoopForUI::current()->Quit();
+  }
+
+  S* source() const { return source_; }
+
+ private:
+  S* source_;
+  NotificationRegistrar registrar_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimpleNotificationObserverWithSource);
+};
+
 class LanguageDetectionNotificationObserver : public NotificationObserver {
  public:
   explicit LanguageDetectionNotificationObserver(TabContents* tab) {
     registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                   Source<TabContents>(tab));
     ui_test_utils::RunMessageLoop();
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
@@ skipping 157 matching lines @@
   SimpleNotificationObserver<ExtensionAction>
       observer(NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
                browser_action);
 }
 
 void WaitForLoadStop(NavigationController* controller) {
   SimpleNotificationObserver<NavigationController>
       new_tab_observer(NotificationType::LOAD_STOP, controller);
 }
 
+Browser* WaitForNewBrowser() {
+  SimpleNotificationObserverWithSource<Browser> observer(
+      NotificationType::BROWSER_WINDOW_READY,
+      NotificationService::AllSources());
+  return observer.source();
+}
+
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser::OpenURLOffTheRecord(profile, url);
   Browser* browser = BrowserList::FindBrowserWithType(
       profile->GetOffTheRecordProfile(), Browser::TYPE_NORMAL);
   WaitForNavigations(&browser->GetSelectedTabContents()->controller(), 1);
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
   NavigateToURLBlockUntilNavigationsComplete(browser, url, 1);
 }
@@ skipping 89 matching lines @@
   path = path.Append(FilePath::FromWStringHack(dir));
   path = path.Append(FilePath::FromWStringHack(file));
   return net::FilePathToFileURL(path);
 }
 
 void WaitForDownloadCount(DownloadManager* download_manager, size_t count) {
   DownloadsCompleteObserver download_observer(download_manager, count);
 }
 
 AppModalDialog* WaitForAppModalDialog() {
-  AppModalDialogObserver observer;
-  return observer.WaitForAppModalDialog();
+  SimpleNotificationObserverWithSource<AppModalDialog> observer(
+      NotificationType::APP_MODAL_DIALOG_SHOWN,
+      NotificationService::AllSources());
+  return observer.source();
 }
 
 void CrashTab(TabContents* tab) {
   RenderProcessHost* rph = tab->render_view_host()->process();
   base::KillProcess(rph->GetHandle(), 0, false);
   SimpleNotificationObserver<RenderProcessHost>
       crash_observer(NotificationType::RENDERER_PROCESS_CLOSED, rph);
 }
 
 void WaitForFocusChange(RenderViewHost* rvh) {
@@ skipping 149 matching lines @@
 
 TestWebSocketServer::~TestWebSocketServer() {
   scoped_ptr<CommandLine> cmd_line(CreateWebSocketServerCommandLine());
   cmd_line->AppendSwitchWithValue("server", "stop");
   cmd_line->AppendSwitchWithValue("pidfile",
                                   websocket_pid_file_.ToWStringHack());
   base::LaunchApp(*cmd_line.get(), true, false, NULL);
 }
 
 }  // namespace ui_test_utils