Make panel adjust bounds per preferred size change notification on Windows.

chrome/browser/ui/panels/panel.cc

 // 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.
 
 #include "chrome/browser/ui/panels/panel.h"
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/native_panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/extensions/extension.h"
+#include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/content_notification_types.h"
+#include "content/common/view_messages.h"
 #include "ui/gfx/rect.h"
 
 // static
 const Extension* Panel::GetExtension(Browser* browser) {
   // Find the extension. When we create a panel from an extension, the extension
   // ID is passed as the app name to the Browser.
   ExtensionService* extension_service =
       browser->GetProfile()->GetExtensionService();
   return extension_service->GetExtensionById(
       web_app::GetExtensionIdFromApplicationName(browser->app_name()), false);
 }
 
 Panel::Panel(Browser* browser, const gfx::Rect& bounds)
-    : native_panel_(NULL),
+    : min_size_(bounds.size()),
+      max_size_(bounds.size()),
+      native_panel_(NULL),
       expansion_state_(EXPANDED) {
   native_panel_ = CreateNativePanel(browser, this, bounds);
+
+  registrar_.Add(this,
+                 content::NOTIFICATION_TAB_ADDED,
+                 Source<TabContentsDelegate>(browser));
 }
 
 Panel::~Panel() {
   // Invoked by native panel so do not access native_panel_ here.
 }
 
 PanelManager* Panel::manager() const {
   return PanelManager::GetInstance();
 }
 
 void Panel::SetPanelBounds(const gfx::Rect& bounds) {
   native_panel_->SetPanelBounds(bounds);
 }
 
+void Panel::SetMaxSize(const gfx::Size& max_size) {
+  if (max_size_ == max_size)
+    return;
+  max_size_ = max_size;
+
+  // Note: |render_view_host| might be NULL if the tab has not been created.
+  // If so, we will do it when NOTIFICATION_TAB_ADDED is received.
+  RenderViewHost* render_view_host = GetRenderViewHost();
+  if (render_view_host)
+    RequestRenderViewHostToDisableScrollbars(render_view_host);
+}
+
 void Panel::SetExpansionState(ExpansionState new_expansion_state) {
   if (expansion_state_ == new_expansion_state)
     return;
 
   expansion_state_ = new_expansion_state;
 
   native_panel_->OnPanelExpansionStateChanged(expansion_state_);
 
   // The minimized panel should not get the focus.
   if (expansion_state_ == MINIMIZED)
@@ skipping 11 matching lines @@
     return true;
 
   // Let the native panel decide.
   return native_panel_->ShouldBringUpPanelTitlebar(mouse_x, mouse_y);
 }
 
 bool Panel::IsDrawingAttention() const {
   return native_panel_->IsDrawingAttention();
 }
 
+int Panel::GetRestoredHeight() const {
+  return native_panel_->GetRestoredHeight();
+}
+
+void Panel::SetRestoredHeight(int height) {
+  native_panel_->SetRestoredHeight(height);
+}
+
 void Panel::Show() {
   native_panel_->ShowPanel();
 }
 
 void Panel::ShowInactive() {
   native_panel_->ShowPanelInactive();
 }
 
 void Panel::SetBounds(const gfx::Rect& bounds) {
   // Ignore any SetBounds requests since the bounds are completely controlled
@@ skipping 350 matching lines @@
 FindBar* Panel::CreateFindBar() {
   return native_panel_->CreatePanelFindBar();
 }
 
 #if defined(OS_CHROMEOS)
 void Panel::ShowKeyboardOverlay(gfx::NativeWindow owning_window) {
   NOTIMPLEMENTED();
 }
 #endif
 
+void Panel::UpdatePreferredSize(TabContents* tab_contents,
+                                const gfx::Size& pref_size) {
+  gfx::Size non_client_size = native_panel_->GetNonClientAreaExtent();
+  return manager()->OnPreferredWindowSizeChanged(this,
+      gfx::Size(pref_size.width() + non_client_size.width(),
+                pref_size.height() + non_client_size.height()));
+}
+
+void Panel::Observe(int type,
+                    const NotificationSource& source,
+                    const NotificationDetails& details) {
+  switch (type) {
+    case content::NOTIFICATION_TAB_ADDED:
+    case content::NOTIFICATION_TAB_CONTENTS_SWAPPED: {
+      RenderViewHost* render_view_host = GetRenderViewHost();
+      DCHECK(render_view_host);
+      render_view_host->Send(new ViewMsg_EnablePreferredSizeChangedMode(
+          render_view_host->routing_id(),
+          kPreferredSizeWidth | kPreferredSizeHeightThisIsSlow));
+      RequestRenderViewHostToDisableScrollbars(render_view_host);
+      break;
+    }
+    default:
+      NOTREACHED() << "Got a notification we didn't register for!";
+      break;
+  }
+}
+
+RenderViewHost* Panel::GetRenderViewHost() const {
+  TabContents* tab_contents = browser()->GetSelectedTabContents();
+  if (!tab_contents)
+    return NULL;
+  return tab_contents->render_view_host();
+}
+
+void Panel::RequestRenderViewHostToDisableScrollbars(
+    RenderViewHost* render_view_host) {
+  DCHECK(render_view_host);
+
+  gfx::Size non_client_size = native_panel_->GetNonClientAreaExtent();
+  render_view_host->Send(new ViewMsg_DisableScrollbarsForSmallWindows(
+      render_view_host->routing_id(),
+      gfx::Size(max_size_.width() - non_client_size.width(),
+                max_size_.height() - non_client_size.height())));
+}
+
 Browser* Panel::browser() const {
   return native_panel_->GetPanelBrowser();
 }
 
 void Panel::DestroyBrowser() {
   native_panel_->DestroyPanelBrowser();
 }