view.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/views/view.h"

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdlib>
#include <iomanip>
#include <iterator>
#include <memory>
#include <optional>
#include <sstream>
#include <string_view>
#include <utility>

#include "base/auto_reset.h"
#include "base/check_op.h"
#include "base/command_line.h"
#include "base/containers/adapters.h"
#include "base/containers/contains.h"
#include "base/containers/flat_set.h"
#include "base/debug/crash_logging.h"
#include "base/debug/dump_without_crashing.h"
#include "base/debug/stack_trace.h"
#include "base/feature_list.h"
#include "base/functional/callback_helpers.h"
#include "base/i18n/rtl.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/not_fatal_until.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/ranges/algorithm.h"
#include "base/scoped_observation.h"
#include "base/strings/utf_string_conversions.h"
#include "base/trace_event/common/trace_event_common.h"
#include "base/trace_event/trace_event.h"
#include "base/tracing/protos/chrome_track_event.pbzero.h"
#include "build/build_config.h"
#include "cc/paint/paint_flags.h"
#include "third_party/perfetto/include/perfetto/tracing/event_context.h"
#include "third_party/perfetto/include/perfetto/tracing/track_event.h"
#include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkScalar.h"
#include "ui/accessibility/ax_action_data.h"
#include "ui/actions/actions.h"
#include "ui/base/accelerators/accelerator_manager.h"
#include "ui/base/cursor/cursor.h"
#include "ui/base/dragdrop/drag_drop_types.h"
#include "ui/base/dragdrop/mojom/drag_drop_types.mojom.h"
#include "ui/base/dragdrop/os_exchange_data.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/metadata/base_type_conversion.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/color/color_provider.h"
#include "ui/compositor/clip_recorder.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/paint_context.h"
#include "ui/compositor/paint_recorder.h"
#include "ui/compositor/transform_recorder.h"
#include "ui/display/screen.h"
#include "ui/events/base_event_utils.h"
#include "ui/events/event.h"
#include "ui/events/event_constants.h"
#include "ui/events/event_target_iterator.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/geometry/transform.h"
#include "ui/gfx/scoped_canvas.h"
#include "ui/native_theme/native_theme.h"
#include "ui/views/accessibility/accessibility_paint_checks.h"
#include "ui/views/accessibility/ax_event_manager.h"
#include "ui/views/accessibility/ax_virtual_view.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/actions/action_view_interface.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/buildflags.h"
#include "ui/views/context_menu_controller.h"
#include "ui/views/controls/scroll_view.h"
#include "ui/views/drag_controller.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/views/interaction/element_tracker_views.h"
#include "ui/views/layout/fill_layout.h"
#include "ui/views/layout/layout_provider.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/view_observer.h"
#include "ui/views/view_tracker.h"
#include "ui/views/view_utils.h"
#include "ui/views/views_features.h"
#include "ui/views/views_switches.h"
#include "ui/views/widget/tooltip_manager.h"
#include "ui/views/widget/widget.h"

#if BUILDFLAG(IS_WIN)
#include "base/win/scoped_gdi_object.h"
#include "ui/native_theme/native_theme_win.h"
#endif

namespace ui {
class ClipboardFormatType;
enum class PropertyChangeReason;
}  // namespace ui

namespace views {

namespace {

#if BUILDFLAG(IS_WIN)
constexpr bool kContextMenuOnMousePress = false;
#else
constexpr bool kContextMenuOnMousePress = …;
#endif

// Default horizontal drag threshold in pixels.
// Same as what gtk uses.
constexpr int kDefaultHorizontalDragThreshold = …;

// Default vertical drag threshold in pixels.
// Same as what gtk uses.
constexpr int kDefaultVerticalDragThreshold = …;

// The following are used to offset the keys for the callbacks associated with
// the bounds element callbacks.
constexpr int kXChangedKey = …;
constexpr int kYChangedKey = …;
constexpr int kWidthChangedKey = …;
constexpr int kHeightChangedKey = …;

// Returns the top view in |view|'s hierarchy.
const View* GetHierarchyRoot(const View* view) { … }

}  // namespace

namespace internal {

#if DCHECK_IS_ON()
ScopedChildrenLock::ScopedChildrenLock(const View* view)
    : … { … }

ScopedChildrenLock::~ScopedChildrenLock() = default;
#else
ScopedChildrenLock::ScopedChildrenLock(const View* view) {}
ScopedChildrenLock::~ScopedChildrenLock() {}
#endif

}  // namespace internal

////////////////////////////////////////////////////////////////////////////////
// ViewMaskLayer
// This class is responsible for creating a masking layer for a view that paints
// to a layer. It tracks the size of the layer it is masking.
class VIEWS_EXPORT ViewMaskLayer : public ui::LayerDelegate,
                                   public ViewObserver { … };

ViewMaskLayer::ViewMaskLayer(const SkPath& path, View* observed_view)
    : … { … }

ViewMaskLayer::~ViewMaskLayer() { … }

void ViewMaskLayer::OnDeviceScaleFactorChanged(float old_device_scale_factor,
                                               float new_device_scale_factor) { … }

void ViewMaskLayer::OnPaintLayer(const ui::PaintContext& context) { … }

void ViewMaskLayer::OnViewBoundsChanged(View* observed_view) { … }

////////////////////////////////////////////////////////////////////////////////
// View, public:

// Creation and lifetime -------------------------------------------------------

View::View() { … }

View::~View() { … }

// Tree operations -------------------------------------------------------------

const Widget* View::GetWidget() const { … }

Widget* View::GetWidget() { … }

void View::ReorderChildView(View* view, size_t index) { … }

void View::RemoveChildView(View* view) { … }

void View::RemoveAllChildViews() { … }

void View::RemoveAllChildViewsWithoutDeleting() { … }

bool View::Contains(const View* view) const { … }

View::Views::const_iterator View::FindChild(const View* view) const { … }

std::optional<size_t> View::GetIndexOf(const View* view) const { … }

// Size and disposition --------------------------------------------------------

void View::SetBounds(int x, int y, int width, int height) { … }

void View::SetBoundsRect(const gfx::Rect& bounds) { … }

void View::SetSize(const gfx::Size& size) { … }

void View::SetPosition(const gfx::Point& position) { … }

void View::SetX(int x) { … }

void View::SetY(int y) { … }

gfx::Rect View::GetContentsBounds() const { … }

gfx::Rect View::GetLocalBounds() const { … }

gfx::Insets View::GetInsets() const { … }

gfx::Rect View::GetVisibleBounds() const { … }

gfx::Rect View::GetBoundsInScreen() const { … }

gfx::Rect View::GetAnchorBoundsInScreen() const { … }

gfx::Size View::GetPreferredSize(const SizeBounds& available_size) const { … }

int View::GetBaseline() const { … }

void View::SetPreferredSize(std::optional<gfx::Size> size) { … }

void View::SizeToPreferredSize() { … }

gfx::Size View::GetMinimumSize() const { … }

gfx::Size View::GetMaximumSize() const { … }

int View::GetHeightForWidth(int w) const { … }

SizeBounds View::GetAvailableSize(const View* child) const { … }

bool View::GetVisible() const { … }

void View::SetVisible(bool visible) { … }

base::CallbackListSubscription View::AddVisibleChangedCallback(
    PropertyChangedCallback callback) { … }

bool View::IsDrawn() const { … }

bool View::GetIsDrawn() const { … }

bool View::GetEnabled() const { … }

void View::SetEnabled(bool enabled) { … }

base::CallbackListSubscription View::AddEnabledChangedCallback(
    PropertyChangedCallback callback) { … }

View::Views View::GetChildrenInZOrder() { … }

// Transformations -------------------------------------------------------------

gfx::Transform View::GetTransform() const { … }

void View::SetClipPath(const SkPath& path) { … }

void View::SetTransform(const gfx::Transform& transform) { … }

void View::SetPaintToLayer(ui::LayerType layer_type) { … }

void View::DestroyLayer() { … }

void View::AddLayerToRegion(ui::Layer* new_layer, LayerRegion region) { … }

void View::RemoveLayerFromRegions(ui::Layer* old_layer) { … }

void View::RemoveLayerFromRegionsKeepInLayerTree(ui::Layer* old_layer) { … }

std::vector<ui::Layer*> View::GetLayersInOrder(ViewLayer view_layer) { … }

void View::LayerDestroyed(ui::Layer* layer) { … }

std::unique_ptr<ui::Layer> View::RecreateLayer() { … }

// RTL positioning -------------------------------------------------------------

gfx::Rect View::GetMirroredBounds() const { … }

gfx::Rect View::GetMirroredContentsBounds() const { … }

gfx::Point View::GetMirroredPosition() const { … }

int View::GetMirroredX() const { … }

int View::GetMirroredXForRect(const gfx::Rect& rect) const { … }

gfx::Rect View::GetMirroredRect(const gfx::Rect& rect) const { … }

int View::GetMirroredXInView(int x) const { … }

int View::GetMirroredXWithWidthInView(int x, int w) const { … }

// Layout ----------------------------------------------------------------------

void View::DeprecatedLayoutImmediately() { … }

void View::Layout(PassKey) { … }

void View::SetLayoutManagerUseConstrainedSpace(
    bool layout_manager_use_constrained_space) { … }

void View::InvalidateLayout() { … }

LayoutManager* View::GetLayoutManager() const { … }

void View::SetLayoutManager(std::nullptr_t) { … }

bool View::GetUseDefaultFillLayout() const { … }

void View::SetUseDefaultFillLayout(bool value) { … }

// Attributes ------------------------------------------------------------------

const View* View::GetViewByID(int id) const { … }

View* View::GetViewByID(int id) { … }

void View::SetID(int id) { … }

base::CallbackListSubscription View::AddIDChangedCallback(
    PropertyChangedCallback callback) { … }

void View::SetGroup(int gid) { … }

int View::GetGroup() const { … }

base::CallbackListSubscription View::AddGroupChangedCallback(
    PropertyChangedCallback callback) { … }

bool View::IsGroupFocusTraversable() const { … }

void View::GetViewsInGroup(int group, Views* views) { … }

View* View::GetSelectedViewForGroup(int group) { … }

std::string View::GetObjectName() const { … }

// Coordinate conversion -------------------------------------------------------

// static
void View::ConvertPointToTarget(const View* source,
                                const View* target,
                                gfx::Point* point) { … }

// static
gfx::Point View::ConvertPointToTarget(const View* source,
                                      const View* target,
                                      const gfx::Point& point) { … }

// static
void View::ConvertRectToTarget(const View* source,
                               const View* target,
                               gfx::RectF* rect) { … }

// static
gfx::RectF View::ConvertRectToTarget(const View* source,
                                     const View* target,
                                     const gfx::RectF& rect) { … }

// static
gfx::Rect View::ConvertRectToTarget(const View* source,
                                    const View* target,
                                    const gfx::Rect& rect) { … }

// static
void View::ConvertPointToWidget(const View* src, gfx::Point* p) { … }

// static
void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) { … }

