Add desktop type context to most existing instances of FindTabbedBrowser.

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/stringprintf.h"
@@ skipping 35 matching lines @@
 // Returns true if the specified Browser can open tabs. Not all Browsers support
 // multiple tabs, such as app frames and popups. This function returns false for
 // those types of Browser.
 bool WindowCanOpenTabs(Browser* browser) {
   return browser->CanSupportWindowFeature(Browser::FEATURE_TABSTRIP) ||
       browser->tab_strip_model()->empty();
 }
 
 // Finds an existing Browser compatible with |profile|, making a new one if no
 // such Browser is located.
-Browser* GetOrCreateBrowser(Profile* profile) {
-  Browser* browser = browser::FindTabbedBrowser(profile, false);
+Browser* GetOrCreateBrowser(Profile* profile,
+                            chrome::HostDesktopType host_desktop_type) {
+  Browser* browser =
+      browser::FindTabbedBrowser(profile, false, host_desktop_type);
   return browser ? browser : new Browser(Browser::CreateParams(profile));
 }
 
 // Change some of the navigation parameters based on the particular URL.
 // Currently this applies to some chrome:// pages which we always want to open
 // in a non-incognito window. Note that even though a ChromeOS guest session is
 // technically an incognito window, these URLs are allowed.
 // Returns true on success. Otherwise, if changing params leads the browser into
 // an erroneous state, returns false.
 bool AdjustNavigateParamsForURL(chrome::NavigateParams* params) {
   if (params->target_contents != NULL ||
       chrome::IsURLAllowedInIncognito(params->url) ||
       Profile::IsGuestSession()) {
     return true;
   }
 
   Profile* profile = params->initiating_profile;
 
   if (profile->IsOffTheRecord() || params->disposition == 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->browser = browser::FindOrCreateTabbedBrowser(profile);
+    params->browser =
+        browser::FindOrCreateTabbedBrowser(profile, params->host_desktop_type);
     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 TabContents 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 = chrome::GetActiveTabContents(params->browser);
 
   Profile* profile = params->initiating_profile;
 
   switch (params->disposition) {
     case 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);
+      return GetOrCreateBrowser(profile, params->host_desktop_type);
     case SINGLETON_TAB:
     case NEW_FOREGROUND_TAB:
     case 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);
+      return GetOrCreateBrowser(profile, params->host_desktop_type);
     case NEW_POPUP: {
       // Make a new popup window.
       // Coerce app-style if |source| represents an app.
       std::string app_name;
       if (!params->extension_app_id.empty()) {
         app_name = web_app::GenerateApplicationNameFromExtensionId(
             params->extension_app_id);
       } else if (!params->browser->app_name().empty()) {
         app_name = params->browser->app_name();
       } else if (params->source_contents) {
@@ skipping 13 matching lines @@
 
       return new Browser(Browser::CreateParams::CreateForApp(
           Browser::TYPE_POPUP, app_name, params->window_bounds, profile));
     }
     case NEW_WINDOW: {
       // Make a new normal browser window.
       return new Browser(Browser::CreateParams(profile));
     }
     case OFF_THE_RECORD:
       // Make or find an incognito window.
-      return GetOrCreateBrowser(profile->GetOffTheRecordProfile());
+      return GetOrCreateBrowser(profile->GetOffTheRecordProfile(),
+                                params->host_desktop_type);
     // The following types all result in no navigation.
     case SUPPRESS_OPEN:
     case SAVE_TO_DISK:
     case IGNORE_ACTION:
       return NULL;
     default:
       NOTREACHED();
   }
   return NULL;
 }
@@ skipping 142 matching lines @@
       disposition(CURRENT_TAB),
       transition(a_transition),
       is_renderer_initiated(false),
       tabstrip_index(-1),
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(NO_ACTION),
       user_gesture(true),
       path_behavior(RESPECT),
       ref_behavior(IGNORE_REF),
       browser(a_browser),
-      initiating_profile(NULL) {}
+      initiating_profile(NULL) {
+        if (a_browser)
+          host_desktop_type = a_browser->host_desktop_type();
+        else
+          host_desktop_type = chrome::HOST_DESKTOP_TYPE_NATIVE;
+      }
 
 NavigateParams::NavigateParams(Browser* a_browser,
                                TabContents* a_target_contents)
     : target_contents(a_target_contents),
       source_contents(NULL),
       disposition(CURRENT_TAB),
       transition(content::PAGE_TRANSITION_LINK),
       is_renderer_initiated(false),
       tabstrip_index(-1),
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(NO_ACTION),
       user_gesture(true),
       path_behavior(RESPECT),
       ref_behavior(IGNORE_REF),
       browser(a_browser),
-      initiating_profile(NULL) {}
+      initiating_profile(NULL) {
+        if (a_browser)
+          host_desktop_type = a_browser->host_desktop_type();
+        else
+          host_desktop_type = chrome::HOST_DESKTOP_TYPE_NATIVE;
+      }
 
 NavigateParams::NavigateParams(Profile* a_profile,
                                const GURL& a_url,
                                content::PageTransition a_transition)
     : url(a_url),
       target_contents(NULL),
       source_contents(NULL),
       disposition(NEW_FOREGROUND_TAB),
       transition(a_transition),
       is_renderer_initiated(false),
       tabstrip_index(-1),
       tabstrip_add_types(TabStripModel::ADD_ACTIVE),
       window_action(SHOW_WINDOW),
       user_gesture(true),
       path_behavior(RESPECT),
       ref_behavior(IGNORE_REF),
       browser(NULL),
-      initiating_profile(a_profile) {}
+      initiating_profile(a_profile),
+      host_desktop_type(chrome::HOST_DESKTOP_TYPE_NATIVE) {}
 
 NavigateParams::~NavigateParams() {}
 
 void Navigate(NavigateParams* params) {
   Browser* source_browser = params->browser;
   if (source_browser)
     params->initiating_profile = source_browser->profile();
   DCHECK(params->initiating_profile);
 
   if (!AdjustNavigateParamsForURL(params))
@@ skipping 190 matching lines @@
   return !(url.scheme() == chrome::kChromeUIScheme &&
       (url.host() == chrome::kChromeUISettingsHost ||
        url.host() == chrome::kChromeUISettingsFrameHost ||
        url.host() == chrome::kChromeUIExtensionsHost ||
        url.host() == chrome::kChromeUIBookmarksHost ||
        url.host() == chrome::kChromeUISyncPromoHost ||
        url.host() == chrome::kChromeUIUberHost));
 }
 
 }  // namespace chrome