[Panel refactor] Deprecate old panels.

chrome/browser/ui/panels/panel.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_PANELS_PANEL_H_
 #define CHROME_BROWSER_UI_PANELS_PANEL_H_
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/base_window.h"
 #include "chrome/browser/ui/panels/panel_constants.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/gfx/rect.h"
 
-class Browser;
-class BrowserWindow;
 class GURL;
 class NativePanel;
 class PanelHost;
 class PanelManager;
 class PanelStrip;
 class Profile;
 
 namespace content {
 class WebContents;
 struct NativeWebKeyboardEvent;
@@ skipping 45 matching lines @@
   // Returns the PanelManager associated with this panel.
   PanelManager* manager() const;
 
   const std::string& app_name() const { return app_name_; }
   const SessionID& session_id() const { return session_id_; }
   extensions::WindowController* extension_window_controller() const {
     return extension_window_controller_.get();
   }
   const std::string extension_id() const;
 
-  virtual CommandUpdater* command_updater();
-  virtual Profile* profile() const;
+  CommandUpdater* command_updater();
+  Profile* profile() const;
 
   // Returns web contents of the panel, if any. There may be none if web
   // contents have not been added to the panel yet.
-  virtual content::WebContents* GetWebContents() const;
+  content::WebContents* GetWebContents() const;
 
   void SetExpansionState(ExpansionState new_expansion_state);
 
   bool IsDrawingAttention() const;
 
   // This function will only get called by PanelManager when full screen mode
   // changes i.e it gets called when an app goes into full screen mode or when
   // an app exits full screen mode. Panel should respond by making sure
   // a) it does not go on top when some app enters full screen mode.
   // b) it remains on top when an app exits full screen mode.
@@ skipping 33 matching lines @@
   // Overridden from CommandUpdater::CommandUpdaterDelegate:
   virtual void ExecuteCommandWithDisposition(
       int id,
       WindowOpenDisposition disposition) OVERRIDE;
 
   // content::NotificationObserver overrides.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  // Construct a native panel BrowserWindow implementation for the specified
-  // |browser|. (legacy)
-  static NativePanel* CreateNativePanel(Browser* browser,
-                                        Panel* panel,
-                                        const gfx::Rect& bounds);
-
   // Construct a native panel implementation.
   static NativePanel* CreateNativePanel(Panel* panel,
                                         const gfx::Rect& bounds);
 
   NativePanel* native_panel() const { return native_panel_; }
 
   // Invoked when the native panel has detected a mouse click on the
   // panel's titlebar, minimize or restore buttons. Behavior of the
   // click may be modified as indicated by |modifier|.
   void OnTitlebarClicked(panel::ClickModifier modifier);
   void OnMinimizeButtonClicked(panel::ClickModifier modifier);
   void OnRestoreButtonClicked(panel::ClickModifier modifier);
 
   // Used on platforms where the panel cannot determine its window size
   // until the window has been created. (e.g. GTK)
   void OnWindowSizeAvailable();
 
   // Asynchronous completion of panel close request.
   void OnNativePanelClosed();
 
-  // Legacy accessors.
-  virtual Browser* browser() const;
-  virtual BrowserWindow* browser_window() const;
-
   // May be NULL if:
   // * panel is newly created and has not been positioned yet.
   // * panel is being closed asynchronously.
   // Please use it with caution.
   PanelStrip* panel_strip() const { return panel_strip_; }
 
   // Sets the current panel strip that contains this panel.
   void set_panel_strip(PanelStrip* new_strip) { panel_strip_ = new_strip; }
 
   ExpansionState expansion_state() const { return expansion_state_; }
@@ skipping 11 matching lines @@
   }
 
   // The full size is the size of the panel when it is detached or expanded
   // in the docked strip and squeezing mode is not on.
   gfx::Size full_size() const { return full_size_; }
   void set_full_size(const gfx::Size& size) { full_size_ = size; }
 
   // Panel must be initialized to be "fully created" and ready for use.
   // Only called by PanelManager.
   bool initialized() const { return initialized_; }
-  virtual void Initialize(const gfx::Rect& bounds, Browser* browser);  // legacy
-  virtual void Initialize(Profile* profile, const GURL& url,
-                          const gfx::Rect& bounds);
+  void Initialize(Profile* profile, const GURL& url, const gfx::Rect& bounds);
 
