When we open a popup window from an app window, we used to identify this popu...

chrome/browser/browser.cc

 // Copyright (c) 2006-2008 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/browser.h"
 
 #include "base/command_line.h"
 #include "base/idle_timer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 248 matching lines @@
 
 // static
 Browser* Browser::CreateForPopup(Profile* profile) {
   Browser* browser = new Browser(TYPE_POPUP, profile);
   browser->CreateBrowserWindow();
   return browser;
 }
 
 // static
 Browser* Browser::CreateForApp(const std::wstring& app_name,
-                               Profile* profile) {
-  Browser* browser = new Browser(TYPE_APP, profile);
+                               Profile* profile, bool is_popup) {
+  Browser* browser = new Browser(is_popup? TYPE_APP_POPUP : TYPE_APP, profile);
   browser->app_name_ = app_name;
   browser->CreateBrowserWindow();
   return browser;
 }
 
 void Browser::CreateBrowserWindow() {
   DCHECK(!window_);
   window_ = BrowserWindow::CreateBrowserWindow(this);
 
   // Show the First Run information bubble if we've been told to.
@@ skipping 29 matching lines @@
   // TODO(eroman): should we have referrer here?
   browser->AddTabWithURL(url, GURL(), PageTransition::LINK, true, NULL);
   browser->window()->Show();
 }
 
 // static
 void Browser::OpenApplicationWindow(Profile* profile, const GURL& url) {
   std::wstring app_name = ComputeApplicationNameFromURL(url);
   RegisterAppPrefs(app_name);
 
-  Browser* browser = Browser::CreateForApp(app_name, profile);
+  Browser* browser = Browser::CreateForApp(app_name, profile, false);
   browser->AddTabWithURL(url, GURL(), PageTransition::START_PAGE, true, NULL);
   browser->window()->Show();
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   browser->GetSelectedTabContents()->SetInitialFocus();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, State Storage and Retrieval for UI:
 
 std::wstring Browser::GetWindowPlacementKey() const {
   std::wstring name(prefs::kBrowserWindowPlacement);
   if (!app_name_.empty()) {
     name.append(L"_");
     name.append(app_name_);
   }
   return name;
 }
 
 bool Browser::ShouldSaveWindowPlacement() const {
   // We don't save window position for popups.
-  return type() != TYPE_POPUP;
+  return (type() & TYPE_POPUP) == 0;
 }
 
 void Browser::SaveWindowPlacement(const gfx::Rect& bounds, bool maximized) {
   // Save to the session storage service, used when reloading a past session.
   // Note that we don't want to be the ones who cause lazy initialization of
   // the session service. This function gets called during initial window
   // showing, and we don't want to bring in the session service this early.
   if (profile()->HasSessionService()) {
     SessionService* session_service = profile()->GetSessionService();
     if (session_service)
@@ skipping 119 matching lines @@
 
   CloseAllTabs();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
 TabContents* Browser::AddTabWithURL(
     const GURL& url, const GURL& referrer, PageTransition::Type transition,
     bool foreground, SiteInstance* instance) {
-  if (type_ == TYPE_APP && tabstrip_model_.count() == 1) {
+  if ((type_ & TYPE_APP) != 0 && tabstrip_model_.count() == 1) {
     NOTREACHED() << "Cannot add a tab in a mono tab application.";
     return NULL;
   }
 
   GURL url_to_load = url;
   if (url_to_load.is_empty())
     url_to_load = GetHomePage();
   TabContents* contents =
       CreateTabContentsForURL(url_to_load, referrer, profile_, transition,
                               false, instance);
@@ skipping 810 matching lines @@
     // If you duplicate a tab that is not selected, we need to make sure to
     // select the tab being duplicated so that DetermineInsertionIndex returns
     // the right index (if tab 5 is selected and we right-click tab 1 we want
     // the new tab to appear in index position 2, not 6).
     if (tabstrip_model_.selected_index() != index)
       tabstrip_model_.SelectTabContentsAt(index, true);
     tabstrip_model_.AddTabContents(new_contents, index + 1,
                                    PageTransition::LINK, true);
   } else {
     Browser* browser = NULL;
-    if (type_ == TYPE_APP) {
-      browser = Browser::CreateForApp(app_name_, profile_);
+    if (type_ & TYPE_APP) {
+      browser = Browser::CreateForApp(app_name_, profile_, type_ & TYPE_POPUP);
     } else if (type_ == TYPE_POPUP) {
       browser = Browser::CreateForPopup(profile_);
     }
 
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetNormalBounds().origin(),
                           window()->GetNormalBounds().size()));
 
@@ skipping 209 matching lines @@
       if (web_contents) {
         const GURL& current_url = web_contents->GetURL();
         if (SiteInstance::IsSameWebSite(current_url, url))
           instance = web_contents->GetSiteInstance();
       }
     }
   }
 
   // If this is an application we can only have one tab so a new tab always
   // goes into a tabbed browser window.
-  if (disposition != NEW_WINDOW && type_ == TYPE_APP) {
+  if (disposition != NEW_WINDOW && type_ & TYPE_APP) {
     // If the disposition is OFF_THE_RECORD we don't want to create a new
     // browser that will itself create another OTR browser. This will result in
     // a browser leak (and crash below because no tab is created or selected).
     if (disposition == OFF_THE_RECORD) {
       OpenURLOffTheRecord(profile_, url);
       return;
     }
 
     Browser* b = GetOrCreateTabbedBrowser();
     DCHECK(b);
@@ skipping 104 matching lines @@
       disposition != NEW_WINDOW && disposition != NEW_POPUP &&
       type_ != TYPE_NORMAL) {
     Browser* b = GetOrCreateTabbedBrowser();
     DCHECK(b);
     PageTransition::Type transition = PageTransition::LINK;
     // If we were called from an "installed webapp" we want to emulate the code
     // that is run from browser_init.cc for links from external applications.
     // This means we need to open the tab with the START PAGE transition.
     // AddNewContents doesn't support this but the TabStripModel's
     // AddTabContents method does.
-    if (type_ == TYPE_APP)
+    if (type_ & TYPE_APP)
       transition = PageTransition::START_PAGE;
     b->tabstrip_model()->AddTabContents(new_contents, -1, transition, true);
     b->window()->Show();
     return;
   }
 
   if (disposition == NEW_POPUP) {
     BuildPopupWindow(source, new_contents, initial_pos);
   } else if (disposition == NEW_WINDOW) {
     Browser* browser = Browser::Create(profile_);
@@ skipping 37 matching lines @@
 
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED() << "CloseContents called for tab not in our strip";
     return;
   }
   tabstrip_model_.CloseTabContentsAt(index);
 }
 
 void Browser::MoveContents(TabContents* source, const gfx::Rect& pos) {
-  if (type() != TYPE_POPUP) {
+  if ((type() & TYPE_POPUP) == 0) {
     NOTREACHED() << "moving invalid browser type";
     return;
   }
   window_->SetBounds(pos);
 }
 
 bool Browser::IsPopup(TabContents* source) {
   // A non-tabbed BROWSER is an unconstrained popup.
-  return (type() == TYPE_POPUP);
+  return (type() & TYPE_POPUP);
 }
 
 void Browser::ToolbarSizeChanged(TabContents* source, bool is_animating) {
   if (source == GetSelectedTabContents() || source == NULL) {
     // This will refresh the shelf if needed.
     window_->SelectedTabToolbarSizeChanged(is_animating);
   }
 }
 
 void Browser::URLStarredChanged(TabContents* source, bool starred) {
@@ skipping 25 matching lines @@
     PrefService* prefs = profile_->GetPrefs();
     GetStatusBubble()->SetURL(url, prefs->GetString(prefs::kAcceptLanguages));
   }
 }
 
 void Browser::ContentsZoomChange(bool zoom_in) {
   ExecuteCommand(zoom_in ? IDC_ZOOM_PLUS : IDC_ZOOM_MINUS);
 }
 
 bool Browser::IsApplication() const {
-  return type_ == TYPE_APP;
+  return (type_ & TYPE_APP) != 0;
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
   int index = tabstrip_model_.GetIndexOfTabContents(contents);
   if (index < 0)
     return;
 
   const GURL& url = contents->controller()->GetActiveEntry()->url();
   std::wstring app_name = ComputeApplicationNameFromURL(url);
   RegisterAppPrefs(app_name);
 
   tabstrip_model_.DetachTabContentsAt(index);
-  Browser* browser = Browser::CreateForApp(app_name, profile_);
+  Browser* browser = Browser::CreateForApp(app_name, profile_, false);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 void Browser::ContentsStateChanged(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index != TabStripModel::kNoTab)
     tabstrip_model_.UpdateTabContentsStateAt(index);
 }
 
@@ skipping 278 matching lines @@
 
 void Browser::UpdateCommandsForFullscreenMode(bool is_fullscreen) {
   const bool show_main_ui = (type() == TYPE_NORMAL) && !is_fullscreen;
 
   // Navigation commands
   command_updater_.UpdateCommandEnabled(IDC_OPEN_CURRENT_URL, show_main_ui);
 
   // Window management commands
   command_updater_.UpdateCommandEnabled(IDC_PROFILE_MENU, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_SHOW_AS_TAB,
-      (type() == TYPE_POPUP) && !is_fullscreen);
+      (type() & TYPE_POPUP) && !is_fullscreen);
 
   // Focus various bits of UI
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_TOOLBAR, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_LOCATION, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_SEARCH, show_main_ui);
 
   // Show various bits of UI
   command_updater_.UpdateCommandEnabled(IDC_DEVELOPER_MENU, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_NEW_PROFILE, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_REPORT_BUG, show_main_ui);
@@ skipping 264 matching lines @@
       profile_, TYPE_NORMAL);
   if (!browser)
     browser = Browser::Create(profile_);
   return browser;
 }
 
 void Browser::BuildPopupWindow(TabContents* source,
                                TabContents* new_contents,
                                const gfx::Rect& initial_pos) {
   Browser* browser =
-      new Browser((type_ == TYPE_APP) ? TYPE_APP : TYPE_POPUP, profile_);
+      new Browser((type_ & TYPE_APP) ? TYPE_APP_POPUP : TYPE_POPUP, profile_);
   browser->set_override_bounds(initial_pos);
   browser->CreateBrowserWindow();
   // We need to Show before AddNewContents, otherwise AddNewContents will focus
   // it (via BrowserView::TabSelectedAt calling RestoreFocus), triggering any
   // onblur="" handlers.
   browser->window()->Show();
   // TODO(beng): See if this can be made to use
   //             TabStripModel::AppendTabContents.
   browser->AddNewContents(source, new_contents, NEW_FOREGROUND_TAB,
                           gfx::Rect(), true);
@@ skipping 52 matching lines @@
 
   // We need to register the window position pref.
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }