// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "cobalt/layout/topmost_event_target.h"

#include <memory>
#include <utility>
#include <vector>

#include "base/optional.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/token.h"
#include "cobalt/base/tokens.h"
#include "cobalt/cssom/computed_style_utils.h"
#include "cobalt/cssom/keyword_value.h"
#include "cobalt/dom/document.h"
#include "cobalt/dom/html_element.h"
#include "cobalt/dom/html_html_element.h"
#include "cobalt/dom/lottie_player.h"
#include "cobalt/dom/mouse_event.h"
#include "cobalt/dom/mouse_event_init.h"
#include "cobalt/dom/pointer_event.h"
#include "cobalt/dom/pointer_event_init.h"
#include "cobalt/dom/pointer_state.h"
#include "cobalt/dom/ui_event.h"
#include "cobalt/dom/wheel_event.h"
#include "cobalt/layout/layout_unit.h"
#include "cobalt/math/rect_f.h"
#include "cobalt/math/vector2d.h"
#include "cobalt/math/vector2d_f.h"
#include "cobalt/web/event.h"

namespace cobalt {
namespace layout {

scoped_refptr<dom::HTMLElement> TopmostEventTarget::FindTopmostEventTarget(
    const scoped_refptr<dom::Document>& document,
    const math::Vector2dF& coordinate) {
  TRACE_EVENT0("cobalt::layout",
               "TopmostEventTarget::FindTopmostEventTarget()");
  DCHECK(document);
  DCHECK(!box_);
  DCHECK(render_sequence_.empty());

  // Make sure the document's layout box tree is up-to-date.
  document->DoSynchronousLayout();

  html_element_ = document->html();
  bool consider_only_fixed_elements = false;
  ConsiderElement(html_element_, coordinate, consider_only_fixed_elements);
  box_ = NULL;
  render_sequence_.clear();
  scoped_refptr<dom::HTMLElement> topmost_element;
  topmost_element.swap(html_element_);
  DCHECK(!html_element_);
  return topmost_element;
}

namespace {

LayoutBoxes* GetLayoutBoxesIfNotEmpty(dom::Element* element) {
  dom::HTMLElement* html_element = element->AsHTMLElement();
  if (html_element && html_element->computed_style()) {
    dom::LayoutBoxes* dom_layout_boxes = html_element->layout_boxes();
    if (dom_layout_boxes &&
        dom_layout_boxes->type() == dom::LayoutBoxes::kLayoutLayoutBoxes) {
      LayoutBoxes* layout_boxes =
          base::polymorphic_downcast<LayoutBoxes*>(dom_layout_boxes);
      if (!layout_boxes->boxes().empty()) {
        return layout_boxes;
      }
    }
  }
  return NULL;
}

std::unique_ptr<dom::PossibleScrollTargets> FindPossibleScrollTargets(
    scoped_refptr<dom::Element> target_element) {
  std::unique_ptr<dom::PossibleScrollTargets> possible_scroll_targets =
      std::make_unique<dom::PossibleScrollTargets>();

  for (auto current_element = target_element; !!current_element;
       current_element = current_element->parent_element()) {
    auto current_html_element = current_element->AsHTMLElement();
    if (!current_html_element) {
      continue;
    }

    bool pointer_events_enabled =
        current_html_element->computed_style()->pointer_events() !=
        cssom::KeywordValue::GetNone();
    if (!pointer_events_enabled) {
      continue;
    }

    auto current_ui_nav_item = current_html_element->GetUiNavItem();
    if (!current_ui_nav_item) {
      continue;
    }

    float scroll_top_lower_bound;
    float scroll_left_lower_bound;
    float scroll_top_upper_bound;
    float scroll_left_upper_bound;
    current_ui_nav_item->GetBounds(
        &scroll_top_lower_bound, &scroll_left_lower_bound,
        &scroll_top_upper_bound, &scroll_left_upper_bound);

    float offset_x;
    float offset_y;
    current_ui_nav_item->GetContentOffset(&offset_x, &offset_y);

    bool can_scroll_left = scroll_left_lower_bound < offset_x;
    bool can_scroll_right = scroll_left_upper_bound > offset_x;
    bool can_scroll_up = scroll_top_lower_bound < offset_y;
    bool can_scroll_down = scroll_top_upper_bound > offset_y;

    if (can_scroll_left && !possible_scroll_targets->left) {
      possible_scroll_targets->left = current_html_element;
    }
    if (can_scroll_right && !possible_scroll_targets->right) {
      possible_scroll_targets->right = current_html_element;
    }
    if (can_scroll_up && !possible_scroll_targets->up) {
      possible_scroll_targets->up = current_html_element;
    }
    if (can_scroll_down && !possible_scroll_targets->down) {
      possible_scroll_targets->down = current_html_element;
    }
  }
  return possible_scroll_targets;
}

bool HasAnyScrollTarget(
    const dom::PossibleScrollTargets* possible_scroll_targets) {
  if (!possible_scroll_targets) {
    return false;
  }
  return possible_scroll_targets->left || possible_scroll_targets->right ||
         possible_scroll_targets->up || possible_scroll_targets->down;
}

scoped_refptr<dom::HTMLElement> FindFirstElementWithScrollType(
    dom::PossibleScrollTargets* possible_scroll_targets,
    ui_navigation::scroll_engine::ScrollType major_scroll_axis,
    bool scrolling_right, bool scrolling_down) {
  bool scrolling_left = !scrolling_right;
  bool scrolling_up = !scrolling_down;
  bool horizontal_scroll_axis =
      major_scroll_axis == ui_navigation::scroll_engine::ScrollType::Horizontal;
  bool vertical_scroll_axis =
      major_scroll_axis == ui_navigation::scroll_engine::ScrollType::Vertical;

  if (scrolling_left && horizontal_scroll_axis) {
    return possible_scroll_targets->left;
  } else if (scrolling_right && horizontal_scroll_axis) {
    return possible_scroll_targets->right;
  } else if (scrolling_up && vertical_scroll_axis) {
    return possible_scroll_targets->up;
  } else if (scrolling_down && vertical_scroll_axis) {
    return possible_scroll_targets->down;
  }
  return nullptr;
}

bool TransformCanBeAppliedToBox(const Box* box, math::Vector2dF* coordinate) {
  return !box->IsTransformed() ||
         box->ApplyTransformActionToCoordinate(coordinate);
}

struct CanTargetBox {
  const math::Vector2dF* coordinate;
  explicit CanTargetBox(const math::Vector2dF* coordinate)
      : coordinate(coordinate) {}
  bool operator()(const Box* box) const {
    return box->CoordinateCanTarget(coordinate);
  }
};

bool CanTargetElementAndChildren(dom::Element* element,
                                 math::Vector2dF* coordinate) {
  LayoutBoxes* layout_boxes = GetLayoutBoxesIfNotEmpty(element);
  const Boxes boxes = layout_boxes->boxes();
  const Box* box = boxes.front();
  if (!box->computed_style()) {
    return true;
  }

  return TransformCanBeAppliedToBox(box, coordinate) &&
         std::any_of(boxes.begin(), boxes.end(), CanTargetBox(coordinate));
}

// Return the nearest common ancestor of previous_element and target_element
scoped_refptr<dom::Element> GetNearestCommonAncestor(
    scoped_refptr<dom::HTMLElement> previous_element,
    scoped_refptr<dom::HTMLElement> target_element) {
  scoped_refptr<dom::Element> nearest_common_ancestor;
  if (previous_element == target_element) {
    nearest_common_ancestor = target_element;
  } else {
    if (previous_element && target_element) {
      // Find the nearest common ancestor, if there is any.
      dom::Document* previous_document = previous_element->node_document();
      // The elements only have a common ancestor if they are both in the same
      // document.
      if (previous_document &&
          previous_document == target_element->node_document()) {
        // The nearest ancestor of the target element that is already
        // designated is the nearest common ancestor of it and the previous
        // element.
        nearest_common_ancestor = target_element;
        while (nearest_common_ancestor &&
               nearest_common_ancestor->AsHTMLElement() &&
               !nearest_common_ancestor->AsHTMLElement()->IsDesignated()) {
          nearest_common_ancestor = nearest_common_ancestor->parent_element();
        }
      }
    }
  }
  return nearest_common_ancestor;
}

void SendStateChangeLeaveEvents(
    bool is_pointer_event, scoped_refptr<dom::HTMLElement> previous_element,
    scoped_refptr<dom::HTMLElement> target_element,
    scoped_refptr<dom::Element> nearest_common_ancestor,
    dom::PointerEventInit* event_init) {
  // Send enter/leave/over/out (status change) events when needed.
  if (previous_element != target_element) {
    const scoped_refptr<dom::Window>& view = event_init->view();

    // Send out and leave events.
    if (previous_element) {
      // LottiePlayer elements may change playback state.
      if (previous_element->AsLottiePlayer()) {
        previous_element->AsLottiePlayer()->OnUnHover();
      }

      dom::Document* previous_document = previous_element->node_document();

      event_init->set_related_target(target_element);
      if (is_pointer_event) {
        previous_element->DispatchEvent(new dom::PointerEvent(
            base::Tokens::pointerout(), view, *event_init));
        if (previous_document) {
          for (scoped_refptr<dom::Element> element = previous_element;
               element && element != nearest_common_ancestor;
               element = element->parent_element()) {
            DCHECK(element->AsHTMLElement()->IsDesignated());
            element->DispatchEvent(new dom::PointerEvent(
                base::Tokens::pointerleave(), web::Event::kNotBubbles,
                web::Event::kNotCancelable, view, *event_init));
          }
        }
      }

      // Send compatibility mapping mouse events for state changes.
      //   https://www.w3.org/TR/pointerevents/#mapping-for-devices-that-do-not-support-hover
      previous_element->DispatchEvent(
          new dom::MouseEvent(base::Tokens::mouseout(), view, *event_init));

      if (previous_document) {
        for (scoped_refptr<dom::Element> element = previous_element;
             element && element != nearest_common_ancestor;
             element = element->parent_element()) {
          DCHECK(element->AsHTMLElement()->IsDesignated());
          element->DispatchEvent(new dom::MouseEvent(
              base::Tokens::mouseleave(), web::Event::kNotBubbles,
              web::Event::kNotCancelable, view, *event_init));
        }

        if (!target_element ||
            previous_document != target_element->node_document()) {
          previous_document->SetIndicatedElement(NULL);
        }
      }
    }
  }
}

void SendStateChangeEnterEvents(
    bool is_pointer_event, scoped_refptr<dom::HTMLElement> previous_element,
    scoped_refptr<dom::HTMLElement> target_element,
    scoped_refptr<dom::Element> nearest_common_ancestor,
    dom::PointerEventInit* event_init) {
  // Send enter/leave/over/out (status change) events when needed.
  if (previous_element != target_element) {
    const scoped_refptr<dom::Window>& view = event_init->view();

    // Send over and enter events.
    if (target_element) {
      // LottiePlayer elements may change playback state.
      if (target_element->AsLottiePlayer()) {
        target_element->AsLottiePlayer()->OnHover();
      }

      event_init->set_related_target(previous_element);
      if (is_pointer_event) {
        target_element->DispatchEvent(new dom::PointerEvent(
            base::Tokens::pointerover(), view, *event_init));
        for (scoped_refptr<dom::Element> element = target_element;
             element && element != nearest_common_ancestor;
             element = element->parent_element()) {
          element->DispatchEvent(new dom::PointerEvent(
              base::Tokens::pointerenter(), web::Event::kNotBubbles,
              web::Event::kNotCancelable, view, *event_init));
        }
      }

      // Send compatibility mapping mouse events for state changes.
      //   https://www.w3.org/TR/pointerevents/#mapping-for-devices-that-do-not-support-hover
      target_element->DispatchEvent(
          new dom::MouseEvent(base::Tokens::mouseover(), view, *event_init));
      for (scoped_refptr<dom::Element> element = target_element;
           element && element != nearest_common_ancestor;
           element = element->parent_element()) {
        element->DispatchEvent(new dom::MouseEvent(
            base::Tokens::mouseenter(), web::Event::kNotBubbles,
            web::Event::kNotCancelable, view, *event_init));
      }
    }
  }
}

void SendCompatibilityMappingMouseEvent(
    const scoped_refptr<dom::HTMLElement>& target_element,
    const scoped_refptr<web::Event>& event,
    const dom::PointerEvent* pointer_event,
    const dom::PointerEventInit& event_init,
    std::set<std::string>* mouse_event_prevent_flags) {
  // Send compatibility mapping mouse event if needed.
  //   https://www.w3.org/TR/2015/REC-pointerevents-20150224/#compatibility-mapping-with-mouse-events
  bool has_compatibility_mouse_event = true;
  base::Token type = pointer_event->type();
  if (type == base::Tokens::pointerdown()) {
    // If the pointer event dispatched was pointerdown and the event was
    // canceled, then set the PREVENT MOUSE EVENT flag for this pointerType.
    if (event->default_prevented()) {
      mouse_event_prevent_flags->insert(pointer_event->pointer_type());
      has_compatibility_mouse_event = false;
    } else {
      type = base::Tokens::mousedown();
    }
  } else {
    has_compatibility_mouse_event =
        mouse_event_prevent_flags->find(pointer_event->pointer_type()) ==
        mouse_event_prevent_flags->end();
    if (type == base::Tokens::pointerup()) {
      // If the pointer event dispatched was pointerup, clear the PREVENT
      // MOUSE EVENT flag for this pointerType.
      mouse_event_prevent_flags->erase(pointer_event->pointer_type());
      type = base::Tokens::mouseup();
    } else if (type == base::Tokens::pointermove()) {
      type = base::Tokens::mousemove();
    } else {
      has_compatibility_mouse_event = false;
    }
  }
  if (has_compatibility_mouse_event) {
    target_element->DispatchEvent(
        new dom::MouseEvent(type, event_init.view(), event_init));
  }
}

void InitializePointerEventInitFromEvent(
    const dom::MouseEvent* const mouse_event,
    const dom::PointerEvent* pointer_event, dom::PointerEventInit* event_init) {
  // For EventInit
  event_init->set_bubbles(mouse_event->bubbles());
  event_init->set_cancelable(mouse_event->cancelable());

  // For UIEventInit
  event_init->set_view(mouse_event->view());
  event_init->set_detail(mouse_event->detail());
  event_init->set_which(mouse_event->which());

  // For EventModifierInit
  event_init->set_ctrl_key(mouse_event->ctrl_key());
  event_init->set_shift_key(mouse_event->shift_key());
  event_init->set_alt_key(mouse_event->alt_key());
  event_init->set_meta_key(mouse_event->meta_key());

  // For MouseEventInit
  event_init->set_screen_x(mouse_event->screen_x());
  event_init->set_screen_y(mouse_event->screen_y());
  event_init->set_client_x(mouse_event->screen_x());
  event_init->set_client_y(mouse_event->screen_y());
  event_init->set_button(mouse_event->button());
  event_init->set_buttons(mouse_event->buttons());
  event_init->set_related_target(mouse_event->related_target());
  if (pointer_event) {
    // For PointerEventInit
    event_init->set_pointer_id(pointer_event->pointer_id());
    event_init->set_width(pointer_event->width());
    event_init->set_height(pointer_event->height());
    event_init->set_pressure(pointer_event->pressure());
    event_init->set_tilt_x(pointer_event->tilt_x());
    event_init->set_tilt_y(pointer_event->tilt_y());
    event_init->set_pointer_type(pointer_event->pointer_type());
    event_init->set_is_primary(pointer_event->is_primary());
  }
}

void DispatchPointerEventsForScrollStart(
    scoped_refptr<dom::HTMLElement> element,
    dom::PointerEventInit* event_init) {
  const scoped_refptr<dom::Window>& view = event_init->view();
  element->DispatchEvent(
      new dom::PointerEvent(base::Tokens::pointercancel(), web::Event::kBubbles,
                            web::Event::kNotCancelable, view, *event_init));
  bool is_pointer_event = true;
  scoped_refptr<dom::HTMLElement> target_element = nullptr;
  scoped_refptr<dom::Element> nearest_common_ancestor = nullptr;
  SendStateChangeLeaveEvents(is_pointer_event, element, target_element,
                             nearest_common_ancestor, event_init);
}

math::Matrix3F GetCompleteTransformMatrix(dom::Element* element) {
  auto complete_matrix = math::Matrix3F::Identity();
  auto current_element = element;
  while (current_element) {
    LayoutBoxes* layout_boxes = GetLayoutBoxesIfNotEmpty(current_element);
    const Box* box = layout_boxes->boxes().front();
    complete_matrix = complete_matrix * box->GetCSSTransformForBox();
    current_element = current_element->parent_element();
  }
  return complete_matrix;
}

bool LayoutBoxesAreFixed(LayoutBoxes* layout_boxes) {
  const Boxes boxes = layout_boxes->boxes();
  const Box* box = boxes.front();
  if (!box->computed_style()) {
    return false;
  }

  return box->computed_style()->position() == cssom::KeywordValue::GetFixed();
}

bool ShouldConsiderElementAndChildren(dom::Element* element,
                                      math::Vector2dF* coordinate,
                                      bool consider_only_fixed_elements) {
  LayoutBoxes* layout_boxes = GetLayoutBoxesIfNotEmpty(element);
  if (!layout_boxes) {
    return false;
  }

  bool is_fixed_element = LayoutBoxesAreFixed(layout_boxes);
  if (consider_only_fixed_elements && !is_fixed_element) {
    return false;
  }
  return CanTargetElementAndChildren(element, coordinate);
}

}  // namespace

void TopmostEventTarget::ConsiderElement(dom::Element* element,
                                         const math::Vector2dF& coordinate,
                                         bool consider_only_fixed_elements) {
  if (!element) return;
  math::Vector2dF element_coordinate(coordinate);
  LayoutBoxes* layout_boxes = GetLayoutBoxesIfNotEmpty(element);
  bool consider_element_and_children = ShouldConsiderElementAndChildren(
      element, &element_coordinate, consider_only_fixed_elements);

  if (consider_element_and_children) {
    scoped_refptr<dom::HTMLElement> html_element = element->AsHTMLElement();
    if (html_element && html_element->CanBeDesignatedByPointerIfDisplayed()) {
      ConsiderBoxes(html_element, layout_boxes, element_coordinate);
    }
  }

  for (dom::Element* child_element = element->first_element_child();
       child_element; child_element = child_element->next_element_sibling()) {
    ConsiderElement(child_element, element_coordinate,
                    !consider_element_and_children);
  }
}

void TopmostEventTarget::ConsiderBoxes(
    const scoped_refptr<dom::HTMLElement>& html_element,
    LayoutBoxes* layout_boxes, const math::Vector2dF& coordinate) {
  const Boxes& boxes = layout_boxes->boxes();
  Vector2dLayoutUnit layout_coordinate(LayoutUnit(coordinate.x()),
                                       LayoutUnit(coordinate.y()));
  for (Boxes::const_iterator box_iterator = boxes.begin();
       box_iterator != boxes.end(); ++box_iterator) {
    Box* box = *box_iterator;
    do {
      if (box->IsUnderCoordinate(layout_coordinate)) {
        Box::RenderSequence render_sequence = box->GetRenderSequence();
        if (Box::IsRenderedLater(render_sequence, render_sequence_)) {
          html_element_ = html_element;
          box_ = box;
          render_sequence_.swap(render_sequence);
        }
      }
      box = box->GetSplitSibling();
    } while (box != NULL);
  }
}

void TopmostEventTarget::CancelScrollsInParentNavItems(
    scoped_refptr<dom::HTMLElement> target_element) {
  // Cancel any scrolls in the tree.
  std::vector<scoped_refptr<ui_navigation::NavItem>> scrolls_to_cancel;
  auto current_element = target_element;
  while (true) {
    if (!current_element->parent_element()) {
      break;
    }
    current_element = current_element->parent_element()->AsHTMLElement();
    auto current_ui_nav_item = current_element->GetUiNavItem();
    if (current_ui_nav_item) {
      scrolls_to_cancel.push_back(current_ui_nav_item);
    }
  }

  scroll_engine_->thread()->message_loop()->task_runner()->PostTask(
      FROM_HERE,
      base::Bind(&ui_navigation::scroll_engine::ScrollEngine::
                     CancelActiveScrollsForNavItems,
                 base::Unretained(scroll_engine_), scrolls_to_cancel));
}

void TopmostEventTarget::HandleScrollState(
    scoped_refptr<dom::HTMLElement> target_element,
    const dom::PointerEvent* pointer_event, dom::PointerState* pointer_state,
    dom::PointerEventInit* event_init) {
  // On pointer down, cancel any scrolls happening for UI nav items above
  // that element. Additionally, save the pointer coordinates.
  //
  // On pointer move, check if we've reached the threshold to start
  // scrolling. If we have, find the first scroll container we can scroll.
  // Then send that scroll container, initial pointer event coords, current
  // pointer event coords, scroll direction.
  bool pointer_type_is_accepted = pointer_event->pointer_type() == "mouse" ||
                                  pointer_event->pointer_type() == "pen" ||
                                  pointer_event->pointer_type() == "touch";
  if (!scroll_engine_ || !pointer_event || !pointer_type_is_accepted) {
    return;
  }

  bool should_clear_pointer_state =
      pointer_event->type() == base::Tokens::pointerup();

  auto pointer_id = pointer_event->pointer_id();
  auto pointer_coordinates =
      math::Vector2dF(pointer_event->client_x(), pointer_event->client_y());

  if (pointer_event->type() == base::Tokens::pointerdown()) {
    CancelScrollsInParentNavItems(target_element);

    auto initial_possible_scroll_targets =
        FindPossibleScrollTargets(target_element);
    pointer_state->SetPossibleScrollTargets(
        pointer_id, std::move(initial_possible_scroll_targets));
    if (HasAnyScrollTarget(initial_possible_scroll_targets.get())) {
      pointer_state->SetPendingPointerCaptureTargetOverride(pointer_id,
                                                            target_element);
    }

    auto transform_matrix = GetCompleteTransformMatrix(target_element.get());
    pointer_state->SetClientTransformMatrix(pointer_id, transform_matrix);
    pointer_state->SetClientCoordinates(pointer_id, pointer_coordinates);
    pointer_state->SetClientTimeStamp(pointer_id, pointer_event->time_stamp());
    return;
  }

  auto initial_coordinates = pointer_state->GetClientCoordinates(pointer_id);
  auto initial_time_stamp = pointer_state->GetClientTimeStamp(pointer_id);
  auto possible_scroll_targets =
      pointer_state->GetPossibleScrollTargets(pointer_id);
  auto initial_transform = pointer_state->GetClientTransformMatrix(pointer_id);

  if (pointer_event->type() == base::Tokens::pointermove() &&
      initial_coordinates.has_value() && initial_time_stamp.has_value() &&
      possible_scroll_targets) {
    cobalt::math::Vector2dF drag_vector =
        initial_coordinates.value() - pointer_coordinates;
    float x = drag_vector.x();
    float y = drag_vector.y();

    if (drag_vector.Length() >=
        ui_navigation::scroll_engine::kDragDistanceThreshold) {
      // Get major scroll direction.
      ui_navigation::scroll_engine::ScrollType scroll_type =
          std::abs(x) > std::abs(y)
              ? ui_navigation::scroll_engine::ScrollType::Horizontal
              : ui_navigation::scroll_engine::ScrollType::Vertical;
      auto element_to_scroll = FindFirstElementWithScrollType(
          possible_scroll_targets, scroll_type, x > 0, y > 0);
      if (!element_to_scroll) {
        return;
      }

      scoped_refptr<dom::HTMLElement> previous_html_element(
          previous_html_element_weak_);
      DispatchPointerEventsForScrollStart(previous_html_element, event_init);
      pointer_state->SetWasCancelled(pointer_id);
      pointer_state->ClearPendingPointerCaptureTargetOverride(pointer_id);

      should_clear_pointer_state = true;
      scroll_engine_->thread()->message_loop()->task_runner()->PostTask(
          FROM_HERE,
          base::Bind(
              &ui_navigation::scroll_engine::ScrollEngine::HandleScrollStart,
              base::Unretained(scroll_engine_),
              element_to_scroll->GetUiNavItem(), scroll_type, pointer_id,
              initial_coordinates.value(), initial_time_stamp.value(),
              pointer_coordinates, pointer_event->time_stamp(),
              initial_transform));
    }
  }

  if (should_clear_pointer_state) {
    pointer_state->ClearPossibleScrollTargets(pointer_id);
    pointer_state->ClearClientCoordinates(pointer_id);
    pointer_state->ClearTimeStamp(pointer_id);
    pointer_state->ClearMatrix(pointer_id);
  }
}

TopmostEventTarget::TopmostEventTarget(
    ui_navigation::scroll_engine::ScrollEngine* scroll_engine)
    : scroll_engine_(scroll_engine) {}

void TopmostEventTarget::MaybeSendPointerEvents(
    const scoped_refptr<web::Event>& event) {
  TRACE_EVENT0("cobalt::layout",
               "TopmostEventTarget::MaybeSendPointerEvents()");

  const dom::MouseEvent* const mouse_event =
      base::polymorphic_downcast<const dom::MouseEvent* const>(event.get());
  DCHECK(mouse_event);
  DCHECK(!html_element_);
  const dom::PointerEvent* pointer_event =
      (event->GetWrappableType() == base::GetTypeId<dom::PointerEvent>())
          ? base::polymorphic_downcast<const dom::PointerEvent* const>(
                event.get())
          : NULL;
  bool is_touchpad_event = false;

  // The target override element for the pointer event. This may not be the same
  // as the hit test target, and it also may not be set.
  scoped_refptr<dom::HTMLElement> target_override_element;

  // Store the data for the status change and pointer capture event(s).
  dom::PointerEventInit event_init;
  InitializePointerEventInitFromEvent(mouse_event, pointer_event, &event_init);
  const scoped_refptr<dom::Window>& view = event_init.view();
  if (!view) {
    return;
  }
  dom::PointerState* pointer_state = view->document()->pointer_state();
  if (pointer_event) {
    pointer_state->SetActiveButtonsState(pointer_event->pointer_id(),
                                         pointer_event->buttons());
    is_touchpad_event = pointer_event->pointer_type() == "touchpad";
    if (is_touchpad_event) {
      if (pointer_event->type() == base::Tokens::pointerdown()) {
        pointer_state->SetActive(pointer_event->pointer_id());
        // Implicitly capture the pointer to the active element.
        //   https://www.w3.org/TR/pointerevents/#implicit-pointer-capture
        scoped_refptr<dom::HTMLElement> html_element;
        if (view->document()->active_element()) {
          html_element = view->document()->active_element()->AsHTMLElement();
        }
        if (html_element) {
          pointer_state->SetPendingPointerCaptureTargetOverride(
              pointer_event->pointer_id(), html_element);
        }
      }
    } else {
      pointer_state->SetActive(pointer_event->pointer_id());
    }
    target_override_element = pointer_state->GetPointerCaptureOverrideElement(
        pointer_event->pointer_id(), &event_init);
  }

  scoped_refptr<dom::HTMLElement> target_element;
  if (target_override_element) {
    target_element = target_override_element;
  } else {
    // Do a hit test if there is no target override element.
    math::Vector2dF coordinate(static_cast<float>(event_init.client_x()),
                               static_cast<float>(event_init.client_y()));
    target_element = FindTopmostEventTarget(view->document(), coordinate);
  }

  if (target_element && pointer_event) {
    HandleScrollState(target_element, pointer_event, pointer_state,
                      &event_init);
  }

  bool event_was_cancelled = pointer_event && pointer_state->GetWasCancelled(
                                                  pointer_event->pointer_id());
  if (pointer_event && pointer_event->type() == base::Tokens::pointerup()) {
    pointer_state->ClearWasCancelled(pointer_event->pointer_id());
  }

  scoped_refptr<dom::HTMLElement> previous_html_element(
      previous_html_element_weak_);

  // The enter/leave status change events apply to all ancestors up to the
  // nearest common ancestor between the previous and current element.
  scoped_refptr<dom::Element> nearest_common_ancestor(
      GetNearestCommonAncestor(previous_html_element, target_element));

  if (!event_was_cancelled) {
    SendStateChangeLeaveEvents(pointer_event, previous_html_element,
                               target_element, nearest_common_ancestor,
                               &event_init);
  }

  if (target_element) {
    if (!event_was_cancelled) {
      target_element->DispatchEvent(event);
    }
  }

  if (pointer_event) {
    if (pointer_event->type() == base::Tokens::pointerup()) {
      if (is_touchpad_event) {
        // A touchpad becomes inactive after a pointerup.
        pointer_state->ClearActive(pointer_event->pointer_id());
      }
      // Implicit release of pointer capture.
      //   https://www.w3.org/TR/pointerevents/#implicit-release-of-pointer-capture
      pointer_state->ClearPendingPointerCaptureTargetOverride(
          pointer_event->pointer_id());
    }
    if (target_element && !is_touchpad_event && !event_was_cancelled) {
      SendCompatibilityMappingMouseEvent(target_element, event, pointer_event,
                                         event_init,
                                         &mouse_event_prevent_flags_);
    }
  }

  if (event_init.button() == 0 &&
      ((mouse_event->type() == base::Tokens::pointerup()) ||
       (mouse_event->type() == base::Tokens::mouseup()))) {
    // This is an 'up' event for the last pressed button indicating that no
    // more buttons are pressed.
    if (target_element && !is_touchpad_event) {
      // Send the click event if needed, which is not prevented by cancelling
      // the pointerdown event.
      //   https://www.w3.org/TR/uievents/#event-type-click
      //   https://www.w3.org/TR/pointerevents/#compatibility-mapping-with-mouse-events
      target_element->DispatchEvent(
          new dom::MouseEvent(base::Tokens::click(), view, event_init));
    }
    if (target_element && (pointer_event->pointer_type() != "mouse")) {
      // If it's not a mouse event, then releasing the last button means
      // that there is no longer an indicated element.
      dom::Document* document = target_element->node_document();
      if (document) {
        document->SetIndicatedElement(NULL);
        target_element = NULL;
      }
    }
  }

  SendStateChangeEnterEvents(pointer_event, previous_html_element,
                             target_element, nearest_common_ancestor,
                             &event_init);

  if (target_element) {
    // Touchpad input never indicates document elements.
    if (!is_touchpad_event) {
      dom::Document* document = target_element->node_document();
      if (document) {
        document->SetIndicatedElement(target_element);
      }
    }
    previous_html_element_weak_ = base::AsWeakPtr(target_element.get());
  } else {
    previous_html_element_weak_.reset();
  }
  DCHECK(!html_element_);
}

}  // namespace layout
}  // namespace cobalt