// static
void View::ConvertPointToScreen(const View* src, gfx::Point* p) { … }

// static
gfx::Point View::ConvertPointToScreen(const View* src, const gfx::Point& p) { … }

// static
void View::ConvertPointFromScreen(const View* dst, gfx::Point* p) { … }

// static
gfx::Point View::ConvertPointFromScreen(const View* src, const gfx::Point& p) { … }

// static
void View::ConvertRectToScreen(const View* src, gfx::Rect* rect) { … }

gfx::Rect View::ConvertRectToParent(const gfx::Rect& rect) const { … }

gfx::Rect View::ConvertRectToWidget(const gfx::Rect& rect) const { … }

// Painting --------------------------------------------------------------------

void View::SchedulePaint() { … }

void View::SchedulePaintInRect(const gfx::Rect& rect) { … }

// The following is temporary. It is present to help diagnose a potential UaF.
std::string IntToHex(uint32_t value) { … }

void View::Paint(const PaintInfo& parent_paint_info) { … }

void View::SetBackground(std::unique_ptr<Background> b) { … }

Background* View::GetBackground() const { … }

void View::SetBorder(std::unique_ptr<Border> b) { … }

Border* View::GetBorder() const { … }

const ui::ThemeProvider* View::GetThemeProvider() const { … }

const LayoutProvider* View::GetLayoutProvider() const { … }

const ui::ColorProvider* View::GetColorProvider() const { … }

const ui::NativeTheme* View::GetNativeTheme() const { … }

// RTL painting ----------------------------------------------------------------

bool View::GetFlipCanvasOnPaintForRTLUI() const { … }

void View::SetFlipCanvasOnPaintForRTLUI(bool enable) { … }

base::CallbackListSubscription
View::AddFlipCanvasOnPaintForRTLUIChangedCallback(
    PropertyChangedCallback callback) { … }

