Fix Panel to always detect when a tab is added.

chrome/browser/ui/panels/panel.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include "chrome/browser/ui/browser_window.h"
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "chrome/browser/tabs/tab_strip_model_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/gfx/rect.h"
 
 class NativePanel;
 class PanelManager;
 class RenderViewHost;
 
 // A platform independent implementation of BrowserWindow for Panels.  This
 // class would get the first crack at all the BrowserWindow calls for Panels and
 // do one or more of the following:
 // - Do nothing.  The function is not relevant to Panels.
 // - Throw an exceptions.  The function shouldn't be called for Panels.
 // - Do Panel specific platform independent processing and then invoke the
 //   function on the platform specific BrowserWindow member.  For example,
 //   Panel size is restricted to certain limits.
 // - Invoke an appropriate PanelManager function to do stuff that might affect
 //   other Panels.  For example deleting a panel would rearrange other panels.
-class Panel : public BrowserWindow, public content::NotificationObserver {
+class Panel : public BrowserWindow,
+              public TabStripModelObserver,
+              public content::NotificationObserver {
  public:
   enum ExpansionState {
    // The panel is fully expanded with both title-bar and the client-area.
    EXPANDED,
    // The panel is shown with the title-bar only.
    TITLE_ONLY,
    // The panel is shown with 3-pixel line.
    MINIMIZED
   };
 
@@ skipping 120 matching lines @@
 #if defined(OS_CHROMEOS)
   virtual void ShowMobileSetup() OVERRIDE;
   virtual void ShowKeyboardOverlay(gfx::NativeWindow owning_window) OVERRIDE;
 #endif
   virtual void UpdatePreferredSize(TabContents* tab_contents,
                                    const gfx::Size& pref_size) OVERRIDE;
   virtual void ShowAvatarBubble(TabContents* tab_contents,
                                 const gfx::Rect& rect) OVERRIDE;
   virtual void ShowAvatarBubbleFromAvatarButton() OVERRIDE;
 
+  // TabStripModelObserver overrides.
+  virtual void TabInsertedAt(TabContentsWrapper* contents,
+                             int index,
+                             bool foreground) 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|.
   static NativePanel* CreateNativePanel(Browser* browser,
                                         Panel* panel,
                                         const gfx::Rect& bounds);
 
   // Gets the extension from the browser that a panel is created from.
   // Returns NULL if it cannot be found.
   static const Extension* GetExtensionFromBrowser(Browser* browser);
 
   // 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();
+
   NativePanel* native_panel() { return native_panel_; }
   Browser* browser() const;
   ExpansionState expansion_state() const { return expansion_state_; }
   const gfx::Size& min_size() const { return min_size_; }
   const gfx::Size& max_size() const { return max_size_; }
 
  protected:
   virtual void DestroyBrowser() OVERRIDE;
 
  private:
   friend class PanelManager;
   friend class PanelBrowserTest;
   FRIEND_TEST_ALL_PREFIXES(PanelBrowserTest, RestoredBounds);
 
   // Panel can only be created using PanelManager::CreatePanel().
   Panel(Browser* browser, const gfx::Rect& bounds);
 
   // This is different from BrowserWindow::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.
   void SetPanelBounds(const gfx::Rect& bounds);
 
   // Updates the maximum size.
   void SetMaxSize(const gfx::Size& max_size);
 
   // NULL might be returned if the tab has not been added.
   RenderViewHost* GetRenderViewHost() const;
 
+  void EnableAutoResize(RenderViewHost* render_view_host);
+
   // Requests RenderViewHost not to show the scrollbars till |max_size_| since
   // the panel can grow to |max_size_|.
   void RequestRenderViewHostToDisableScrollbars(
       RenderViewHost* render_view_host);
 
   // This is the minimum size that the panel can shrink to.
   gfx::Size min_size_;
 
   // This is the size beyond which the panel is not going to grow to accomodate
   // the growing content and WebKit would add the scrollbars in such case.
   gfx::Size max_size_;
 
   // Platform specifc implementation for panels.  It'd be one of
   // PanelBrowserWindowGtk/PanelBrowserView/PanelBrowserWindowCocoa.
   NativePanel* native_panel_;  // Weak, owns us.
 
   ExpansionState expansion_state_;
 
   // Stores the full height of the panel so we can restore it after it's
   // been minimized.
   int restored_height_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(Panel);
 };
 
 #endif  // CHROME_BROWSER_UI_PANELS_PANEL_H_