Make the views bookmark bubble work on GTK....

chrome/browser/views/info_bubble.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/views/info_bubble.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/resource_bundle.h"
 #include "chrome/browser/browser_window.h"
@@ skipping 111 matching lines @@
   set_window_style(WS_POPUP | WS_CLIPCHILDREN);
   set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW);
   // Because we're going to change the alpha value of the layered window we
   // don't want to use the offscreen buffer provided by WidgetWin.
   SetUseLayeredBuffer(false);
   set_initial_class_style(
       (win_util::GetWinVersion() < win_util::WINVERSION_XP) ?
       0 : CS_DROPSHADOW);
 #endif
   content_view_ = CreateContentView(content);
-  gfx::Rect bounds =
-      content_view_->CalculateWindowBoundsAndAjust(position_relative_to);
 
 #if defined(OS_WIN)
-  WidgetWin::Init(parent->GetNativeWindow(), bounds);
+  WidgetWin::Init(parent->GetNativeWindow(), gfx::Rect());
 #else
-  WidgetGtk::Init(GTK_WIDGET(parent->GetNativeWindow()), bounds);
+  WidgetGtk::Init(GTK_WIDGET(parent->GetNativeWindow()), gfx::Rect());
 #endif
+
   SetContentsView(content_view_);
   // The preferred size may differ when parented. Ask for the bounds again
   // and if they differ reset the bounds.
   gfx::Rect parented_bounds =
       content_view_->CalculateWindowBoundsAndAjust(position_relative_to);
 
-  if (bounds != parented_bounds) {
+  // TODO(beng): This should be done in a cleaner and cross-platform way.
 #if defined(OS_WIN)
-    SetWindowPos(NULL, parented_bounds.x(), parented_bounds.y(),
-                 parented_bounds.width(), parented_bounds.height(),
-                 SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOZORDER);
-    // Invoke ChangeSize, otherwise layered window isn't updated correctly.
-    ChangeSize(0, CSize(parented_bounds.width(), parented_bounds.height()));
+  SetWindowPos(NULL, parented_bounds.x(), parented_bounds.y(),
+               parented_bounds.width(), parented_bounds.height(),
+               SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOZORDER);
+  // Invoke ChangeSize, otherwise layered window isn't updated correctly.
+  ChangeSize(0, CSize(parented_bounds.width(), parented_bounds.height()));
+#else
+  SetBounds(parented_bounds);
 #endif
-  }
 
 #if defined(OS_WIN)
   // Register the Escape accelerator for closing.
   GetFocusManager()->RegisterAccelerator(views::Accelerator(VK_ESCAPE, false,
                                                             false, false),
                                          this);
   // Set initial alpha value of the layered window.
   SetLayeredWindowAttributes(GetNativeView(),
                              RGB(0xFF, 0xFF, 0xFF),
                              kMinimumAlpha,
@@ skipping 41 matching lines @@
   // The popup should close when it is deactivated.
   if (action == WA_INACTIVE && !closed_) {
     Close();
   } else if (action == WA_ACTIVE) {
     DCHECK(GetRootView()->GetChildViewCount() > 0);
     GetRootView()->GetChildViewAt(0)->RequestFocus();
   }
 }
 
 void InfoBubble::OnSize(UINT param, const CSize& size) {
+  // See OnSizeAllocate for the Linux version.
   gfx::Path path;
   content_view_->GetMask(gfx::Size(size.cx, size.cy), &path);
   SetWindowRgn(path.CreateHRGN(), TRUE);
   WidgetWin::OnSize(param, size);
 }
 #endif
 
 InfoBubble::ContentView* InfoBubble::CreateContentView(View* content) {
   return new ContentView(content, this);
 }
 
 void InfoBubble::Close(bool closed_by_escape) {
   if (closed_)
     return;
 
   // We don't fade out because it looks terrible.
   if (delegate_)
     delegate_->InfoBubbleClosing(this, closed_by_escape);
   closed_ = true;
 #if defined(OS_WIN)
   WidgetWin::Close();
 #else
   WidgetGtk::Close();
 #endif
 }
 
+#if defined(OS_LINUX)
+void InfoBubble::OnSizeAllocate(GtkWidget* widget, GtkAllocation* allocation) {
+  gfx::Path path;
+  content_view_->GetMask(gfx::Size(allocation->width, allocation->height),
+                         &path);
+  SetShape(path);
+  WidgetGtk::OnSizeAllocate(widget, allocation);
+}
+#endif
+
 // ContentView ----------------------------------------------------------------
 
 InfoBubble::ContentView::ContentView(views::View* content, InfoBubble* host)
-    : host_(host) {
+    : content_(content),
+      host_(host) {
   if (UILayoutIsRightToLeft()) {
     arrow_edge_ = TOP_RIGHT;
   } else {
     arrow_edge_ = TOP_LEFT;
   }
-  AddChildView(content);
 }
 
 gfx::Rect InfoBubble::ContentView::CalculateWindowBoundsAndAjust(
     const gfx::Rect& position_relative_to) {
   scoped_ptr<WindowSizer::MonitorInfoProvider> monitor_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   gfx::Rect monitor_bounds(
       monitor_provider->GetMonitorWorkAreaMatching(position_relative_to));
   // Calculate the bounds using TOP_LEFT (the default).
   gfx::Rect window_bounds = CalculateWindowBounds(position_relative_to);
@@ skipping 170 matching lines @@
     canvas->FillRectInt(kBorderColor1, arrow_x + (kArrowSize - i), y, 1, 1);
     if (i != 0) {
       canvas->FillRectInt(kBorderColor2, arrow_x - (kArrowSize - i) - 1, y, 1,
                           1);
       canvas->FillRectInt(kBorderColor2, arrow_x + (kArrowSize - i) + 1, y, 1,
                           1);
     }
   }
 }
 
+void InfoBubble::ContentView::ViewHierarchyChanged(bool is_add,
+                                                   View* parent,
+                                                   View* child) {
+  if (is_add && child == this)
+    AddChildView(content_);
+}
+
 gfx::Rect InfoBubble::ContentView::CalculateWindowBounds(
     const gfx::Rect& position_relative_to) {
   gfx::Size pref = GetPreferredSize();
   int x = position_relative_to.x() + position_relative_to.width() / 2;
   int y;
   if (IsLeft())
     x -= kArrowXOffset;
   else
     x = x + kArrowXOffset - pref.width();
   if (IsTop()) {
     y = position_relative_to.bottom() + kArrowToContentPadding;
   } else {
     y = position_relative_to.y() - kArrowToContentPadding - pref.height();
   }
   return gfx::Rect(x, y, pref.width(), pref.height());
 }