Elim Browser::AppType

chrome/browser/ui/browser.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_BROWSER_H_
 #define CHROME_BROWSER_UI_BROWSER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 93 matching lines @@
                 public content::PageNavigator,
                 public content::NotificationObserver,
                 public ui::SelectFileDialog::Listener {
  public:
   // SessionService::WindowType mirrors these values.  If you add to this
   // enum, look at SessionService::WindowType to see if it needs to be
   // updated.
   enum Type {
     // If you add a new type, consider updating the test
     // BrowserTest.StartMaximized.
-    TYPE_TABBED = 1,
-    TYPE_POPUP = 2
-  };
-
-  // Distinguishes between browsers that host an app (opened from
-  // ApplicationLauncher::OpenApplication), and child browsers created by an app
-  // from Browser::CreateForApp (e.g. by windows.open or the extension API).
-  enum AppType {
-    APP_TYPE_HOST = 1,
-    APP_TYPE_CHILD = 2
+    TYPE_TABBED = 1,  // A tabbed browser
+    TYPE_POPUP = 2,  // A popup window opened by a browser page or an app
+    TYPE_HOSTED_POPUP = 3  // A popup window for a hosted app or system page

[Ben Goodger (Google), 2014/03/19 17:30:19]

I would be inclined to come up with a different name for this. Technically all
pages are "hosted", including drive-by-web.

This frame type is actually limited to trusted pages - pages we trust to be
loaded without showing the URL/nav bar. Either those that have been given this
elevated state by explicit user installation, or now (with your settings
changes) part of the core Chrome UI.

TYPE_TRUSTED_POPUP?

[stevenjb, 2014/04/04 00:04:10]

'TRUSTED' was actually my first thought also, although I worried that "trust"
might imply more than it suggests. But that's probably true with anything we
come up with here that isn't awkward, so 'TRUSTED' it is.

   };
 
   // Possible elements of the Browser window.
   enum WindowFeature {
     FEATURE_NONE = 0,
     FEATURE_TITLEBAR = 1,
     FEATURE_TABSTRIP = 2,
     FEATURE_TOOLBAR = 4,
     FEATURE_LOCATIONBAR = 8,
     FEATURE_BOOKMARKBAR = 16,
@@ skipping 34 matching lines @@
 
     // The browser type.
     Type type;
 
     // The associated profile.
     Profile* profile;
 
     // The host desktop the browser is created on.
     chrome::HostDesktopType host_desktop_type;
 
-    // The application name that is also the name of the window to the shell.
-    // This name should be set when:
-    // 1) we launch an application via an application shortcut or extension API.
-    // 2) we launch an undocked devtool window.
-    std::string app_name;
-
-    // Type of app (host or child). See description of AppType.
-    AppType app_type;
-
     // The bounds of the window to open.
     gfx::Rect initial_bounds;
 
     ui::WindowShowState initial_show_state;
 
     bool is_session_restore;
 
     // Supply a custom BrowserWindow implementation, to be used instead of the
     // default. Intended for testing.
     BrowserWindow* window;
+
+   private:
+    friend class Browser;
+
+    // The application name that is also the name of the window to the shell.
+    // Do not set this value directly, use CreateForApp.
+    // This name will be set for:
+    // 1) v1 applications launched via an application shortcut or extension API.
+    // 2) undocked devtool windows.
+    // 3) popup windows spawned from v1 applications.
+    std::string app_name;
   };
 
   // Constructors, Creation, Showing //////////////////////////////////////////
 
   explicit Browser(const CreateParams& params);
   virtual ~Browser();
 
   // Set overrides for the initial window bounds and maximized state.
   void set_override_bounds(const gfx::Rect& bounds) {
     override_bounds_ = bounds;
@@ skipping 16 matching lines @@
     return is_session_restore_;
   }
   chrome::HostDesktopType host_desktop_type() const {
     return host_desktop_type_;
   }
 
   // Accessors ////////////////////////////////////////////////////////////////
 
   Type type() const { return type_; }
   const std::string& app_name() const { return app_name_; }
-  AppType app_type() const { return app_type_; }
   Profile* profile() const { return profile_; }
   gfx::Rect override_bounds() const { return override_bounds_; }
 
   // |window()| will return NULL if called before |CreateBrowserWindow()|
   // is done.
   BrowserWindow* window() const { return window_; }
   ToolbarModel* toolbar_model() { return toolbar_model_.get(); }
   const ToolbarModel* toolbar_model() const { return toolbar_model_.get(); }
 #if defined(UNIT_TEST)
   void swap_toolbar_models(scoped_ptr<ToolbarModel>* toolbar_model) {
@@ skipping 205 matching lines @@
   virtual void HideValidationMessage(
       content::WebContents* web_contents) OVERRIDE;
   virtual void MoveValidationMessage(
       content::WebContents* web_contents,
       const gfx::Rect& anchor_in_root_view) OVERRIDE;
   virtual bool PreHandleGestureEvent(
       content::WebContents* source,
       const blink::WebGestureEvent& event) OVERRIDE;
 
   bool is_type_tabbed() const { return type_ == TYPE_TABBED; }
-  bool is_type_popup() const { return type_ == TYPE_POPUP; }
+  bool is_type_popup() const {
+    return type_ == TYPE_POPUP || type_ == TYPE_HOSTED_POPUP;
+  }
 
   bool is_app() const;
   bool is_devtools() const;
 
   // True when the mouse cursor is locked.
   bool IsMouseLocked() const;
 
   // Called each time the browser window is shown.
   void OnWindowDidShow();
 
@@ skipping 347 matching lines @@
 
   scoped_ptr<TabStripModelDelegate> tab_strip_model_delegate_;
   scoped_ptr<TabStripModel> tab_strip_model_;
 
   // The application name that is also the name of the window to the shell.
   // This name should be set when:
   // 1) we launch an application via an application shortcut or extension API.
   // 2) we launch an undocked devtool window.
   std::string app_name_;
 
-  // Type of app (host or child). See description of AppType.
-  AppType app_type_;
-
   // Unique identifier of this browser for session restore. This id is only
   // unique within the current session, and is not guaranteed to be unique
   // across sessions.
   const SessionID session_id_;
 
   // The model for the toolbar view.
   scoped_ptr<ToolbarModel> toolbar_model_;
 
   // The model for the "active" search state.  There are per-tab search models
   // as well.  When a tab is active its model is kept in sync with this one.
@@ skipping 91 matching lines @@
   base::WeakPtrFactory<Browser> weak_factory_;
 
   scoped_ptr<BrowserContentTranslateDriverObserver> translate_driver_observer_;
 
   scoped_ptr<chrome::ValidationMessageBubble> validation_message_bubble_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_