Make tooltips toplevel windows on Linux

ui/views/corewm/tooltip_aura.cc

 // Copyright 2013 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/corewm/tooltip_aura.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
@@ skipping 129 matching lines @@
       *width = std::max(*width, line_width);
       result.append(*l);
     }
   }
   *text = result;
 }
 
 int TooltipAura::GetMaxWidth(const gfx::Point& location) const {
   // TODO(varunjain): implementation duplicated in tooltip_manager_aura. Figure
   // out a way to merge.
-  gfx::Rect display_bounds = GetBoundsForTooltip(location);
+  gfx::Screen* screen = gfx::Screen::GetScreenByType(screen_type_);
+  gfx::Rect display_bounds(screen->GetDisplayNearestPoint(location).bounds());
   return (display_bounds.width() + 1) / 2;
 }
 
-gfx::Rect TooltipAura::GetBoundsForTooltip(
-    const gfx::Point& origin) const {
-  DCHECK(tooltip_window_);
-  gfx::Rect widget_bounds;
-  // For Desktop aura we constrain the tooltip to the bounds of the Widget
-  // (which comes from the RootWindow).
-  if (screen_type_ == gfx::SCREEN_TYPE_NATIVE &&
-      gfx::SCREEN_TYPE_NATIVE != gfx::SCREEN_TYPE_ALTERNATE) {
-    widget_bounds = tooltip_window_->GetHost()->GetBounds();
-  }
-  gfx::Screen* screen = gfx::Screen::GetScreenByType(screen_type_);
-  gfx::Rect bounds(screen->GetDisplayNearestPoint(origin).bounds());
-  if (!widget_bounds.IsEmpty())
-    bounds.Intersect(widget_bounds);
-  return bounds;
-}
-
 void TooltipAura::SetTooltipBounds(const gfx::Point& mouse_pos,
                                    int tooltip_width,
                                    int tooltip_height) {
   gfx::Rect tooltip_rect(mouse_pos.x(), mouse_pos.y(), tooltip_width,
                          tooltip_height);
 
   tooltip_rect.Offset(kCursorOffsetX, kCursorOffsetY);
-  gfx::Rect display_bounds = GetBoundsForTooltip(mouse_pos);
+  gfx::Screen* screen = gfx::Screen::GetScreenByType(screen_type_);
+  gfx::Rect display_bounds(screen->GetDisplayNearestPoint(mouse_pos).bounds());
 
   // If tooltip is out of bounds on the x axis, we simply shift it
   // horizontally by the offset.
   if (tooltip_rect.right() > display_bounds.right()) {
     int h_offset = tooltip_rect.right() - display_bounds.right();
     tooltip_rect.Offset(-h_offset, 0);
   }
 
   // If tooltip is out of bounds on the y axis, we flip it to appear above the
   // mouse cursor instead of below.
   if (tooltip_rect.bottom() > display_bounds.bottom())
     tooltip_rect.set_y(mouse_pos.y() - tooltip_height);
 
   tooltip_rect.AdjustToFit(display_bounds);
   widget_->SetBounds(tooltip_rect);
 }
 
-void TooltipAura::CreateWidget() {
-  if (widget_) {
-    // If the window for which the tooltip is being displayed changes and if the
-    // tooltip window and the tooltip widget belong to different rootwindows
-    // then we need to recreate the tooltip widget under the active root window
-    // hierarchy to get it to display.
-    if (widget_->GetNativeWindow()->GetRootWindow() ==
-        tooltip_window_->GetRootWindow())
-      return;
-    DestroyWidget();
-  }
-  widget_ = CreateTooltipWidget(tooltip_window_);
-  widget_->SetContentsView(&label_);
-  widget_->AddObserver(this);
-}
-
 void TooltipAura::DestroyWidget() {
   if (widget_) {
     widget_->RemoveObserver(this);
     widget_->Close();
     widget_ = NULL;
   }
 }
 
 void TooltipAura::SetText(aura::Window* window,
                           const base::string16& tooltip_text,
                           const gfx::Point& location) {
   tooltip_window_ = window;
   int max_width, line_count;
   base::string16 trimmed_text(tooltip_text);
   TrimTooltipToFit(label_.font_list(), GetMaxWidth(location), &trimmed_text,
                    &max_width, &line_count);
   label_.SetText(trimmed_text);
 
   int width = max_width + 2 * kTooltipHorizontalPadding;
   int height = label_.GetHeightForWidth(max_width) +
       2 * kTooltipVerticalPadding;
-  CreateWidget();
+
+  if (!widget_) {

[pkotwicz, 2014/05/16 02:22:53]

Is it worth adding a comment as to why we want to avoid recreating the tooltip?

[Elliot Glaysher, 2014/05/16 19:39:42]

I'm not sure if this is safe; IIRC, chromeos can have multiple root windows, and
I thought this class was shared between linux and chromeos.

[oshima, 2014/05/16 19:49:49]

yes, erg@ is correct.

https://code.google.com/p/chromium/codesearch#chromium/src/ash/shell.cc&l=961

[pkotwicz, 2014/05/16 20:02:16]

My understanding is that views::Widget::SetBounds() will reparent the tooltip to
the new root window if necessary on CrOS
erg@, oshima@, am I missing something?

[Elliot Glaysher, 2014/05/16 20:07:20]

Huh, it looks like you're right. ash::ScreenPositionController::SetBounds() has
code to move windows from one RootWindow to another.

[oshima, 2014/05/16 20:11:12]

It does, but doe it based on the best matching display for given bounds, which
may not be what you want.

This is probably what you want:

widget->GetNativeView()->SetSetBoundsInScreen(bounds_in_scren,
    gfx::Screen::GetScreenFor(window)->GetDisplayNearestWindow(window));

+    widget_ = CreateTooltipWidget(tooltip_window_);
+    widget_->SetContentsView(&label_);
+    widget_->AddObserver(this);
+  }
+
   SetTooltipBounds(location, width, height);
 
+  ui::NativeTheme* native_theme = widget_->GetNativeTheme();
   label_.set_background(
       views::Background::CreateSolidBackground(
-          widget_->GetNativeTheme()->GetSystemColor(
+          native_theme->GetSystemColor(
               ui::NativeTheme::kColorId_TooltipBackground)));
+
+  label_.SetAutoColorReadabilityEnabled(false);
+  label_.SetEnabledColor(native_theme->GetSystemColor(
+      ui::NativeTheme::kColorId_TooltipText));
 }
 
 void TooltipAura::Show() {
-  if (widget_)
+  if (widget_) {
     widget_->Show();
+    widget_->StackAtTop();
+  }
 }
 
 void TooltipAura::Hide() {
   tooltip_window_ = NULL;
   if (widget_)
     widget_->Hide();
 }
 
 bool TooltipAura::IsVisible() {
   return widget_ && widget_->IsVisible();
 }
 
 void TooltipAura::OnWidgetDestroying(views::Widget* widget) {
   DCHECK_EQ(widget_, widget);
   widget_ = NULL;
   tooltip_window_ = NULL;
 }
 
 }  // namespace corewm
 }  // namespace views