void View::SetMirrored(bool is_mirrored) { … }

bool View::GetMirrored() const { … }

// Input -----------------------------------------------------------------------

View* View::GetEventHandlerForPoint(const gfx::Point& point) { … }

View* View::GetEventHandlerForRect(const gfx::Rect& rect) { … }

bool View::GetCanProcessEventsWithinSubtree() const { … }

void View::SetCanProcessEventsWithinSubtree(bool can_process) { … }

View* View::GetTooltipHandlerForPoint(const gfx::Point& point) { … }

ui::Cursor View::GetCursor(const ui::MouseEvent& event) { … }

bool View::HitTestPoint(const gfx::Point& point) const { … }

bool View::HitTestRect(const gfx::Rect& rect) const { … }

bool View::IsMouseHovered() const { … }

bool View::OnMousePressed(const ui::MouseEvent& event) { … }

bool View::OnMouseDragged(const ui::MouseEvent& event) { … }

void View::OnMouseReleased(const ui::MouseEvent& event) { … }

void View::OnMouseCaptureLost() { … }

void View::OnMouseMoved(const ui::MouseEvent& event) { … }

void View::OnMouseEntered(const ui::MouseEvent& event) { … }

void View::OnMouseExited(const ui::MouseEvent& event) { … }

void View::SetMouseAndGestureHandler(View* new_handler) { … }

void View::SetMouseHandler(View* new_handler) { … }

bool View::OnKeyPressed(const ui::KeyEvent& event) { … }

bool View::OnKeyReleased(const ui::KeyEvent& event) { … }

bool View::OnMouseWheel(const ui::MouseWheelEvent& event) { … }

void View::OnKeyEvent(ui::KeyEvent* event) { … }

void View::OnMouseEvent(ui::MouseEvent* event) { … }

void View::OnScrollEvent(ui::ScrollEvent* event) { … }

void View::OnTouchEvent(ui::TouchEvent* event) { … }

void View::OnGestureEvent(ui::GestureEvent* event) { … }

std::string_view View::GetLogContext() const { … }

void View::SetNotifyEnterExitOnChild(bool notify) { … }

bool View::GetNotifyEnterExitOnChild() const { … }

const ui::InputMethod* View::GetInputMethod() const { … }

std::unique_ptr<ViewTargeter> View::SetEventTargeter(
    std::unique_ptr<ViewTargeter> targeter) { … }

ViewTargeter* View::GetEffectiveViewTargeter() const { … }

WordLookupClient* View::GetWordLookupClient() { … }

bool View::CanAcceptEvent(const ui::Event& event) { … }

ui::EventTarget* View::GetParentTarget() { … }

std::unique_ptr<ui::EventTargetIterator> View::GetChildIterator() const { … }

ui::EventTargeter* View::GetEventTargeter() { … }

void View::ConvertEventToTarget(const ui::EventTarget* target,
                                ui::LocatedEvent* event) const { … }

gfx::PointF View::GetScreenLocationF(const ui::LocatedEvent& event) const { … }

// Accelerators ----------------------------------------------------------------

void View::AddAccelerator(const ui::Accelerator& accelerator) { … }

void View::RemoveAccelerator(const ui::Accelerator& accelerator) { … }

void View::ResetAccelerators() { … }

bool View::AcceleratorPressed(const ui::Accelerator& accelerator) { … }

bool View::CanHandleAccelerators() const { … }

// Focus -----------------------------------------------------------------------

bool View::HasFocus() const { … }

View* View::GetNextFocusableView() { … }

const View* View::GetNextFocusableView() const { … }

View* View::GetPreviousFocusableView() { … }

void View::RemoveFromFocusList() { … }

void View::InsertBeforeInFocusList(View* view) { … }

void View::InsertAfterInFocusList(View* view) { … }

View::Views View::GetChildrenFocusList() { … }

View::FocusBehavior View::GetFocusBehavior() const { … }

void View::SetFocusBehavior(FocusBehavior focus_behavior) { … }

bool View::IsFocusable() const { … }

FocusManager* View::GetFocusManager() { … }

const FocusManager* View::GetFocusManager() const { … }

void View::RequestFocus() { … }

bool View::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) { … }

FocusTraversable* View::GetFocusTraversable() { … }

FocusTraversable* View::GetPaneFocusTraversable() { … }

// Tooltips --------------------------------------------------------------------

