Re-reland Propagate OnNativeWidgetMove to delegate/observers, etc.

ui/views/bubble/bubble_delegate.cc

 // 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.
 
 #include "ui/views/bubble/bubble_delegate.h"
 
 #include "ui/base/animation/slide_animation.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/widget/widget.h"
 
 // The duration of the fade animation in milliseconds.
 static const int kHideFadeDurationMS = 200;
 
 // The defaut margin between the content and the inside border, in pixels.
 static const int kDefaultMargin = 6;
 
 namespace views {
 
 namespace {
 
 // Create a widget to host the bubble.
-Widget* CreateBubbleWidget(BubbleDelegateView* bubble, Widget* parent) {
+Widget* CreateBubbleWidget(BubbleDelegateView* bubble) {
   Widget* bubble_widget = new Widget();
   Widget::InitParams bubble_params(Widget::InitParams::TYPE_BUBBLE);
   bubble_params.delegate = bubble;
   bubble_params.transparent = true;
   if (bubble->parent_window())
     bubble_params.parent = bubble->parent_window();
   else
-    bubble_params.parent_widget = parent;
+    bubble_params.parent_widget = bubble->anchor_widget();
   if (bubble->use_focusless())
     bubble_params.can_activate = false;
 #if defined(OS_WIN) && !defined(USE_AURA)
   bubble_params.type = Widget::InitParams::TYPE_WINDOW_FRAMELESS;
   bubble_params.transparent = false;
 #endif
   bubble_widget->Init(bubble_params);
   return bubble_widget;
 }
 
@@ skipping 32 matching lines @@
   }
 
  private:
   BubbleDelegateView* bubble_;
   Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleBorderDelegate);
 };
 
 // Create a widget to host the bubble's border.
-Widget* CreateBorderWidget(BubbleDelegateView* bubble, Widget* parent) {
+Widget* CreateBorderWidget(BubbleDelegateView* bubble) {
   Widget* border_widget = new Widget();
   Widget::InitParams border_params(Widget::InitParams::TYPE_BUBBLE);
   border_params.delegate = new BubbleBorderDelegate(bubble, border_widget);
   border_params.transparent = true;
-  border_params.parent_widget = parent;
+  border_params.parent_widget = bubble->anchor_widget();
   border_widget->Init(border_params);
   return border_widget;
 }
 #endif
 
 }  // namespace
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 const SkColor BubbleDelegateView::kBackgroundColor =
     color_utils::GetSysSkColor(COLOR_WINDOW);
 #else
 // TODO(beng): source from theme provider.
 const SkColor BubbleDelegateView::kBackgroundColor = SK_ColorWHITE;
 #endif
 
 BubbleDelegateView::BubbleDelegateView()
     : close_on_esc_(true),
       close_on_deactivate_(true),
       anchor_view_(NULL),
+      anchor_widget_(NULL),
+      move_with_anchor_(false),
       arrow_location_(BubbleBorder::TOP_LEFT),
       color_(kBackgroundColor),
       margin_(kDefaultMargin),
       original_opacity_(255),
       border_widget_(NULL),
       use_focusless_(false),
       parent_window_(NULL) {
   set_background(views::Background::CreateSolidBackground(color_));
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, 0));
 }
 
 BubbleDelegateView::BubbleDelegateView(
     View* anchor_view,
     BubbleBorder::ArrowLocation arrow_location)
     : close_on_esc_(true),
       close_on_deactivate_(true),
       anchor_view_(anchor_view),
