Re-land:

chrome/browser/ui/views/bubble/bubble.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/views/bubble/bubble.h"
 
 #include <vector>
 
 #include "chrome/browser/ui/views/bubble/border_contents.h"
 #include "content/common/notification_service.h"
@@ skipping 103 matching lines @@
   // Also fade in/out the bubble border window.
   border_->SetOpacity(opacity);
   border_->border_contents()->SchedulePaint();
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 Bubble::Bubble()
     :
+#if defined(OS_WIN)
+      views::WidgetWin(new views::Widget),
+#elif defined(TOOLKIT_USES_GTK)
+      views::WidgetGtk(new views::Widget),
+#endif
 #if defined(TOOLKIT_USES_GTK)
       border_contents_(NULL),
 #elif defined(OS_WIN)
       border_(NULL),
 #endif
       delegate_(NULL),
       show_status_(kOpen),
       fade_away_on_close_(false),
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
       type_(views::Widget::InitParams::TYPE_WINDOW),
 #endif
 #if defined(OS_CHROMEOS)
       show_while_screen_is_locked_(false),
 #endif
       arrow_location_(BubbleBorder::NONE),
       contents_(NULL) {
 }
 
 #if defined(OS_CHROMEOS)
 Bubble::Bubble(views::Widget::InitParams::Type type,
                bool show_while_screen_is_locked)
-    : border_contents_(NULL),
+    : views::WidgetGtk(new views::Widget),
+      border_contents_(NULL),
       delegate_(NULL),
       show_status_(kOpen),
       fade_away_on_close_(false),
       type_(type),
       show_while_screen_is_locked_(show_while_screen_is_locked),
       arrow_location_(BubbleBorder::NONE),
       contents_(NULL) {
 }
 #endif
 
 Bubble::~Bubble() {
 }
 
 void Bubble::InitBubble(views::Widget* parent,
                         const gfx::Rect& position_relative_to,
                         BubbleBorder::ArrowLocation arrow_location,
                         views::View* contents,
                         BubbleDelegate* delegate) {
   delegate_ = delegate;
   position_relative_to_ = position_relative_to;
   arrow_location_ = arrow_location;
   contents_ = contents;
 
   // Create the main window.
 #if defined(OS_WIN)
-  views::Window* parent_window = parent->GetWindow();
+  views::Window* parent_window = parent->GetContainingWindow();
   if (parent_window)
     parent_window->DisableInactiveRendering();
   set_window_style(WS_POPUP | WS_CLIPCHILDREN);
   int extended_style = WS_EX_TOOLWINDOW;
   // During FadeIn we need to turn on the layered window style to deal with
   // transparency. This flag needs to be reset after fading in is complete.
   bool fade_in = delegate_ && delegate_->FadeInOnShow();
   if (fade_in)
     extended_style |= WS_EX_LAYERED;
   set_window_ex_style(extended_style);
 
   DCHECK(!border_);
   border_ = new BorderWidgetWin();
 
   if (fade_in) {
     border_->SetOpacity(0);
-    SetOpacity(0);
+    GetWidget()->SetOpacity(0);
   }
 
   border_->InitBorderWidgetWin(CreateBorderContents(), parent->GetNativeView());
   border_->border_contents()->SetBackgroundColor(kBackgroundColor);
 
   // We make the BorderWidgetWin the owner of the Bubble HWND, so that the
   // latter is displayed on top of the former.
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.parent = border_->GetNativeView();
+  params.native_widget = this;
   GetWidget()->Init(params);
 
   SetWindowText(GetNativeView(), delegate_->accessible_name().c_str());
 #elif defined(TOOLKIT_USES_GTK)
   views::Widget::InitParams params(type_);
   params.transparent = true;
   params.parent_widget = parent;
-  // TODO(beng): Figure out how to make this implicit or set via InitParams.
-  make_transient_to_parent();
+  params.native_widget = this;
   GetWidget()->Init(params);
 #if defined(OS_CHROMEOS)
   {
     vector<int> params;
     params.push_back(show_while_screen_is_locked_ ? 1 : 0);
     chromeos::WmIpc::instance()->SetWindowType(
         GetNativeView(),
         chromeos::WM_IPC_WINDOW_CHROME_INFO_BUBBLE,
         &params);
   }
 #endif
 #endif
 
   // Create a View to hold the contents of the main window.
   views::View* contents_view = new views::View;
   // We add |contents_view| to ourselves before the AddChildView() call below so
   // that when |contents| gets added, it will already have a widget, and thus
   // any NativeButtons it creates in ViewHierarchyChanged() will be functional
   // (e.g. calling SetChecked() on checkboxes is safe).
-  SetContentsView(contents_view);
+  GetWidget()->SetContentsView(contents_view);
   // Adding |contents| as a child has to be done before we call
   // contents->GetPreferredSize() below, since some supplied views don't
   // actually initialize themselves until they're added to a hierarchy.
   contents_view->AddChildView(contents);
 
   // Calculate and set the bounds for all windows and views.
   gfx::Rect window_bounds;
 
 #if defined(OS_WIN)
   // Initialize and position the border window.
@@ skipping 18 matching lines @@
       &contents_bounds, &window_bounds);
   // This new view must be added before |contents| so it will paint under it.
   contents_view->AddChildViewAt(border_contents_, 0);
 
   // |contents_view| has no layout manager, so we have to explicitly position
   // its children.
   border_contents_->SetBoundsRect(
       gfx::Rect(gfx::Point(), window_bounds.size()));
   contents->SetBoundsRect(contents_bounds);
 #endif