std::u16string View::GetTooltipText(const gfx::Point& p) const { … }

// Context menus ---------------------------------------------------------------

void View::set_context_menu_controller(ContextMenuController* menu_controller) { … }

void View::ShowContextMenu(const gfx::Point& p,
                           ui::MenuSourceType source_type) { … }

gfx::Point View::GetKeyboardContextMenuLocation() { … }

// Drag and drop ---------------------------------------------------------------

bool View::GetDropFormats(int* formats,
                          std::set<ui::ClipboardFormatType>* format_types) { … }

bool View::AreDropTypesRequired() { … }

bool View::CanDrop(const OSExchangeData& data) { … }

void View::OnDragEntered(const ui::DropTargetEvent& event) { … }

int View::OnDragUpdated(const ui::DropTargetEvent& event) { … }

void View::OnDragExited() { … }

void View::OnDragDone() { … }

View::DropCallback View::GetDropCallback(const ui::DropTargetEvent& event) { … }

// static
bool View::ExceededDragThreshold(const gfx::Vector2d& delta) { … }

// Accessibility----------------------------------------------------------------

ViewAccessibility& View::GetViewAccessibility() const { … }

void View::SetAccessibilityProperties(
    std::optional<ax::mojom::Role> role,
    std::optional<std::u16string> name,
    std::optional<std::u16string> description,
    std::optional<std::u16string> role_description,
    std::optional<ax::mojom::NameFrom> name_from,
    std::optional<ax::mojom::DescriptionFrom> description_from) { … }

void View::SetAccessibleName(const std::u16string& name) { … }

void View::SetAccessibleName(std::u16string name,
                             ax::mojom::NameFrom name_from) { … }

void View::SetAccessibleName(View* naming_view) { … }

std::u16string View::GetAccessibleName() const { … }

void View::SetAccessibleRole(const ax::mojom::Role role) { … }

void View::SetAccessibleRole(const ax::mojom::Role role,
                             const std::u16string& role_description) { … }

ax::mojom::Role View::GetAccessibleRole() const { … }

void View::SetAccessibleDescription(const std::u16string& description) { … }

void View::SetAccessibleDescription(
    const std::u16string& description,
    ax::mojom::DescriptionFrom description_from) { … }

void View::SetAccessibleDescription(View* describing_view) { … }

std::u16string View::GetAccessibleDescription() const { … }

bool View::HandleAccessibleAction(const ui::AXActionData& action_data) { … }

gfx::NativeViewAccessible View::GetNativeViewAccessible() { … }

void View::NotifyAccessibilityEvent(ax::mojom::Event event_type,
                                    bool send_native_event) { … }

void View::OnAccessibilityEvent(ax::mojom::Event event_type) { … }

// Scrolling -------------------------------------------------------------------

void View::ScrollRectToVisible(const gfx::Rect& rect) { … }

void View::ScrollViewToVisible() { … }

void View::AddObserver(ViewObserver* observer) { … }

void View::RemoveObserver(ViewObserver* observer) { … }

bool View::HasObserver(const ViewObserver* observer) const { … }

////////////////////////////////////////////////////////////////////////////////
// View, protected:

// Size and disposition --------------------------------------------------------

gfx::Size View::CalculatePreferredSize(const SizeBounds& available_size) const { … }

void View::PreferredSizeChanged() { … }

bool View::GetNeedsNotificationWhenVisibleBoundsChange() const { … }

void View::OnVisibleBoundsChanged() { … }

// Tree operations -------------------------------------------------------------

void View::ViewHierarchyChanged(const ViewHierarchyChangedDetails& details) { … }

void View::VisibilityChanged(View* starting_from, bool is_visible) { … }

void View::NativeViewHierarchyChanged() { … }

void View::AddedToWidget() { … }

void View::RemovedFromWidget() { … }

// Painting --------------------------------------------------------------------

void View::OnDidSchedulePaint(const gfx::Rect& rect) { … }

void View::PaintChildren(const PaintInfo& paint_info) { … }

void View::OnPaint(gfx::Canvas* canvas) { … }

void View::OnPaintBackground(gfx::Canvas* canvas) { … }

void View::OnPaintBorder(gfx::Canvas* canvas) { … }

// Accelerated Painting --------------------------------------------------------

View::LayerOffsetData View::CalculateOffsetToAncestorWithLayer(
    ui::Layer** layer_parent) { … }