+      anchor_widget_(NULL),
+      move_with_anchor_(false),
       arrow_location_(arrow_location),
       color_(kBackgroundColor),
       margin_(kDefaultMargin),
       original_opacity_(255),
       border_widget_(NULL),
       use_focusless_(false),
       parent_window_(NULL) {
   set_background(views::Background::CreateSolidBackground(color_));
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, 0));
 }
 
 BubbleDelegateView::~BubbleDelegateView() {}
 
 // static
 Widget* BubbleDelegateView::CreateBubble(BubbleDelegateView* bubble_delegate) {
   bubble_delegate->Init();
-  Widget* parent = bubble_delegate->anchor_view() ?
+  // Determine the anchor widget from the anchor view at bubble creation time.
+  bubble_delegate->anchor_widget_ = bubble_delegate->anchor_view() ?
       bubble_delegate->anchor_view()->GetWidget() : NULL;
-  Widget* bubble_widget = CreateBubbleWidget(bubble_delegate, parent);
+  Widget* bubble_widget = CreateBubbleWidget(bubble_delegate);
 
 #if defined(OS_WIN) && !defined(USE_AURA)
   // First set the contents view to initialize view bounds for widget sizing.
   bubble_widget->SetContentsView(bubble_delegate->GetContentsView());
-  bubble_delegate->border_widget_ = CreateBorderWidget(bubble_delegate, parent);
+  bubble_delegate->border_widget_ = CreateBorderWidget(bubble_delegate);
 #endif
 
   bubble_delegate->SizeToContents();
   bubble_widget->AddObserver(bubble_delegate);
   return bubble_widget;
 }
 
 View* BubbleDelegateView::GetInitiallyFocusedView() {
   return this;
 }
 
 BubbleDelegateView* BubbleDelegateView::AsBubbleDelegate() {
   return this;
 }
 
 View* BubbleDelegateView::GetContentsView() {
   return this;
 }
 
 NonClientFrameView* BubbleDelegateView::CreateNonClientFrameView(
     Widget* widget) {
   return new BubbleFrameView(arrow_location(), color(), margin());
 }
 
+void BubbleDelegateView::OnWidgetClosing(Widget* widget) {
+  if (anchor_widget() == widget) {
+    anchor_view_ = NULL;
+    anchor_widget_ = NULL;
+  }
+}
+
 void BubbleDelegateView::OnWidgetVisibilityChanged(Widget* widget,
                                                    bool visible) {
-  if (widget == GetWidget()) {
-    if (visible) {
-      if (border_widget_)
-        border_widget_->Show();
-      GetFocusManager()->SetFocusedView(GetInitiallyFocusedView());
-      Widget* anchor_widget = anchor_view() ? anchor_view()->GetWidget() : NULL;
-      if (anchor_widget && anchor_widget->GetTopLevelWidget())
-        anchor_widget->GetTopLevelWidget()->DisableInactiveRendering();
-    } else if (border_widget_) {
+  if (widget != GetWidget())
+    return;
+
+  if (visible) {
+    if (border_widget_)
+      border_widget_->Show();
+    if (anchor_widget())
+      anchor_widget()->AddObserver(this);
+    GetFocusManager()->SetFocusedView(GetInitiallyFocusedView());
+    if (anchor_widget() && anchor_widget()->GetTopLevelWidget())
+      anchor_widget()->GetTopLevelWidget()->DisableInactiveRendering();
+  } else {
+    if (border_widget_)
       border_widget_->Hide();
-    }
+    if (anchor_widget())
+      anchor_widget()->RemoveObserver(this);
   }
 }
 
 void BubbleDelegateView::OnWidgetActivationChanged(Widget* widget,
                                                    bool active) {
   if (close_on_deactivate() && widget == GetWidget() && !active)
     GetWidget()->Close();
 }
 
+void BubbleDelegateView::OnWidgetMoved(Widget* widget) {
+  if (move_with_anchor() && anchor_widget() == widget)
+    SizeToContents();
+}
+
 gfx::Rect BubbleDelegateView::GetAnchorRect() {
   return anchor_view() ? anchor_view()->GetScreenBounds() : gfx::Rect();
 }
 
 void BubbleDelegateView::Show() {
   GetWidget()->Show();
 }
 
 void BubbleDelegateView::StartFade(bool fade_in) {
   fade_animation_.reset(new ui::SlideAnimation(this));
@@ skipping 97 matching lines @@
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 gfx::Rect BubbleDelegateView::GetBubbleClientBounds() const {
   gfx::Rect client_bounds(GetBubbleFrameView()->GetBoundsForClientView());
   client_bounds.Offset(border_widget_->GetWindowScreenBounds().origin());
   return client_bounds;
 }
 #endif
 
 }  // namespace views