-  SetBounds(window_bounds);
+  GetWidget()->SetBounds(window_bounds);
 
   // Register the Escape accelerator for closing.
-  GetFocusManager()->RegisterAccelerator(
+  GetWidget()->GetFocusManager()->RegisterAccelerator(
       views::Accelerator(ui::VKEY_ESCAPE, false, false, false), this);
 
   // Done creating the bubble.
   NotificationService::current()->Notify(NotificationType::INFO_BUBBLE_CREATED,
                                          Source<Bubble>(this),
                                          NotificationService::NoDetails());
 
   // Show the window.
 #if defined(OS_WIN)
   border_->ShowWindow(SW_SHOW);
   ShowWindow(SW_SHOW);
   if (fade_in)
     FadeIn();
 #elif defined(TOOLKIT_USES_GTK)
-  views::WidgetGtk::Show();
+  GetWidget()->Show();
 #endif
 }
 
 BorderContents* Bubble::CreateBorderContents() {
   return new BorderContents();
 }
 
 void Bubble::SizeToContents() {
   gfx::Rect window_bounds;
 
 #if defined(OS_WIN)
   // Initialize and position the border window.
   window_bounds = border_->SizeAndGetBounds(position_relative_to_,
                                             arrow_location_,
                                             contents_->GetPreferredSize());
 #else
   gfx::Rect contents_bounds;
   border_contents_->SizeAndGetBounds(position_relative_to_,
       arrow_location_, false, contents_->GetPreferredSize(),
       &contents_bounds, &window_bounds);
   // |contents_view| has no layout manager, so we have to explicitly position
   // its children.
   border_contents_->SetBoundsRect(
       gfx::Rect(gfx::Point(), window_bounds.size()));
   contents_->SetBoundsRect(contents_bounds);
 #endif
-  SetBounds(window_bounds);
+  GetWidget()->SetBounds(window_bounds);
 }
 
 #if defined(OS_WIN)
 void Bubble::OnActivate(UINT action, BOOL minimized, HWND window) {
   // The popup should close when it is deactivated.
   if (action == WA_INACTIVE) {
-    Close();
+    GetWidget()->Close();
   } else if (action == WA_ACTIVE) {
-    DCHECK(GetRootView()->has_children());
-    GetRootView()->GetChildViewAt(0)->RequestFocus();
+    DCHECK(GetWidget()->GetRootView()->has_children());
+    GetWidget()->GetRootView()->GetChildViewAt(0)->RequestFocus();
   }
 }
 #elif defined(TOOLKIT_USES_GTK)
 void Bubble::IsActiveChanged() {
-  if (!IsActive())
-    Close();
+  if (!GetWidget()->IsActive())
+    GetWidget()->Close();
 }
 #endif
 
 void Bubble::DoClose(bool closed_by_escape) {
   if (show_status_ == kClosed)
     return;
 
-  GetFocusManager()->UnregisterAccelerator(
+  GetWidget()->GetFocusManager()->UnregisterAccelerator(
       views::Accelerator(ui::VKEY_ESCAPE, false, false, false), this);
   if (delegate_)
     delegate_->BubbleClosing(this, closed_by_escape);
   show_status_ = kClosed;
 #if defined(OS_WIN)
   border_->Close();
+#endif
+#if defined(OS_WIN)
   WidgetWin::Close();
 #elif defined(TOOLKIT_USES_GTK)
   WidgetGtk::Close();
 #endif
 }
 
 void Bubble::FadeIn() {
   Fade(true);  // |fade_in|.
 }
 
@@ skipping 23 matching lines @@
     animation_->Hide();
 }
 
 bool Bubble::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!delegate_ || delegate_->CloseOnEscape()) {
     DoClose(true);
     return true;
   }
   return false;
 }