void View::UpdateParentLayer() { … }

void View::MoveLayerToParent(ui::Layer* parent_layer,
                             const LayerOffsetData& offset_data) { … }

void View::UpdateLayerVisibility() { … }

void View::UpdateChildLayerVisibility(bool ancestor_visible) { … }

void View::DestroyLayerImpl(LayerChangeNotifyBehavior notify_parents) { … }

void View::NotifyParentsOfLayerChange() { … }

void View::UpdateChildLayerBounds(const LayerOffsetData& offset_data) { … }

void View::OnPaintLayer(const ui::PaintContext& context) { … }

void View::OnLayerTransformed(const gfx::Transform& old_transform,
                              ui::PropertyChangeReason reason) { … }

void View::OnLayerClipRectChanged(const gfx::Rect& old_rect,
                                  ui::PropertyChangeReason reason) { … }

void View::OnDeviceScaleFactorChanged(float old_device_scale_factor,
                                      float new_device_scale_factor) { … }

void View::CreateOrDestroyLayer() { … }

void View::ReorderLayers() { … }

void View::AddLayerToRegionImpl(
    ui::Layer* new_layer,
    std::vector<raw_ptr<ui::Layer, VectorExperimental>>& layer_vector) { … }

void View::SetLayerParent(ui::Layer* parent_layer) { … }

void View::ReorderChildLayers(ui::Layer* parent_layer) { … }

void View::OnChildLayerChanged(View* child) { … }

// Input -----------------------------------------------------------------------

View::DragInfo* View::GetDragInfo() { … }

// Focus -----------------------------------------------------------------------

void View::OnFocus() { … }

void View::OnBlur() { … }

void View::Focus() { … }

void View::Blur() { … }

// System events ---------------------------------------------------------------

void View::OnThemeChanged() { … }

// Tooltips --------------------------------------------------------------------

void View::TooltipTextChanged() { … }

void View::UpdateTooltipForFocus() { … }

// Drag and drop ---------------------------------------------------------------

int View::GetDragOperations(const gfx::Point& press_pt) { … }

void View::WriteDragData(const gfx::Point& press_pt, OSExchangeData* data) { … }

bool View::InDrag() const { … }

int View::GetHorizontalDragThreshold() { … }

int View::GetVerticalDragThreshold() { … }

PaintInfo::ScaleType View::GetPaintScaleType() const { … }

void View::HandlePropertyChangeEffects(PropertyEffects effects) { … }

void View::AfterPropertyChange(const void* key, int64_t old_value) { … }

void View::OnPropertyChanged(ui::metadata::PropertyKey property,
                             PropertyEffects property_effects) { … }

int View::GetX() const { … }

int View::GetY() const { … }

int View::GetWidth() const { … }

int View::GetHeight() const { … }

void View::SetWidth(int width) { … }

void View::SetHeight(int height) { … }

std::u16string View::GetTooltip() const { … }

////////////////////////////////////////////////////////////////////////////////
// View, private:

// DropInfo --------------------------------------------------------------------

void View::DragInfo::Reset() { … }

void View::DragInfo::PossibleDrag(const gfx::Point& p) { … }

// Painting --------------------------------------------------------------------

void View::SchedulePaintInRectImpl(const gfx::Rect& rect) { … }

void View::SchedulePaintBoundsChanged(bool size_changed) { … }

void View::SchedulePaintOnParent() { … }

bool View::ShouldPaint() const { … }

void View::SetUpTransformRecorderForPainting(
    const gfx::Vector2d& offset_from_parent,
    ui::TransformRecorder* recorder) const { … }

void View::RecursivePaintHelper(void (View::*func)(const PaintInfo&),
                                const PaintInfo& info) { … }

void View::PaintFromPaintRoot(const ui::PaintContext& parent_context) { … }

void View::PaintDebugRects(const PaintInfo& parent_paint_info) { … }

// Tree operations -------------------------------------------------------------

void View::AddChildViewAtImpl(View* view, size_t index) { … }

void View::DoRemoveChildView(View* view,
                             bool update_tool_tip,
                             bool delete_removed_view,
                             View* new_parent) { … }

void View::PropagateRemoveNotifications(View* old_parent,
                                        View* new_parent,
                                        bool is_removed_from_widget) { … }

void View::PropagateAddNotifications(const ViewHierarchyChangedDetails& details,
                                     bool is_added_to_widget) { … }

