mash: Close system tray bubble on click outside its bounds, part 1

ui/views/widget/root_view.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/widget/root_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 139 matching lines @@
 // RootView, public:
 
 // Creation and lifetime -------------------------------------------------------
 
 RootView::RootView(Widget* widget)
     : widget_(widget),
       mouse_pressed_handler_(NULL),
       mouse_move_handler_(NULL),
       last_click_handler_(NULL),
       explicit_mouse_handler_(false),
+      clear_mouse_handler_on_release_(true),
       last_mouse_event_flags_(0),
       last_mouse_event_x_(-1),
       last_mouse_event_y_(-1),
       gesture_handler_(NULL),
       gesture_handler_set_before_processing_(false),
       pre_dispatch_handler_(new internal::PreEventDispatchHandler(this)),
       post_dispatch_handler_(new internal::PostEventDispatchHandler),
       focus_search_(this, false, false),
       focus_traversable_parent_(NULL),
       focus_traversable_parent_view_(NULL),
@@ skipping 264 matching lines @@
 
 void RootView::OnMouseReleased(const ui::MouseEvent& event) {
   UpdateCursor(event);
 
   if (mouse_pressed_handler_) {
     ui::MouseEvent mouse_released(event, static_cast<View*>(this),
                                   mouse_pressed_handler_);
     // We allow the view to delete us from the event dispatch callback. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
-    SetMouseHandler(NULL);
+    if (clear_mouse_handler_on_release_)
+      SetMouseHandler(nullptr);
     ui::EventDispatchDetails dispatch_details =
         DispatchEvent(mouse_pressed_handler, &mouse_released);
     if (dispatch_details.dispatcher_destroyed)
       return;
   }
 }
 
 void RootView::OnMouseCaptureLost() {
   // TODO: this likely needs to reset touch handler too.
 
@@ skipping 130 matching lines @@
         DispatchEvent(v, const_cast<ui::MouseWheelEvent*>(&event));
     if (dispatch_details.dispatcher_destroyed ||
         dispatch_details.target_destroyed) {
       return event.handled();
     }
   }
   return event.handled();
 }
 
 void RootView::SetMouseHandler(View* new_mh) {
-  // If we're clearing the mouse handler, clear explicit_mouse_handler_ as well.
-  explicit_mouse_handler_ = (new_mh != NULL);
-  mouse_pressed_handler_ = new_mh;
-  gesture_handler_ = new_mh;
-  drag_info_.Reset();
+  SetMouseHandler(new_mh, true /* clear_on_release */);
 }
 
 void RootView::GetAccessibleState(ui::AXViewState* state) {
   state->name = widget_->widget_delegate()->GetAccessibleWindowTitle();
   state->role = widget_->widget_delegate()->GetAccessibleWindowRole();
 }
 
 void RootView::UpdateParentLayer() {
   if (layer())
     ReparentLayer(gfx::Vector2d(GetMirroredX(), y()), widget_->GetLayer());
@@ skipping 19 matching lines @@
       old_dispatch_target_ = NULL;
   }
 }
 
 void RootView::VisibilityChanged(View* /*starting_from*/, bool is_visible) {
   if (!is_visible) {
     // When the root view is being hidden (e.g. when widget is minimized)
     // handlers are reset, so that after it is reshown, events are not captured
     // by old handlers.
     explicit_mouse_handler_ = false;
+    clear_mouse_handler_on_release_ = true;
     mouse_pressed_handler_ = NULL;
     mouse_move_handler_ = NULL;
     gesture_handler_ = NULL;
     event_dispatch_target_ = NULL;
     old_dispatch_target_ = NULL;
   }
 }
 
 void RootView::OnPaint(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
@@ skipping 49 matching lines @@
     MouseEnterExitEvent notify_event(event, type);
     ui::EventDispatchDetails dispatch_details = DispatchEvent(p, &notify_event);
     if (dispatch_details.dispatcher_destroyed ||
         dispatch_details.target_destroyed) {
       return dispatch_details;
     }
   }
   return ui::EventDispatchDetails();
 }
 
+void RootView::SetMouseHandler(View* new_mh, bool clear_on_release) {
+  // If we're clearing the mouse handler, clear explicit_mouse_handler_ as well.
+  explicit_mouse_handler_ = (new_mh != nullptr);
+  clear_mouse_handler_on_release_ = clear_on_release;
+  mouse_pressed_handler_ = new_mh;
+  gesture_handler_ = new_mh;
+  drag_info_.Reset();
+}
+
 bool RootView::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
 ui::EventDispatchDetails RootView::PreDispatchEvent(ui::EventTarget* target,
                                                     ui::Event* event) {
   View* view = static_cast<View*>(target);
   if (event->IsGestureEvent()) {
     // Update |gesture_handler_| to indicate which View is currently handling
     // gesture events.
@@ skipping 38 matching lines @@
 
 #ifndef NDEBUG
   DCHECK(!event_dispatch_target_ || Contains(event_dispatch_target_));
 #endif
 
   return details;
 }
 
 }  // namespace internal
 }  // namespace views