Implement settings in a widnow

chrome/browser/ui/chrome_pages.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/chrome_pages.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
+#include "chrome/browser/ui/settings_window_manager.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/options/content_settings_handler.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/user_metrics.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/url_util.h"
-#include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/enumerate_modules_model_win.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/genius_app/app_id.h"
 #include "chromeos/chromeos_switches.h"
 #endif
 
 using base::UserMetricsAction;
 
 namespace chrome {
 namespace {
 
 const char kHashMark[] = "#";
 
 void OpenBookmarkManagerWithHash(Browser* browser,
                                  const std::string& action,
                                  int64 node_id) {
   content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
   content::RecordAction(UserMetricsAction("ShowBookmarks"));
   NavigateParams params(GetSingletonTabNavigateParams(
       browser,
-      GURL(kChromeUIBookmarksURL).Resolve(
-          base::StringPrintf("/#%s%s", action.c_str(),
-              base::Int64ToString(node_id).c_str()))));
+      GURL(kChromeUIBookmarksURL).Resolve(base::StringPrintf(
+          "/#%s%s", action.c_str(), base::Int64ToString(node_id).c_str()))));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void NavigateToSingletonTab(Browser* browser, const GURL& url) {
   NavigateParams params(GetSingletonTabNavigateParams(browser, url));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 // Shows either the help app or the appropriate help page for |source|. If
 // |browser| is NULL and the help page is used (vs the app), the help page is
 // shown in the last active browser. If there is no such browser, a new browser
 // is created.
 void ShowHelpImpl(Browser* browser,
                   Profile* profile,
                   HostDesktopType host_desktop_type,
                   HelpSource source) {
   content::RecordAction(UserMetricsAction("ShowHelpTab"));
 #if defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD)
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(chromeos::switches::kDisableGeniusApp)) {
-    const extensions::Extension* extension = profile->GetExtensionService()->
-        GetInstalledExtension(genius_app::kGeniusAppId);
-    OpenApplication(
-        AppLaunchParams(profile, extension, 0, host_desktop_type));
+    const extensions::Extension* extension =
+        profile->GetExtensionService()->GetInstalledExtension(
+            genius_app::kGeniusAppId);
+    OpenApplication(AppLaunchParams(profile, extension, 0, host_desktop_type));
     return;
   }
 #endif
   GURL url;
   switch (source) {
     case HELP_SOURCE_KEYBOARD:
       url = GURL(kChromeHelpViaKeyboardURL);
       break;
     case HELP_SOURCE_MENU:
       url = GURL(kChromeHelpViaMenuURL);
@@ skipping 76 matching lines @@
       return;
     }
   }
 #endif
 
   content::RecordAction(UserMetricsAction("AboutConflicts"));
   ShowSingletonTab(browser, GURL(kChromeUIConflictsURL));
 }
 
 void ShowHelp(Browser* browser, HelpSource source) {
-  ShowHelpImpl(browser, browser->profile(), browser->host_desktop_type(),
-      source);
+  ShowHelpImpl(
+      browser, browser->profile(), browser->host_desktop_type(), source);
 }
 
 void ShowHelpForProfile(Profile* profile,
                         HostDesktopType host_desktop_type,
                         HelpSource source) {
   ShowHelpImpl(NULL, profile, host_desktop_type, source);
 }
 
 void ShowPolicy(Browser* browser) {
   ShowSingletonTab(browser, GURL(kChromeUIPolicyURL));
 }
 
 void ShowSlow(Browser* browser) {
 #if defined(OS_CHROMEOS)
   ShowSingletonTab(browser, GURL(kChromeUISlowURL));
 #endif
 }
 
