Convert WindowOpenDisposition to an enum class.

chrome/test/base/ui_test_utils.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/test/base/ui_test_utils.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 148 matching lines @@
 
   std::string post_data("test=body");
   params.post_data = content::ResourceRequestBody::CreateFromBytes(
       post_data.data(), post_data.size());
   params.uses_post = true;
 
   NavigateToURL(&params);
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
-  NavigateToURLWithDisposition(browser, url, CURRENT_TAB,
+  NavigateToURLWithDisposition(browser, url, WindowOpenDisposition::CURRENT_TAB,
                                BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
     Browser* browser,
     const GURL& url,
     int number_of_navigations,
     WindowOpenDisposition disposition,
     int browser_test_flags) {
   TabStripModel* tab_strip = browser->tab_strip_model();
-  if (disposition == CURRENT_TAB && tab_strip->GetActiveWebContents())
-      content::WaitForLoadStop(tab_strip->GetActiveWebContents());
+  if (disposition == WindowOpenDisposition::CURRENT_TAB &&
+      tab_strip->GetActiveWebContents())
+    content::WaitForLoadStop(tab_strip->GetActiveWebContents());
   content::TestNavigationObserver same_tab_observer(
       tab_strip->GetActiveWebContents(),
       number_of_navigations);
 
   std::set<Browser*> initial_browsers;
   for (auto* browser : *BrowserList::GetInstance())
     initial_browsers.insert(browser);
 
   content::WindowedNotificationObserver tab_added_observer(
       chrome::NOTIFICATION_TAB_ADDED,
       content::NotificationService::AllSources());
 
   browser->OpenURL(OpenURLParams(
       url, Referrer(), disposition, ui::PAGE_TRANSITION_TYPED, false));
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
     tab_added_observer.Wait();
   if (!(browser_test_flags & BROWSER_TEST_WAIT_FOR_NAVIGATION)) {
     // Some other flag caused the wait prior to this.
     return;
   }
   WebContents* web_contents = NULL;
-  if (disposition == NEW_BACKGROUND_TAB) {
+  if (disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB) {
     // We've opened up a new tab, but not selected it.
     TabStripModel* tab_strip = browser->tab_strip_model();
     web_contents = tab_strip->GetWebContentsAt(tab_strip->active_index() + 1);
     EXPECT_TRUE(web_contents != NULL)
         << " Unable to wait for navigation to \"" << url.spec()
         << "\" because the new tab is not available yet";
     if (!web_contents)
       return;
-  } else if ((disposition == CURRENT_TAB) ||
-      (disposition == NEW_FOREGROUND_TAB) ||
-      (disposition == SINGLETON_TAB)) {
+  } else if ((disposition == WindowOpenDisposition::CURRENT_TAB) ||
+             (disposition == WindowOpenDisposition::NEW_FOREGROUND_TAB) ||
+             (disposition == WindowOpenDisposition::SINGLETON_TAB)) {
     // The currently selected tab is the right one.
     web_contents = browser->tab_strip_model()->GetActiveWebContents();
   }
-  if (disposition == CURRENT_TAB) {
+  if (disposition == WindowOpenDisposition::CURRENT_TAB) {
     same_tab_observer.Wait();
     return;
   } else if (web_contents) {
     content::TestNavigationObserver observer(web_contents,
                                              number_of_navigations);
     observer.Wait();
     return;
   }
   EXPECT_TRUE(NULL != web_contents) << " Unable to wait for navigation to \""
                                     << url.spec() << "\""
                                     << " because we can't get the tab contents";
 }
 
 void NavigateToURLWithDisposition(Browser* browser,
                                   const GURL& url,
                                   WindowOpenDisposition disposition,
                                   int browser_test_flags) {
   NavigateToURLWithDispositionBlockUntilNavigationsComplete(
       browser,
       url,
       1,
       disposition,
       browser_test_flags);
 }
 
 void NavigateToURLBlockUntilNavigationsComplete(Browser* browser,
                                                 const GURL& url,
                                                 int number_of_navigations) {
   NavigateToURLWithDispositionBlockUntilNavigationsComplete(
-      browser,
-      url,
-      number_of_navigations,
-      CURRENT_TAB,
+      browser, url, number_of_navigations, WindowOpenDisposition::CURRENT_TAB,
       BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 base::FilePath GetTestFilePath(const base::FilePath& dir,
                                const base::FilePath& file) {
   base::FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   return path.Append(dir).Append(file);
 }
 
@@ skipping 272 matching lines @@
         new content::MessageLoopRunner;
     WaitHistoryLoadedObserver observer(runner.get());
     ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
         scoped_observer(&observer);
     scoped_observer.Add(history_service);
     runner->Run();
   }
 }
 
 }  // namespace ui_test_utils