Convert WindowOpenDisposition to an enum class.

chrome/browser/ui/browser_navigator.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/ui/browser_navigator.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 84 matching lines @@
 bool AdjustNavigateParamsForURL(chrome::NavigateParams* params) {
   if (params->target_contents != NULL ||
       chrome::IsURLAllowedInIncognito(params->url,
                                       params->initiating_profile) ||
       params->initiating_profile->IsGuestSession()) {
     return true;
   }
 
   Profile* profile = params->initiating_profile;
 
-  if (profile->IsOffTheRecord() || params->disposition == OFF_THE_RECORD) {
+  if (profile->IsOffTheRecord() ||
+      params->disposition == WindowOpenDisposition::OFF_THE_RECORD) {
     profile = profile->GetOriginalProfile();
 
     // If incognito is forced, we punt.
     PrefService* prefs = profile->GetPrefs();
     if (prefs && IncognitoModePrefs::GetAvailability(prefs) ==
             IncognitoModePrefs::FORCED) {
       return false;
     }
 
-    params->disposition = SINGLETON_TAB;
+    params->disposition = WindowOpenDisposition::SINGLETON_TAB;
     params->browser = GetOrCreateBrowser(profile);
     params->window_action = chrome::NavigateParams::SHOW_WINDOW;
   }
 
   return true;
 }
 
 // Returns a Browser that can host the navigation or tab addition specified in
 // |params|. This might just return the same Browser specified in |params|, or
 // some other if that Browser is deemed incompatible.
 Browser* GetBrowserForDisposition(chrome::NavigateParams* params) {
   // If no source WebContents was specified, we use the selected one from
   // the target browser. This must happen first, before
   // GetBrowserForDisposition() has a chance to replace |params->browser| with
   // another one.
   if (!params->source_contents && params->browser) {
     params->source_contents =
         params->browser->tab_strip_model()->GetActiveWebContents();
   }
 
   Profile* profile = params->initiating_profile;
 
   switch (params->disposition) {
-    case CURRENT_TAB:
+    case WindowOpenDisposition::CURRENT_TAB:
       if (params->browser)
         return params->browser;
       // Find a compatible window and re-execute this command in it. Otherwise
       // re-run with NEW_WINDOW.
       return GetOrCreateBrowser(profile);
-    case SINGLETON_TAB:
-    case NEW_FOREGROUND_TAB:
-    case NEW_BACKGROUND_TAB:
+    case WindowOpenDisposition::SINGLETON_TAB:
+    case WindowOpenDisposition::NEW_FOREGROUND_TAB:
+    case WindowOpenDisposition::NEW_BACKGROUND_TAB:
       // See if we can open the tab in the window this navigator is bound to.
       if (params->browser && WindowCanOpenTabs(params->browser))
         return params->browser;
       // Find a compatible window and re-execute this command in it. Otherwise
       // re-run with NEW_WINDOW.
       return GetOrCreateBrowser(profile);
-    case NEW_POPUP: {
+    case WindowOpenDisposition::NEW_POPUP: {
       // Make a new popup window.
       // Coerce app-style if |source| represents an app.
       std::string app_name;
 #if defined(ENABLE_EXTENSIONS)
       if (!params->extension_app_id.empty()) {
         app_name = web_app::GenerateApplicationNameFromExtensionId(
             params->extension_app_id);
       } else if (params->browser && !params->browser->app_name().empty()) {
         app_name = params->browser->app_name();
       } else if (params->source_contents) {
         extensions::TabHelper* extensions_tab_helper =
             extensions::TabHelper::FromWebContents(params->source_contents);
         if (extensions_tab_helper && extensions_tab_helper->is_app()) {
           app_name = web_app::GenerateApplicationNameFromExtensionId(
               extensions_tab_helper->extension_app()->id());
         }
       }
 #endif
       if (app_name.empty()) {
         Browser::CreateParams browser_params(Browser::TYPE_POPUP, profile);
         browser_params.trusted_source = params->trusted_source;
         browser_params.initial_bounds = params->window_bounds;
         return new Browser(browser_params);
       }
 
       return new Browser(Browser::CreateParams::CreateForApp(
           app_name, params->trusted_source, params->window_bounds, profile));
     }
-    case NEW_WINDOW: {
+    case WindowOpenDisposition::NEW_WINDOW: {
       // Make a new normal browser window.
       return new Browser(Browser::CreateParams(profile));
     }
-    case OFF_THE_RECORD:
+    case WindowOpenDisposition::OFF_THE_RECORD:
       // Make or find an incognito window.
       return GetOrCreateBrowser(profile->GetOffTheRecordProfile());
     // The following types result in no navigation.
-    case SAVE_TO_DISK:
-    case IGNORE_ACTION:
+    case WindowOpenDisposition::SAVE_TO_DISK:
+    case WindowOpenDisposition::IGNORE_ACTION:
       return NULL;
     default:
       NOTREACHED();
   }
   return NULL;
 }
 
 // Fix disposition and other parameter values depending on prevailing
 // conditions.
 void NormalizeDisposition(chrome::NavigateParams* params) {
   // Calculate the WindowOpenDisposition if necessary.
   if (params->browser->tab_strip_model()->empty() &&
-      (params->disposition == NEW_BACKGROUND_TAB ||
-       params->disposition == CURRENT_TAB ||
-       params->disposition == SINGLETON_TAB)) {
-    params->disposition = NEW_FOREGROUND_TAB;
+      (params->disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB ||
+       params->disposition == WindowOpenDisposition::CURRENT_TAB ||
+       params->disposition == WindowOpenDisposition::SINGLETON_TAB)) {
+    params->disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   }
   if (params->browser->profile()->IsOffTheRecord() &&
-      params->disposition == OFF_THE_RECORD) {
-    params->disposition = NEW_FOREGROUND_TAB;
+      params->disposition == WindowOpenDisposition::OFF_THE_RECORD) {
+    params->disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   }
-  if (!params->source_contents && params->disposition == CURRENT_TAB)
-    params->disposition = NEW_FOREGROUND_TAB;
+  if (!params->source_contents &&
+      params->disposition == WindowOpenDisposition::CURRENT_TAB)
+    params->disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
 
   switch (params->disposition) {
-    case NEW_BACKGROUND_TAB:
+    case WindowOpenDisposition::NEW_BACKGROUND_TAB:
       // Disposition trumps add types. ADD_ACTIVE is a default, so we need to
       // remove it if disposition implies the tab is going to open in the
       // background.
       params->tabstrip_add_types &= ~TabStripModel::ADD_ACTIVE;
       break;
 
-    case NEW_WINDOW:
-    case NEW_POPUP:
+    case WindowOpenDisposition::NEW_WINDOW:
+    case WindowOpenDisposition::NEW_POPUP: {
       // Code that wants to open a new window typically expects it to be shown
       // automatically.
       if (params->window_action == chrome::NavigateParams::NO_ACTION)
         params->window_action = chrome::NavigateParams::SHOW_WINDOW;
       // Fall-through.
-    case NEW_FOREGROUND_TAB:
-    case SINGLETON_TAB:
+    }
+    case WindowOpenDisposition::NEW_FOREGROUND_TAB:
+    case WindowOpenDisposition::SINGLETON_TAB:
       params->tabstrip_add_types |= TabStripModel::ADD_ACTIVE;
       break;
 
     default:
       break;
   }
 }
 
 // Obtain the profile used by the code that originated the Navigate() request.
 Profile* GetSourceProfile(chrome::NavigateParams* params) {
@@ skipping 35 matching lines @@
   explicit ScopedBrowserShower(chrome::NavigateParams* params)
       : params_(params) {
   }
   ~ScopedBrowserShower() {
     if (params_->window_action ==
         chrome::NavigateParams::SHOW_WINDOW_INACTIVE) {
       params_->browser->window()->ShowInactive();
     } else if (params_->window_action == chrome::NavigateParams::SHOW_WINDOW) {
       params_->browser->window()->Show();
       // If a user gesture opened a popup window, focus the contents.
-      if (params_->user_gesture && params_->disposition == NEW_POPUP &&
+      if (params_->user_gesture &&
+          params_->disposition == WindowOpenDisposition::NEW_POPUP &&
           params_->target_contents) {
         params_->target_contents->Focus();
       }
     }
   }
 
  private:
   chrome::NavigateParams* params_;
   DISALLOW_COPY_AND_ASSIGN(ScopedBrowserShower);
 };
@@ skipping 38 matching lines @@
       params.browser->profile(),
       params.source_site_instance
           ? params.source_site_instance
           : tab_util::GetSiteInstanceForNewTab(params.browser->profile(), url));
   create_params.main_frame_name = params.frame_name;
   if (params.source_contents) {
     create_params.initial_size =
         params.source_contents->GetContainerBounds().size();
     create_params.created_with_opener = params.created_with_opener;
   }
-  if (params.disposition == NEW_BACKGROUND_TAB)
+  if (params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
     create_params.initially_hidden = true;
 
 #if defined(USE_AURA)
   if (params.browser->window() &&
       params.browser->window()->GetNativeWindow()) {
     create_params.context =
         params.browser->window()->GetNativeWindow();
   }
 #endif
 
@@ skipping 44 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
   const extensions::Extension* extension =
     extensions::ExtensionRegistry::Get(params->initiating_profile)->
         enabled_extensions().GetExtensionOrAppByURL(params->url);
   // Platform apps cannot navigate. Block the request.
   if (extension && extension->is_platform_app())
     params->url = GURL(chrome::kExtensionInvalidRequestURL);
 #endif
 
   // The browser window may want to adjust the disposition.
-  if (params->disposition == NEW_POPUP &&
-      source_browser &&
-      source_browser->window()) {
+  if (params->disposition == WindowOpenDisposition::NEW_POPUP &&
+      source_browser && source_browser->window()) {
     params->disposition =
         source_browser->window()->GetDispositionForPopupBounds(
             params->window_bounds);
   }
 
   params->browser = GetBrowserForDisposition(params);
   if (!params->browser)
     return;
 
 #if defined(USE_ASH)
@@ skipping 40 matching lines @@
 
   // If a new window has been created, it needs to be shown.
   if (params->window_action == NavigateParams::NO_ACTION &&
       source_browser != params->browser &&
       params->browser->tab_strip_model()->empty()) {
     params->window_action = NavigateParams::SHOW_WINDOW;
   }
 
   // If we create a popup window from a non user-gesture, don't activate it.
   if (params->window_action == NavigateParams::SHOW_WINDOW &&
-      params->disposition == NEW_POPUP &&
+      params->disposition == WindowOpenDisposition::NEW_POPUP &&
       params->user_gesture == false) {
     params->window_action = NavigateParams::SHOW_WINDOW_INACTIVE;
   }
 
   // Determine if the navigation was user initiated. If it was, we need to
   // inform the target WebContents, and we may need to update the UI.
   bool user_initiated =
       params->transition & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR ||
       ui::PageTransitionCoreTypeIs(params->transition,
                                    ui::PAGE_TRANSITION_TYPED) ||
@@ skipping 12 matching lines @@
   int singleton_index = chrome::GetIndexOfSingletonTab(params);
 
   // Did we use a prerender?
   bool swapped_in_prerender = false;
 
   // If no target WebContents was specified, we need to construct one if
   // we are supposed to target a new tab; unless it's a singleton that already
   // exists.
   if (!params->target_contents && singleton_index < 0) {
     DCHECK(!params->url.is_empty());
-    if (params->disposition != CURRENT_TAB) {
+    if (params->disposition != WindowOpenDisposition::CURRENT_TAB) {
       params->target_contents = CreateTargetContents(*params, params->url);
 
       // This function takes ownership of |params->target_contents| until it
       // is added to a TabStripModel.
       target_contents_owner.TakeOwnership();
     } else {
       // ... otherwise if we're loading in the current tab, the target is the
       // same as the source.
       DCHECK(params->source_contents);
       params->target_contents = params->source_contents;
@@ skipping 19 matching lines @@
   } else {
     // |target_contents| was specified non-NULL, and so we assume it has already
     // been navigated appropriately. We need to do nothing more other than
     // add it to the appropriate tabstrip.
   }
 
   // If the user navigated from the omnibox, and the selected tab is going to
   // lose focus, then make sure the focus for the source tab goes away from the
   // omnibox.
   if (params->source_contents &&
-      (params->disposition == NEW_FOREGROUND_TAB ||
-       params->disposition == NEW_WINDOW) &&
+      (params->disposition == WindowOpenDisposition::NEW_FOREGROUND_TAB ||
+       params->disposition == WindowOpenDisposition::NEW_WINDOW) &&
       (params->tabstrip_add_types & TabStripModel::ADD_INHERIT_OPENER))
     params->source_contents->Focus();
 
   if (params->source_contents == params->target_contents ||
-      (swapped_in_prerender && params->disposition == CURRENT_TAB)) {
+      (swapped_in_prerender &&
+       params->disposition == WindowOpenDisposition::CURRENT_TAB)) {
     // The navigation occurred in the source tab.
     params->browser->UpdateUIForNavigationInTab(params->target_contents,
                                                 params->transition,
                                                 user_initiated);
   } else if (singleton_index == -1) {
     // If some non-default value is set for the index, we should tell the
     // TabStripModel to respect it.
     if (params->tabstrip_index != -1)
       params->tabstrip_add_types |= TabStripModel::ADD_FORCE_INDEX;
 
@@ skipping 19 matching lines @@
       LoadURLInContents(target, params->url, params);
     }
 
     // If the singleton tab isn't already selected, select it.
     if (params->source_contents != params->target_contents) {
       params->browser->tab_strip_model()->ActivateTabAt(singleton_index,
                                                         user_initiated);
     }
   }
 
-  if (params->disposition != CURRENT_TAB) {
+  if (params->disposition != WindowOpenDisposition::CURRENT_TAB) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_TAB_ADDED,
         content::Source<content::WebContentsDelegate>(params->browser),
         content::Details<WebContents>(params->target_contents));
   }
 }
 
 bool IsURLAllowedInIncognito(const GURL& url,
                              content::BrowserContext* browser_context) {
   if (url.scheme() == content::kViewSourceScheme) {
@@ skipping 45 matching lines @@
   bool reverse_on_redirect = false;
   content::BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
       &rewritten_url, browser_context, &reverse_on_redirect);
 
   // Some URLs are mapped to uber subpages. Do not allow them in incognito.
   return !(rewritten_url.scheme() == content::kChromeUIScheme &&
            rewritten_url.host() == chrome::kChromeUIUberHost);
 }
 
 }  // namespace chrome