void View::PropagateNativeViewHierarchyChanged() { … }

void View::ViewHierarchyChangedImpl(
    const ViewHierarchyChangedDetails& details) { … }

// Size and disposition --------------------------------------------------------

void View::PropagateVisibilityNotifications(View* start, bool is_visible) { … }

void View::VisibilityChangedImpl(View* starting_from, bool is_visible) { … }

void View::SnapLayerToPixelBoundary(const LayerOffsetData& offset_data) { … }

// static
void View::RegisterChildrenForVisibleBoundsNotification(View* view) { … }

// static
void View::UnregisterChildrenForVisibleBoundsNotification(View* view) { … }

void View::RegisterForVisibleBoundsNotification() { … }

void View::UnregisterForVisibleBoundsNotification() { … }

void View::AddDescendantToNotify(View* view) { … }

void View::RemoveDescendantToNotify(View* view) { … }

void View::SetLayoutManagerImpl(std::unique_ptr<LayoutManager> layout_manager) { … }

void View::SetToDefaultFillLayout() { … }

void View::SetLayerBounds(const gfx::Size& size,
                          const LayerOffsetData& offset_data) { … }

// Transformations -------------------------------------------------------------

bool View::GetTransformRelativeTo(const View* ancestor,
                                  gfx::Transform* transform) const { … }

// Coordinate conversion -------------------------------------------------------

bool View::ConvertPointForAncestor(const View* ancestor,
                                   gfx::Point* point) const { … }

bool View::ConvertPointFromAncestor(const View* ancestor,
                                    gfx::Point* point) const { … }

bool View::ConvertRectForAncestor(const View* ancestor,
                                  gfx::RectF* rect) const { … }

bool View::ConvertRectFromAncestor(const View* ancestor,
                                   gfx::RectF* rect) const { … }

// Accelerated painting --------------------------------------------------------

void View::CreateLayer(ui::LayerType layer_type) { … }

bool View::UpdateParentLayers() { … }

void View::OrphanLayers() { … }

void View::ReparentLayer(ui::Layer* parent_layer) { … }

void View::CreateMaskLayer() { … }

// Layout ----------------------------------------------------------------------

bool View::HasLayoutManager() const { … }

void View::LayoutImmediately() { … }

// Input -----------------------------------------------------------------------

bool View::ProcessMousePressed(const ui::MouseEvent& event) { … }

void View::ProcessMouseDragged(ui::MouseEvent* event) { … }

void View::ProcessMouseReleased(const ui::MouseEvent& event) { … }

// Accelerators ----------------------------------------------------------------

void View::RegisterPendingAccelerators() { … }

void View::UnregisterAccelerators(bool leave_data_intact) { … }

// Focus -----------------------------------------------------------------------

void View::SetFocusSiblings(View* view, Views::const_iterator pos) { … }

void View::AdvanceFocusIfNecessary() { … }

// System events ---------------------------------------------------------------

void View::PropagateThemeChanged() { … }

void View::PropagateDeviceScaleFactorChanged(float old_device_scale_factor,
                                             float new_device_scale_factor) { … }

// Tooltips --------------------------------------------------------------------

void View::UpdateTooltip() { … }

bool View::kShouldDisableKeyboardTooltipsForTesting = …;

void View::DisableKeyboardTooltipsForTesting() { … }

void View::EnableKeyboardTooltipsForTesting() { … }

// Drag and drop ---------------------------------------------------------------

bool View::DoDrag(const ui::LocatedEvent& event,
                  const gfx::Point& press_pt,
                  ui::mojom::DragEventSource source) { … }

std::unique_ptr<ActionViewInterface> View::GetActionViewInterface() { … }

base::CallbackListSubscription View::RegisterNotifyViewControllerCallback(
    base::RepeatingClosureList::CallbackType callback) { … }

void View::NotifyViewControllerCallback() { … }

BaseActionViewInterface::BaseActionViewInterface(View* action_view)
    : … { … }

void BaseActionViewInterface::ActionItemChangedImpl(
    actions::ActionItem* action_item) { … }

// This block requires the existence of METADATA_HEADER_BASE(View) in the class
// declaration for View.
BEGIN_METADATA_BASE(…)

}  // namespace views

DEFINE_ENUM_CONVERTERS(…)
chromium/ui/views/view.cc