-  // This is different from BrowserWindow::SetBounds():
+  // This is different from BaseWindow::SetBounds():
   // * SetPanelBounds() is only called by PanelManager to manage its position.
-  // * SetBounds() is called by the API to try to change the bounds, which is
-  //   not allowed for Panel.
+  // * SetBounds() is called by the API to try to change the bounds, which may
+  //   only change the size for Panel.
   void SetPanelBounds(const gfx::Rect& bounds);
 
   // Updates the panel bounds instantly without any animation.
   void SetPanelBoundsInstantly(const gfx::Rect& bounds);
 
   // Ensures that the panel's size does not exceed the display area by
   // updating maximum and full size of the panel. This is called each time
   // when display settings are changed. Note that bounds are not updated here
   // and the call of setting bounds or refreshing layout should be called after
   // this.
@@ skipping 47 matching lines @@
 
   // Called when the panel's active state changes.
   // |active| is true if panel became active.
   void OnActiveStateChanged(bool active);
 
   // Called when the panel starts/ends the user resizing.
   void OnPanelStartUserResizing();
   void OnPanelEndUserResizing();
 
   // Gives beforeunload handlers the chance to cancel the close.
-  virtual bool ShouldCloseWindow();
+  bool ShouldCloseWindow();
 
   // Invoked when the window containing us is closing. Performs the necessary
   // cleanup.
-  virtual void OnWindowClosing();
+  void OnWindowClosing();
 
   // Executes a command if it's enabled.
   // Returns true if the command is executed.
   bool ExecuteCommandIfEnabled(int id);
 
   // Gets the title of the window from the web contents.
   string16 GetWindowTitle() const;
 
   // Gets the Favicon of the web contents.
-  virtual gfx::Image GetCurrentPageIcon() const;
+  gfx::Image GetCurrentPageIcon() const;
 
   // Updates the title bar to display the current title and icon.
   void UpdateTitleBar();
 
   // Updates UI to reflect change in loading state.
   void LoadingStateChanged(bool is_loading);
 
   // Updates UI to reflect that the web cotents receives the focus.
   void WebContentsFocused(content::WebContents* contents);
 
  protected:
   // Panel can only be created using PanelManager::CreatePanel() or subclass.
   // |app_name| is the default title for Panels when the page content does not
   // provide a title. For extensions, this is usually the application name
   // generated from the extension id.
   Panel(const std::string& app_name,
         const gfx::Size& min_size, const gfx::Size& max_size);
 
  private:
   friend class PanelManager;
   friend class PanelBrowserTest;
-  friend class OldPanelBrowserTest;
 
   enum MaxSizePolicy {
     // Default maximum size is proportional to the work area.
     DEFAULT_MAX_SIZE,
     // Custom maximum size is used when the panel is resized by the user.
     CUSTOM_MAX_SIZE
   };
 
   // Initialize state for all supported commands.
   void InitCommandState();
@@ skipping 36 matching lines @@
   // True if this panel should always stay on top of other windows.
   bool always_on_top_;
 
   // True if this panel is in preview mode. When in preview mode, panel bounds
   // should not be affected by layout refresh. This is currently used by drag
   // controller to add a panel to the strip without causing its bounds to
   // change.
   bool in_preview_mode_;
 
   // Platform specifc implementation for panels.  It'd be one of
-  // PanelBrowserWindowGtk/PanelBrowserView/PanelBrowserWindowCocoa.
+  // PanelGtk/PanelView/PanelCocoa.
   NativePanel* native_panel_;  // Weak, owns us.
 
   AttentionMode attention_mode_;
 
   ExpansionState expansion_state_;
 
   // The CommandUpdater manages the window commands.
   CommandUpdater command_updater_;
 
   content::NotificationRegistrar registrar_;
   const SessionID session_id_;
   scoped_ptr<extensions::WindowController> extension_window_controller_;
   scoped_ptr<PanelHost> panel_host_;
 
   DISALLOW_COPY_AND_ASSIGN(Panel);
 };
 
 #endif  // CHROME_BROWSER_UI_PANELS_PANEL_H_