text: // 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"
  #include "base/message_loop/message_loop.h"
  #include "ui/accessibility/ax_node_data.h"
  #include "ui/base/cursor/cursor.h"
  #include "ui/base/dragdrop/drag_drop_types.h"
  #include "ui/base/ui_base_switches_util.h"
  #include "ui/compositor/layer.h"
  #include "ui/events/event.h"
  #include "ui/events/event_utils.h"
  #include "ui/events/keycodes/keyboard_codes.h"
  #include "ui/gfx/canvas.h"
  #include "ui/views/drag_controller.h"
  #include "ui/views/focus/view_storage.h"
  #include "ui/views/layout/fill_layout.h"
  #include "ui/views/view_targeter.h"
  #include "ui/views/widget/root_view_targeter.h"
  #include "ui/views/widget/widget.h"
  #include "ui/views/widget/widget_delegate.h"
  
  typedef ui::EventDispatchDetails DispatchDetails;
  
  namespace views {
  namespace internal {
  
  namespace {
  
  enum EventType {
    EVENT_ENTER,
    EVENT_EXIT
  };
  
  class MouseEnterExitEvent : public ui::MouseEvent {
   public:
    MouseEnterExitEvent(const ui::MouseEvent& event, ui::EventType type)
        : ui::MouseEvent(event,
                         static_cast<View*>(NULL),
                         static_cast<View*>(NULL)) {
      DCHECK(type == ui::ET_MOUSE_ENTERED ||
             type == ui::ET_MOUSE_EXITED);
      SetType(type);
    }
  
    ~MouseEnterExitEvent() override {}
  };
  
  }  // namespace
  
  // This event handler receives events in the pre-target phase and takes care of
  // the following:
  //   - Shows keyboard-triggered context menus.
  class PreEventDispatchHandler : public ui::EventHandler {
   public:
    explicit PreEventDispatchHandler(View* owner)
        : owner_(owner) {
    }
    ~PreEventDispatchHandler() override {}
  
   private:
    // ui::EventHandler:
    void OnKeyEvent(ui::KeyEvent* event) override {
      CHECK_EQ(ui::EP_PRETARGET, event->phase());
      if (event->handled())
        return;
  
      View* v = NULL;
      if (owner_->GetFocusManager())  // Can be NULL in unittests.
        v = owner_->GetFocusManager()->GetFocusedView();
  
      // Special case to handle keyboard-triggered context menus.
      if (v && v->enabled() && ((event->key_code() == ui::VKEY_APPS) ||
         (event->key_code() == ui::VKEY_F10 && event->IsShiftDown()))) {
        // Clamp the menu location within the visible bounds of each ancestor view
        // to avoid showing the menu over a completely different view or window.
        gfx::Point location = v->GetKeyboardContextMenuLocation();
        for (View* parent = v->parent(); parent; parent = parent->parent()) {
          const gfx::Rect& parent_bounds = parent->GetBoundsInScreen();
          location.SetToMax(parent_bounds.origin());
          location.SetToMin(parent_bounds.bottom_right());
        }
        v->ShowContextMenu(location, ui::MENU_SOURCE_KEYBOARD);
        event->StopPropagation();
      }
    }
  
    View* owner_;
  
    DISALLOW_COPY_AND_ASSIGN(PreEventDispatchHandler);
  };
  
  // This event handler receives events in the post-target phase and takes care of
  // the following:
  //   - Generates context menu, or initiates drag-and-drop, from gesture events.
  class PostEventDispatchHandler : public ui::EventHandler {
   public:
    PostEventDispatchHandler()
        : touch_dnd_enabled_(::switches::IsTouchDragDropEnabled()) {
    }
    ~PostEventDispatchHandler() override {}
  
   private:
    // Overridden from ui::EventHandler:
    void OnGestureEvent(ui::GestureEvent* event) override {
      DCHECK_EQ(ui::EP_POSTTARGET, event->phase());
      if (event->handled())
        return;
  
      View* target = static_cast<View*>(event->target());
      gfx::Point location = event->location();
      if (touch_dnd_enabled_ &&
          event->type() == ui::ET_GESTURE_LONG_PRESS &&
          (!target->drag_controller() ||
           target->drag_controller()->CanStartDragForView(
               target, location, location))) {
        if (target->DoDrag(*event, location,
            ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH)) {
          event->StopPropagation();
          return;
        }
      }
  
      if (target->context_menu_controller() &&
          (event->type() == ui::ET_GESTURE_LONG_PRESS ||
           event->type() == ui::ET_GESTURE_LONG_TAP ||
           event->type() == ui::ET_GESTURE_TWO_FINGER_TAP)) {
        gfx::Point screen_location(location);
        View::ConvertPointToScreen(target, &screen_location);
        target->ShowContextMenu(screen_location, ui::MENU_SOURCE_TOUCH);
        event->StopPropagation();
      }
    }
  
    bool touch_dnd_enabled_;
  
    DISALLOW_COPY_AND_ASSIGN(PostEventDispatchHandler);
  };
  
  // static
  const char RootView::kViewClassName[] = "RootView";
  
  ////////////////////////////////////////////////////////////////////////////////
  // 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),
        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),
        event_dispatch_target_(NULL),
        old_dispatch_target_(NULL) {
    AddPreTargetHandler(pre_dispatch_handler_.get());
    AddPostTargetHandler(post_dispatch_handler_.get());
    SetEventTargeter(
        std::unique_ptr<ViewTargeter>(new RootViewTargeter(this, this)));
  }
  
  RootView::~RootView() {
    // If we have children remove them explicitly so to make sure a remove
    // notification is sent for each one of them.
    if (has_children())
      RemoveAllChildViews(true);
  }
  
  // Tree operations -------------------------------------------------------------
  
  void RootView::SetContentsView(View* contents_view) {
    DCHECK(contents_view && GetWidget()->native_widget()) <<
        "Can't be called until after the native widget is created!";
    // The ContentsView must be set up _after_ the window is created so that its
    // Widget pointer is valid.
    SetLayoutManager(new FillLayout);
    if (has_children())
      RemoveAllChildViews(true);
    AddChildView(contents_view);
  
    // Force a layout now, since the attached hierarchy won't be ready for the
    // containing window's bounds. Note that we call Layout directly rather than
    // calling the widget's size changed handler, since the RootView's bounds may
    // not have changed, which will cause the Layout not to be done otherwise.
    Layout();
  }
  
  View* RootView::GetContentsView() {
    return child_count() > 0 ? child_at(0) : NULL;
  }
  
  void RootView::NotifyNativeViewHierarchyChanged() {
    PropagateNativeViewHierarchyChanged();
  }
  
  // Focus -----------------------------------------------------------------------
  
  void RootView::SetFocusTraversableParent(FocusTraversable* focus_traversable) {
    DCHECK(focus_traversable != this);
    focus_traversable_parent_ = focus_traversable;
  }
  
  void RootView::SetFocusTraversableParentView(View* view) {
    focus_traversable_parent_view_ = view;
  }
  
  // System events ---------------------------------------------------------------
  
  void RootView::ThemeChanged() {
    View::PropagateThemeChanged();
  }
  
  void RootView::LocaleChanged() {
    View::PropagateLocaleChanged();
  }
  
  void RootView::DeviceScaleFactorChanged(float device_scale_factor) {
    View::PropagateDeviceScaleFactorChanged(device_scale_factor);
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  // RootView, FocusTraversable implementation:
  
  FocusSearch* RootView::GetFocusSearch() {
    return &focus_search_;
  }
  
  FocusTraversable* RootView::GetFocusTraversableParent() {
    return focus_traversable_parent_;
  }
  
  View* RootView::GetFocusTraversableParentView() {
    return focus_traversable_parent_view_;
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  // RootView, ui::EventProcessor overrides:
  
  ui::EventTarget* RootView::GetRootTarget() {
    return this;
  }
  
  void RootView::OnEventProcessingStarted(ui::Event* event) {
    if (!event->IsGestureEvent())
      return;
  
    ui::GestureEvent* gesture_event = event->AsGestureEvent();
  
    // Do not process ui::ET_GESTURE_BEGIN events.
    if (gesture_event->type() == ui::ET_GESTURE_BEGIN) {
      event->SetHandled();
      return;
    }
  
    // Do not process ui::ET_GESTURE_END events if they do not correspond to the
    // removal of the final touch point or if no gesture handler has already
    // been set.
    if (gesture_event->type() == ui::ET_GESTURE_END &&
        (gesture_event->details().touch_points() > 1 ||
         !gesture_handler_)) {
      event->SetHandled();
      return;
    }
  
    // Do not process subsequent gesture scroll events if no handler was set for
    // a ui::ET_GESTURE_SCROLL_BEGIN event.
    if (!gesture_handler_ &&
        (gesture_event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
         gesture_event->type() == ui::ET_GESTURE_SCROLL_END ||
         gesture_event->type() == ui::ET_SCROLL_FLING_START)) {
      event->SetHandled();
      return;
    }
  
    gesture_handler_set_before_processing_ = !!gesture_handler_;
  }
  
  void RootView::OnEventProcessingFinished(ui::Event* event) {
    // If |event| was not handled and |gesture_handler_| was not set by the
    // dispatch of a previous gesture event, then no default gesture handler
    // should be set prior to the next gesture event being received.
    if (event->IsGestureEvent() &&
        !event->handled() &&
        !gesture_handler_set_before_processing_) {
      gesture_handler_ = NULL;
    }
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  // RootView, View overrides:
  
  const Widget* RootView::GetWidget() const {
    return widget_;
  }
  
  Widget* RootView::GetWidget() {
    return const_cast<Widget*>(const_cast<const RootView*>(this)->GetWidget());
  }
  
  bool RootView::IsDrawn() const {
    return visible();
  }
  
  const char* RootView::GetClassName() const {
    return kViewClassName;
  }
  
  void RootView::SchedulePaintInRect(const gfx::Rect& rect) {
    if (layer()) {
      layer()->SchedulePaint(rect);
    } else {
      gfx::Rect xrect = ConvertRectToParent(rect);
      gfx::Rect invalid_rect = gfx::IntersectRects(GetLocalBounds(), xrect);
      if (!invalid_rect.IsEmpty())
        widget_->SchedulePaintInRect(invalid_rect);
    }
  }
  
  bool RootView::OnMousePressed(const ui::MouseEvent& event) {
    UpdateCursor(event);
    SetMouseLocationAndFlags(event);
  
    // If mouse_pressed_handler_ is non null, we are currently processing
    // a pressed -> drag -> released session. In that case we send the
    // event to mouse_pressed_handler_
    if (mouse_pressed_handler_) {
      ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(this),
                                         mouse_pressed_handler_);
      drag_info_.Reset();
      ui::EventDispatchDetails dispatch_details =
          DispatchEvent(mouse_pressed_handler_, &mouse_pressed_event);
      if (dispatch_details.dispatcher_destroyed)
        return true;
      return true;
    }
    DCHECK(!explicit_mouse_handler_);
  
    bool hit_disabled_view = false;
    // Walk up the tree until we find a view that wants the mouse event.
    for (mouse_pressed_handler_ = GetEventHandlerForPoint(event.location());
         mouse_pressed_handler_ && (mouse_pressed_handler_ != this);
         mouse_pressed_handler_ = mouse_pressed_handler_->parent()) {
      DVLOG(1) << "OnMousePressed testing "
          << mouse_pressed_handler_->GetClassName();
      if (!mouse_pressed_handler_->enabled()) {
        // Disabled views should eat events instead of propagating them upwards.
        hit_disabled_view = true;
        break;
      }
  
      // See if this view wants to handle the mouse press.
      ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(this),
                                         mouse_pressed_handler_);
  
      // Remove the double-click flag if the handler is different than the
      // one which got the first click part of the double-click.
      if (mouse_pressed_handler_ != last_click_handler_)
        mouse_pressed_event.set_flags(event.flags() & ~ui::EF_IS_DOUBLE_CLICK);
  
      drag_info_.Reset();
      ui::EventDispatchDetails dispatch_details =
          DispatchEvent(mouse_pressed_handler_, &mouse_pressed_event);
      if (dispatch_details.dispatcher_destroyed)
        return mouse_pressed_event.handled();
  
      // The view could have removed itself from the tree when handling
      // OnMousePressed().  In this case, the removal notification will have
      // reset mouse_pressed_handler_ to NULL out from under us.  Detect this
      // case and stop.  (See comments in view.h.)
      //
      // NOTE: Don't return true here, because we don't want the frame to
      // forward future events to us when there's no handler.
      if (!mouse_pressed_handler_)
        break;
  
      // If the view handled the event, leave mouse_pressed_handler_ set and
      // return true, which will cause subsequent drag/release events to get
      // forwarded to that view.
      if (mouse_pressed_event.handled()) {
        last_click_handler_ = mouse_pressed_handler_;
        DVLOG(1) << "OnMousePressed handled by "
            << mouse_pressed_handler_->GetClassName();
        return true;
      }
    }
  
    // Reset mouse_pressed_handler_ to indicate that no processing is occurring.
    mouse_pressed_handler_ = NULL;
  
    // In the event that a double-click is not handled after traversing the
    // entire hierarchy (even as a single-click when sent to a different view),
    // it must be marked as handled to avoid anything happening from default
    // processing if it the first click-part was handled by us.
    if (last_click_handler_ && (event.flags() & ui::EF_IS_DOUBLE_CLICK))
      hit_disabled_view = true;
  
    last_click_handler_ = NULL;
    return hit_disabled_view;
  }
  
  bool RootView::OnMouseDragged(const ui::MouseEvent& event) {
    if (mouse_pressed_handler_) {
      SetMouseLocationAndFlags(event);
  
      ui::MouseEvent mouse_event(event, static_cast<View*>(this),
                                 mouse_pressed_handler_);
      ui::EventDispatchDetails dispatch_details =
          DispatchEvent(mouse_pressed_handler_, &mouse_event);
      if (dispatch_details.dispatcher_destroyed)
        return false;
    }
    return false;
  }
  
  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);
      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.
  
    if (mouse_pressed_handler_ || gesture_handler_) {
      // Synthesize a release event for UpdateCursor.
      if (mouse_pressed_handler_) {
        gfx::Point last_point(last_mouse_event_x_, last_mouse_event_y_);
        ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, last_point,
                                     last_point, ui::EventTimeForNow(),
                                     last_mouse_event_flags_, 0);
        UpdateCursor(release_event);
      }
      // We allow the view to delete us from OnMouseCaptureLost. As such,
      // configure state such that we're done first, then call View.
      View* mouse_pressed_handler = mouse_pressed_handler_;
      View* gesture_handler = gesture_handler_;
      SetMouseHandler(NULL);
      if (mouse_pressed_handler)
        mouse_pressed_handler->OnMouseCaptureLost();
      else
        gesture_handler->OnMouseCaptureLost();
      // WARNING: we may have been deleted.
    }
  }
  
  void RootView::OnMouseMoved(const ui::MouseEvent& event) {
    View* v = GetEventHandlerForPoint(event.location());
    // Find the first enabled view, or the existing move handler, whichever comes
    // first.  The check for the existing handler is because if a view becomes
    // disabled while handling moves, it's wrong to suddenly send ET_MOUSE_EXITED
    // and ET_MOUSE_ENTERED events, because the mouse hasn't actually exited yet.
    while (v && !v->enabled() && (v != mouse_move_handler_))
      v = v->parent();
    if (v && v != this) {
      if (v != mouse_move_handler_) {
        if (mouse_move_handler_ != NULL &&
            (!mouse_move_handler_->notify_enter_exit_on_child() ||
             !mouse_move_handler_->Contains(v))) {
          MouseEnterExitEvent exit(event, ui::ET_MOUSE_EXITED);
          exit.ConvertLocationToTarget(static_cast<View*>(this),
                                       mouse_move_handler_);
          ui::EventDispatchDetails dispatch_details =
              DispatchEvent(mouse_move_handler_, &exit);
          if (dispatch_details.dispatcher_destroyed)
            return;
          // The mouse_move_handler_ could have been destroyed in the context of
          // the mouse exit event.
          if (!dispatch_details.target_destroyed) {
            CHECK(mouse_move_handler_);
            dispatch_details = NotifyEnterExitOfDescendant(
                event, ui::ET_MOUSE_EXITED, mouse_move_handler_, v);
            if (dispatch_details.dispatcher_destroyed)
              return;
          }
        }
        View* old_handler = mouse_move_handler_;
        mouse_move_handler_ = v;
        if (!mouse_move_handler_->notify_enter_exit_on_child() ||
            !mouse_move_handler_->Contains(old_handler)) {
          MouseEnterExitEvent entered(event, ui::ET_MOUSE_ENTERED);
          entered.ConvertLocationToTarget(static_cast<View*>(this),
                                          mouse_move_handler_);
          ui::EventDispatchDetails dispatch_details =
              DispatchEvent(mouse_move_handler_, &entered);
          if (dispatch_details.dispatcher_destroyed ||
              dispatch_details.target_destroyed) {
            return;
          }
          CHECK(mouse_move_handler_);
          dispatch_details = NotifyEnterExitOfDescendant(
              event, ui::ET_MOUSE_ENTERED, mouse_move_handler_, old_handler);
          if (dispatch_details.dispatcher_destroyed ||
              dispatch_details.target_destroyed) {
            return;
          }
        }
      }
      ui::MouseEvent moved_event(event, static_cast<View*>(this),
                                 mouse_move_handler_);
      mouse_move_handler_->OnMouseMoved(moved_event);
      // TODO(tdanderson): It may be possible to avoid setting the cursor twice
      //                   (once here and once from CompoundEventFilter) on a
      //                   mousemove. See crbug.com/351469.
      if (!(moved_event.flags() & ui::EF_IS_NON_CLIENT))
        widget_->SetCursor(mouse_move_handler_->GetCursor(moved_event));
    } else if (mouse_move_handler_ != NULL) {
      MouseEnterExitEvent exited(event, ui::ET_MOUSE_EXITED);
      ui::EventDispatchDetails dispatch_details =
          DispatchEvent(mouse_move_handler_, &exited);
      if (dispatch_details.dispatcher_destroyed)
        return;
      // The mouse_move_handler_ could have been destroyed in the context of the
      // mouse exit event.
      if (!dispatch_details.target_destroyed) {
        CHECK(mouse_move_handler_);
        dispatch_details = NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_EXITED,
                                                       mouse_move_handler_, v);
        if (dispatch_details.dispatcher_destroyed)
          return;
      }
      // On Aura the non-client area extends slightly outside the root view for
      // some windows.  Let the non-client cursor handling code set the cursor
      // as we do above.
      if (!(event.flags() & ui::EF_IS_NON_CLIENT))
        widget_->SetCursor(gfx::kNullCursor);
      mouse_move_handler_ = NULL;
    }
  }
  
  void RootView::OnMouseExited(const ui::MouseEvent& event) {
    if (mouse_move_handler_ != NULL) {
      MouseEnterExitEvent exited(event, ui::ET_MOUSE_EXITED);
      ui::EventDispatchDetails dispatch_details =
          DispatchEvent(mouse_move_handler_, &exited);
      if (dispatch_details.dispatcher_destroyed)
        return;
      // The mouse_move_handler_ could have been destroyed in the context of the
      // mouse exit event.
      if (!dispatch_details.target_destroyed) {
        CHECK(mouse_move_handler_);
        dispatch_details = NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_EXITED,
                                                       mouse_move_handler_, NULL);
        if (dispatch_details.dispatcher_destroyed)
          return;
      }
      mouse_move_handler_ = NULL;
    }
  }
  
  bool RootView::OnMouseWheel(const ui::MouseWheelEvent& event) {
    for (View* v = GetEventHandlerForPoint(event.location());
         v && v != this && !event.handled(); v = v->parent()) {
      ui::EventDispatchDetails dispatch_details =
          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();
  }
  
  void RootView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
    node_data->SetName(widget_->widget_delegate()->GetAccessibleWindowTitle());
    node_data->role = widget_->widget_delegate()->GetAccessibleWindowRole();
  }
  
  void RootView::UpdateParentLayer() {
    if (layer())
      ReparentLayer(gfx::Vector2d(GetMirroredX(), y()), widget_->GetLayer());
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  // RootView, protected:
  
  void RootView::ViewHierarchyChanged(
      const ViewHierarchyChangedDetails& details) {
    widget_->ViewHierarchyChanged(details);
  
    if (!details.is_add) {
      if (!explicit_mouse_handler_ && mouse_pressed_handler_ == details.child)
        mouse_pressed_handler_ = NULL;
      if (mouse_move_handler_ == details.child)
        mouse_move_handler_ = NULL;
      if (gesture_handler_ == details.child)
        gesture_handler_ = NULL;
      if (event_dispatch_target_ == details.child)
        event_dispatch_target_ = NULL;
      if (old_dispatch_target_ == details.child)
        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;
      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())
      canvas->DrawColor(SK_ColorBLACK, SkBlendMode::kClear);
  
    View::OnPaint(canvas);
  }
  
  gfx::Vector2d RootView::CalculateOffsetToAncestorWithLayer(
      ui::Layer** layer_parent) {
    gfx::Vector2d offset(View::CalculateOffsetToAncestorWithLayer(layer_parent));
    if (!layer() && layer_parent)
      *layer_parent = widget_->GetLayer();
    return offset;
  }
  
  View::DragInfo* RootView::GetDragInfo() {
    return &drag_info_;
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  // RootView, private:
  
  // Input -----------------------------------------------------------------------
  
  void RootView::UpdateCursor(const ui::MouseEvent& event) {
    if (!(event.flags() & ui::EF_IS_NON_CLIENT)) {
      View* v = GetEventHandlerForPoint(event.location());
      ui::MouseEvent me(event, static_cast<View*>(this), v);
      widget_->SetCursor(v->GetCursor(me));
    }
  }
  
  void RootView::SetMouseLocationAndFlags(const ui::MouseEvent& event) {
    last_mouse_event_flags_ = event.flags();
    last_mouse_event_x_ = event.x();
    last_mouse_event_y_ = event.y();
  }
  
  ui::EventDispatchDetails RootView::NotifyEnterExitOfDescendant(
      const ui::MouseEvent& event,
      ui::EventType type,
      View* view,
      View* sibling) {
    for (View* p = view->parent(); p; p = p->parent()) {
      if (!p->notify_enter_exit_on_child())
        continue;
      if (sibling && p->Contains(sibling))
        break;
      // It is necessary to recreate the notify-event for each dispatch, since one
      // of the callbacks can mark the event as handled, and that would cause
      // incorrect event dispatch.
      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();
  }
  
  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.
      // TODO(tdanderson): Look into moving this to PostDispatchEvent() and
      //                   using |event_dispatch_target_| instead of
      //                   |gesture_handler_| to detect if the view has been
      //                   removed from the tree.
      gesture_handler_ = view;
  
      // Disabled views are permitted to be targets of gesture events, but
      // gesture events should never actually be dispatched to them. Prevent
      // dispatch by marking the event as handled.
      if (!view->enabled())
        event->SetHandled();
    }
  
    old_dispatch_target_ = event_dispatch_target_;
    event_dispatch_target_ = view;
    return DispatchDetails();
  }
  
  ui::EventDispatchDetails RootView::PostDispatchEvent(ui::EventTarget* target,
                                                       const ui::Event& event) {
    // The GESTURE_END event corresponding to the removal of the final touch
    // point marks the end of a gesture sequence, so reset |gesture_handler_|
    // to NULL.
    if (event.type() == ui::ET_GESTURE_END) {
      // In case a drag was in progress, reset all the handlers. Otherwise, just
      // reset the gesture handler.
      if (gesture_handler_ && gesture_handler_ == mouse_pressed_handler_)
        SetMouseHandler(NULL);
      else
        gesture_handler_ = NULL;
    }
  
    DispatchDetails details;
    if (target != event_dispatch_target_)
      details.target_destroyed = true;
  
    event_dispatch_target_ = old_dispatch_target_;
    old_dispatch_target_ = NULL;
  
  #ifndef NDEBUG
    DCHECK(!event_dispatch_target_ || Contains(event_dispatch_target_));
  #endif
  
    return details;
  }
  
  }  // namespace internal
  }  // namespace views
  