ellyjones@chromium.org
msw@chromium.org
pkasting@chromium.org
sky@chromium.org
tapted@chromium.org
# NOTE: Do not use the above owners when you're in a subdirectory that has
# OWNERS file. Prefer these instead as these OWNERS will be more familiar, and
# to load balance. Only use the above for subdirectories when doing refactorings
# that touch all the platforms.

# This is for the common case of adding or renaming files. If you're doing
# structural changes, use usual OWNERS rules.
per-file BUILD.gn=*

per-file tab_helpers.*=avi@chromium.org

# Instant/Search files.
per-file browser_instant_controller*=file://chrome/browser/search/OWNERS

# Signin and avatars.
per-file avatar_*=file://components/signin/OWNERS
per-file signin_*=file://components/signin/OWNERS

per-file settings_window_manager*chromeos*=file://chrome/browser/ui/ash/OWNERS

# COMPONENT: UI>Browser