+GURL GetSettingsUrl(const std::string& sub_page) {
+  std::string url = std::string(kChromeUISettingsURL) + sub_page;
+#if defined(OS_CHROMEOS)
+  if (sub_page.find(kInternetOptionsSubPage, 0) != std::string::npos) {
+    std::string::size_type loc = sub_page.find("?", 0);
+    std::string network_page =
+        loc != std::string::npos ? sub_page.substr(loc) : std::string();
+    url = std::string(kChromeUISettingsURL) + network_page;
+  }
+#endif
+  return GURL(url);
+}
+
+bool IsSettingsWindow(const Browser* browser) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableSettingsWindow))
+    return false;
+  if (browser->is_type_tabbed())
+    return false;
+  const content::WebContents* web_contents =
+      browser->tab_strip_model()->GetWebContentsAt(0);
+  if (!web_contents)
+    return false;
+  GURL url(web_contents->GetURL());
+  return (url.SchemeIs(content::kChromeUIScheme) &&
+          url.spec().find(chrome::kChromeUISettingsURL) == 0);
+}
+
 void ShowSettings(Browser* browser) {
-  content::RecordAction(UserMetricsAction("ShowOptions"));
   ShowSettingsSubPage(browser, std::string());
 }
 
 void ShowSettingsSubPage(Browser* browser, const std::string& sub_page) {
-  std::string url = std::string(kChromeUISettingsURL) + sub_page;
-#if defined(OS_CHROMEOS)
-  if (sub_page.find(kInternetOptionsSubPage, 0) != std::string::npos) {
-    std::string::size_type loc = sub_page.find("?", 0);
-    std::string network_page = loc != std::string::npos ?
-        sub_page.substr(loc) : std::string();
-    url = std::string(kChromeUISettingsURL) + network_page;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kEnableSettingsWindow)) {
+    SettingsWindowManager::GetInstance()->ShowForProfile(browser->profile(),
+                                                         sub_page);
+    return;
   }
-#endif
-  NavigateParams params(GetSingletonTabNavigateParams(browser, GURL(url)));
+  ShowSettingsSubPageInTabbedBrowser(browser, sub_page);
+}
+
+void ShowSettingsSubPageForProfile(Profile* profile,
+                                   const std::string& sub_page) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kEnableSettingsWindow)) {
+    SettingsWindowManager::GetInstance()->ShowForProfile(profile, sub_page);
+    return;
+  }
+  Browser* browser =
+      chrome::FindTabbedBrowser(profile, false, HOST_DESKTOP_TYPE_NATIVE);
+  if (!browser) {
+    browser = new Browser(
+        Browser::CreateParams(profile, chrome::HOST_DESKTOP_TYPE_NATIVE));
+  }
+  ShowSettingsSubPageInTabbedBrowser(browser, sub_page);
+}
+
+void ShowSettingsSubPageInTabbedBrowser(Browser* browser,
+                                        const std::string& sub_page) {
+  content::RecordAction(UserMetricsAction("ShowOptions"));
+  GURL gurl = GetSettingsUrl(sub_page);
+  NavigateParams params(GetSingletonTabNavigateParams(browser, gurl));
   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void ShowContentSettings(Browser* browser,
                          ContentSettingsType content_settings_type) {
   ShowSettingsSubPage(
       browser,
       kContentSettingsExceptionsSubPage + std::string(kHashMark) +
-      options::ContentSettingsHandler::ContentSettingsTypeToGroupName(
-          content_settings_type));
+          options::ContentSettingsHandler::ContentSettingsTypeToGroupName(
+              content_settings_type));
 }
 
 void ShowClearBrowsingDataDialog(Browser* browser) {
   content::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
   ShowSettingsSubPage(browser, kClearBrowserDataSubPage);
 }
 
 void ShowPasswordManager(Browser* browser) {
   content::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
   ShowSettingsSubPage(browser, kPasswordManagerSubPage);
@@ skipping 29 matching lines @@
     // If the browser's profile is an incognito profile, make sure to use
     // a browser window from the original profile.  The user cannot sign in
     // from an incognito window.
     scoped_ptr<ScopedTabbedBrowserDisplayer> displayer;
     if (browser->profile()->IsOffTheRecord()) {
       displayer.reset(new ScopedTabbedBrowserDisplayer(
           original_profile, chrome::HOST_DESKTOP_TYPE_NATIVE));
       browser = displayer->browser();
     }
 
-    NavigateToSingletonTab(browser,
-                           GURL(signin::GetPromoURL(source, false)));
+    NavigateToSingletonTab(browser, GURL(signin::GetPromoURL(source, false)));
     DCHECK_GT(browser->tab_strip_model()->count(), 0);
   }
 }
 
 }  // namespace chrome