[gtk] fix a corner case where the status bubble was in the way of the cursor.

chrome/browser/gtk/status_bubble_gtk.cc

 // Copyright (c) 2009 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/gtk/status_bubble_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 
@@ skipping 27 matching lines @@
 }  // namespace
 
 StatusBubbleGtk::StatusBubbleGtk(Profile* profile)
     : theme_provider_(GtkThemeProvider::GetFrom(profile)),
       padding_(NULL),
       label_(NULL),
       flip_horizontally_(false),
       y_offset_(0),
       download_shelf_is_visible_(false),
       last_mouse_location_(0, 0),
-      last_mouse_left_content_(false) {
+      last_mouse_left_content_(false),
+      ignore_next_left_content_(false) {
   InitWidgets();
 
   theme_provider_->InitThemesFor(this);
   registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
 }
 
 StatusBubbleGtk::~StatusBubbleGtk() {
   container_.Destroy();
 }
 
 void StatusBubbleGtk::SetStatus(const string16& status_text_wide) {
   std::string status_text = UTF16ToUTF8(status_text_wide);
   if (status_text_ == status_text)
     return;
 
   status_text_ = status_text;
-  if (!status_text_.empty()) {
+  if (!status_text_.empty())
     SetStatusTextTo(status_text_);
-  } else if (!url_text_.empty()) {
+  else if (!url_text_.empty())
     SetStatusTextTo(url_text_);
-  } else {
+  else
     SetStatusTextTo(std::string());
-  }
 }
 
 void StatusBubbleGtk::SetURL(const GURL& url, const string16& languages) {
   url_ = url;
   languages_ = languages;
 
   // If we want to clear a displayed URL but there is a status still to
   // display, display that status instead.
   if (url.is_empty() && !status_text_.empty()) {
     url_text_ = std::string();
@@ skipping 65 matching lines @@
       // ourselves away from the pointer now.
       gtk_widget_show_all(padding_);
       MouseMoved(last_mouse_location_, false);
     }
     Show();
   }
 }
 
 void StatusBubbleGtk::MouseMoved(
     const gfx::Point& location, bool left_content) {
+  if (left_content && ignore_next_left_content_) {
+    ignore_next_left_content_ = false;
+    return;
+  }
+
   last_mouse_location_ = location;
   last_mouse_left_content_ = left_content;
 
   if (!GTK_WIDGET_REALIZED(container_.get()))
     return;
 
   GtkWidget* parent = gtk_widget_get_parent(container_.get());
   if (!parent || !GTK_WIDGET_REALIZED(parent))
     return;
 
@@ skipping 14 matching lines @@
     gtk_widget_size_request(container_.get(), &requisition);
 
     // Get our base position (that is, not including the current offset)
     // relative to the origin of the root window.
     gint toplevel_x = 0, toplevel_y = 0;
     gdk_window_get_position(toplevel->window, &toplevel_x, &toplevel_y);
     gfx::Rect parent_rect =
         gtk_util::GetWidgetRectRelativeToToplevel(parent);
     gfx::Rect bubble_rect(
         toplevel_x + parent_rect.x() +
-          (ltr ? 0 : parent->allocation.width - requisition.width),
+            (ltr ? 0 : parent->allocation.width - requisition.width),
         toplevel_y + parent_rect.y() +
-          parent->allocation.height - requisition.height,
+            parent->allocation.height - requisition.height,
         requisition.width,
         requisition.height);
 
     int left_threshold =
         bubble_rect.x() - bubble_rect.height() - kMousePadding;
     int right_threshold =
         bubble_rect.right() + bubble_rect.height() + kMousePadding;
     int top_threshold = bubble_rect.y() - kMousePadding;
 
     if (((ltr && location.x() < right_threshold) ||
          (!ltr && location.x() > left_threshold)) &&
         location.y() > top_threshold) {
       if (download_shelf_is_visible_) {
         SetFlipHorizontally(true);
         y_offset_ = 0;
       } else {
         SetFlipHorizontally(false);
         int distance = std::max(ltr ?
-                                  location.x() - right_threshold :
-                                  left_threshold - location.x(),
+                                    location.x() - right_threshold :
+                                    left_threshold - location.x(),
                                 top_threshold - location.y());
         y_offset_ = std::min(-1 * distance, requisition.height);
       }
     } else {
       SetFlipHorizontally(false);
       y_offset_ = 0;
     }
   }
 
   if (y_offset_ != old_y_offset || flip_horizontally_ != old_flip_horizontally)
@@ skipping 28 matching lines @@
   gtk_util::ActAsRoundedWindow(
       container_.get(), gtk_util::kGdkWhite, kCornerSize,
       gtk_util::ROUNDED_TOP_RIGHT,
       gtk_util::BORDER_TOP | gtk_util::BORDER_RIGHT);
   gtk_widget_set_name(container_.get(), "status-bubble");
   gtk_container_add(GTK_CONTAINER(container_.get()), padding_);
 
   // We need to listen for mouse motion events, since a fast-moving pointer may
   // enter our window without us getting any motion events on the browser near
   // enough for us to run away.
-  gtk_widget_add_events(container_.get(), GDK_POINTER_MOTION_MASK);
+  gtk_widget_add_events(container_.get(), GDK_POINTER_MOTION_MASK |
+                                          GDK_ENTER_NOTIFY_MASK);
   g_signal_connect(container_.get(), "motion-notify-event",
                    G_CALLBACK(HandleMotionNotifyThunk), this);
+  g_signal_connect(container_.get(), "enter-notify-event",
+                   G_CALLBACK(HandleEnterNotifyThunk), this);
 
   UserChangedTheme();
 }
 
 void StatusBubbleGtk::UserChangedTheme() {
   if (theme_provider_->UseGtkTheme()) {
     gtk_widget_modify_fg(label_, GTK_STATE_NORMAL, NULL);
     gtk_widget_modify_bg(container_.get(), GTK_STATE_NORMAL, NULL);
   } else {
     // TODO(erg): This is the closest to "text that will look good on a
@@ skipping 23 matching lines @@
 
   gtk_alignment_set_padding(GTK_ALIGNMENT(padding_),
       kInternalTopBottomPadding, kInternalTopBottomPadding,
       kInternalLeftRightPadding + (on_left ? 0 : kCornerSize),
       kInternalLeftRightPadding + (on_left ? kCornerSize : 0));
   // The rounded window code flips these arguments if we're RTL.
   gtk_util::SetRoundedWindowEdgesAndBorders(
       container_.get(),
       kCornerSize,
       flip_horizontally ?
-        gtk_util::ROUNDED_TOP_LEFT :
-        gtk_util::ROUNDED_TOP_RIGHT,
+          gtk_util::ROUNDED_TOP_LEFT :
+          gtk_util::ROUNDED_TOP_RIGHT,
       gtk_util::BORDER_TOP |
-        (flip_horizontally ? gtk_util::BORDER_LEFT : gtk_util::BORDER_RIGHT));
+          (flip_horizontally ? gtk_util::BORDER_LEFT : gtk_util::BORDER_RIGHT));
   gtk_widget_queue_draw(container_.get());
 }
 
 void StatusBubbleGtk::ExpandURL() {
   start_width_ = label_->allocation.width;
   expand_animation_.reset(new SlideAnimation(this));
   expand_animation_->SetTweenType(Tween::LINEAR);
   expand_animation_->Show();
 
   SetStatusTextToURL();
 }
 
 void StatusBubbleGtk::UpdateLabelSizeRequest() {
   if (!expanded() || !expand_animation_->is_animating()) {
     gtk_widget_set_size_request(label_, -1, -1);
     return;
   }
 
   int new_width = start_width_ +
       (desired_width_ - start_width_) * expand_animation_->GetCurrentValue();
   gtk_widget_set_size_request(label_, new_width, -1);
 }
 
+// See http://crbug.com/68897 for why we have to handle this event.
+gboolean StatusBubbleGtk::HandleEnterNotify(GtkWidget* sender,
+                                            GdkEventCrossing* event) {
+  ignore_next_left_content_ = true;
+  MouseMoved(gfx::Point(event->x_root, event->y_root), false);
+  return FALSE;
+}
+
 gboolean StatusBubbleGtk::HandleMotionNotify(GtkWidget* sender,
                                              GdkEventMotion* event) {
   MouseMoved(gfx::Point(event->x_root, event->y_root), false);
   return FALSE;
 }
 
 void StatusBubbleGtk::AnimationEnded(const Animation* animation) {
   UpdateLabelSizeRequest();
 }
 
 void StatusBubbleGtk::AnimationProgressed(const Animation* animation) {
   UpdateLabelSizeRequest();
 }