Commit 27871aa8 authored by Evan Stade's avatar Evan Stade Committed by Commit Bot

Combine ImmersiveFocusWatcher{Mus,Classic}.

Use of TransientWindowClient and ActivationClient allow the same
implementation to work in both classic and Mash.

Bug: 640365
Change-Id: I10324dce04bb014c09d04f45c0be6e691017a648
Reviewed-on: https://chromium-review.googlesource.com/c/1271403Reviewed-by: default avatarScott Violet <sky@chromium.org>
Reviewed-by: default avatarJames Cook <jamescook@chromium.org>
Commit-Queue: Evan Stade <estade@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600119}
parent de56eaf9
......@@ -1141,8 +1141,6 @@ component("ash") {
"wm/gestures/overview_gesture_handler.h",
"wm/immersive_context_ash.cc",
"wm/immersive_context_ash.h",
"wm/immersive_focus_watcher_classic.cc",
"wm/immersive_focus_watcher_classic.h",
"wm/immersive_gesture_handler_classic.cc",
"wm/immersive_gesture_handler_classic.h",
"wm/immersive_handler_factory_ash.cc",
......
......@@ -70,6 +70,7 @@ component("cpp") {
"frame_utils.h",
"gesture_action_type.h",
"immersive/immersive_context.h",
"immersive/immersive_focus_watcher.cc",
"immersive/immersive_focus_watcher.h",
"immersive/immersive_fullscreen_controller.cc",
"immersive/immersive_fullscreen_controller.h",
......@@ -135,6 +136,7 @@ component("cpp") {
"//ui/views",
"//ui/views/mus",
"//ui/wm",
"//ui/wm/public",
]
public_deps = [
......
// Copyright 2016 The Chromium Authors. All rights reserved.
// Copyright 2018 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 "ash/wm/immersive_focus_watcher_classic.h"
#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
#include "ash/public/cpp/immersive/immersive_fullscreen_controller.h"
#include "ui/aura/client/transient_window_client.h"
#include "ui/aura/window.h"
#include "ui/views/bubble/bubble_dialog_delegate_view.h"
#include "ui/views/view.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/core/transient_window_manager.h"
#include "ui/wm/core/window_util.h"
#include "ui/wm/public/activation_client.h"
namespace ash {
namespace {
// Returns the BubbleDialogDelegateView corresponding to |maybe_bubble| if
......@@ -40,8 +40,10 @@ bool IsWindowTransientChildOf(aura::Window* maybe_transient,
if (!maybe_transient || !toplevel)
return false;
aura::client::TransientWindowClient* transient_window_client =
aura::client::GetTransientWindowClient();
for (aura::Window* window = maybe_transient; window;
window = ::wm::GetTransientParent(window)) {
window = transient_window_client->GetTransientParent(window)) {
if (window == toplevel)
return true;
}
......@@ -60,8 +62,7 @@ bool IsWindowTransientChildOf(aura::Window* maybe_transient,
// so that bubbles which are not activatable and bubbles which do not close
// upon deactivation also keep the top-of-window views revealed for the
// duration of their visibility.
class ImmersiveFocusWatcherClassic::BubbleObserver
: public aura::WindowObserver {
class ImmersiveFocusWatcher::BubbleObserver : public aura::WindowObserver {
public:
explicit BubbleObserver(ImmersiveFullscreenController* controller);
~BubbleObserver() override;
......@@ -89,16 +90,16 @@ class ImmersiveFocusWatcherClassic::BubbleObserver
DISALLOW_COPY_AND_ASSIGN(BubbleObserver);
};
ImmersiveFocusWatcherClassic::BubbleObserver::BubbleObserver(
ImmersiveFocusWatcher::BubbleObserver::BubbleObserver(
ImmersiveFullscreenController* controller)
: controller_(controller) {}
ImmersiveFocusWatcherClassic::BubbleObserver::~BubbleObserver() {
ImmersiveFocusWatcher::BubbleObserver::~BubbleObserver() {
for (aura::Window* bubble : bubbles_)
bubble->RemoveObserver(this);
}
void ImmersiveFocusWatcherClassic::BubbleObserver::StartObserving(
void ImmersiveFocusWatcher::BubbleObserver::StartObserving(
aura::Window* bubble) {
if (bubbles_.insert(bubble).second) {
bubble->AddObserver(this);
......@@ -106,7 +107,7 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::StartObserving(
}
}
void ImmersiveFocusWatcherClassic::BubbleObserver::StopObserving(
void ImmersiveFocusWatcher::BubbleObserver::StopObserving(
aura::Window* bubble) {
if (bubbles_.erase(bubble)) {
bubble->RemoveObserver(this);
......@@ -114,7 +115,7 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::StopObserving(
}
}
void ImmersiveFocusWatcherClassic::BubbleObserver::UpdateRevealedLock() {
void ImmersiveFocusWatcher::BubbleObserver::UpdateRevealedLock() {
bool has_visible_bubble = false;
for (aura::Window* bubble : bubbles_) {
if (bubble->IsVisible()) {
......@@ -147,35 +148,37 @@ void ImmersiveFocusWatcherClassic::BubbleObserver::UpdateRevealedLock() {
}
}
void ImmersiveFocusWatcherClassic::BubbleObserver::OnWindowVisibilityChanged(
void ImmersiveFocusWatcher::BubbleObserver::OnWindowVisibilityChanged(
aura::Window*,
bool visible) {
UpdateRevealedLock();
}
void ImmersiveFocusWatcherClassic::BubbleObserver::OnWindowDestroying(
void ImmersiveFocusWatcher::BubbleObserver::OnWindowDestroying(
aura::Window* window) {
StopObserving(window);
}
ImmersiveFocusWatcherClassic::ImmersiveFocusWatcherClassic(
ImmersiveFocusWatcher::ImmersiveFocusWatcher(
ImmersiveFullscreenController* controller)
: immersive_fullscreen_controller_(controller) {
GetWidget()->GetFocusManager()->AddFocusChangeListener(this);
GetWidget()->AddObserver(this);
::wm::TransientWindowManager::GetOrCreate(GetWidgetWindow())
aura::client::GetTransientWindowClient()->AddObserver(this);
::wm::GetActivationClient(GetWidgetWindow()->GetRootWindow())
->AddObserver(this);
RecreateBubbleObserver();
}
ImmersiveFocusWatcherClassic::~ImmersiveFocusWatcherClassic() {
::wm::TransientWindowManager::GetOrCreate(GetWidgetWindow())
->RemoveObserver(this);
ImmersiveFocusWatcher::~ImmersiveFocusWatcher() {
aura::client::GetTransientWindowClient()->RemoveObserver(this);
GetWidget()->GetFocusManager()->RemoveFocusChangeListener(this);
GetWidget()->RemoveObserver(this);
auto* activation_client =
::wm::GetActivationClient(GetWidgetWindow()->GetRootWindow());
if (activation_client)
activation_client->RemoveObserver(this);
}
void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
void ImmersiveFocusWatcher::UpdateFocusRevealedLock() {
views::Widget* widget = GetWidget();
views::View* top_container =
immersive_fullscreen_controller_->top_container();
......@@ -185,7 +188,7 @@ void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
if (top_container->Contains(focused_view))
hold_lock = true;
} else {
aura::Window* native_window = widget->GetNativeWindow();
aura::Window* native_window = GetWidgetWindow();
aura::Window* active_window =
::wm::GetActivationClient(native_window->GetRootWindow())
->GetActiveWindow();
......@@ -223,22 +226,23 @@ void ImmersiveFocusWatcherClassic::UpdateFocusRevealedLock() {
}
}
void ImmersiveFocusWatcherClassic::ReleaseLock() {
void ImmersiveFocusWatcher::ReleaseLock() {
lock_.reset();
}
views::Widget* ImmersiveFocusWatcherClassic::GetWidget() {
views::Widget* ImmersiveFocusWatcher::GetWidget() {
return immersive_fullscreen_controller_->widget();
}
aura::Window* ImmersiveFocusWatcherClassic::GetWidgetWindow() {
aura::Window* ImmersiveFocusWatcher::GetWidgetWindow() {
return GetWidget()->GetNativeWindow();
}
void ImmersiveFocusWatcherClassic::RecreateBubbleObserver() {
void ImmersiveFocusWatcher::RecreateBubbleObserver() {
bubble_observer_.reset(new BubbleObserver(immersive_fullscreen_controller_));
const std::vector<aura::Window*> transient_children =
::wm::GetTransientChildren(GetWidgetWindow());
aura::client::GetTransientWindowClient()->GetTransientChildren(
GetWidgetWindow());
for (size_t i = 0; i < transient_children.size(); ++i) {
aura::Window* transient_child = transient_children[i];
views::View* anchor_view = GetAnchorView(transient_child);
......@@ -249,22 +253,22 @@ void ImmersiveFocusWatcherClassic::RecreateBubbleObserver() {
}
}
void ImmersiveFocusWatcherClassic::OnWillChangeFocus(
views::View* focused_before,
views::View* focused_now) {}
void ImmersiveFocusWatcher::OnWillChangeFocus(views::View* focused_before,
views::View* focused_now) {}
void ImmersiveFocusWatcherClassic::OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) {
void ImmersiveFocusWatcher::OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) {
UpdateFocusRevealedLock();
}
void ImmersiveFocusWatcherClassic::OnWidgetActivationChanged(
views::Widget* widget,
bool active) {
void ImmersiveFocusWatcher::OnWindowActivated(
::wm::ActivationChangeObserver::ActivationReason reason,
aura::Window* gaining_active,
aura::Window* losing_active) {
UpdateFocusRevealedLock();
}
void ImmersiveFocusWatcherClassic::OnTransientChildAdded(
void ImmersiveFocusWatcher::OnTransientChildWindowAdded(
aura::Window* window,
aura::Window* transient) {
views::View* anchor = GetAnchorView(transient);
......@@ -277,7 +281,7 @@ void ImmersiveFocusWatcherClassic::OnTransientChildAdded(
}
}
void ImmersiveFocusWatcherClassic::OnTransientChildRemoved(
void ImmersiveFocusWatcher::OnTransientChildWindowRemoved(
aura::Window* window,
aura::Window* transient) {
bubble_observer_->StopObserving(transient);
......
// Copyright 2016 The Chromium Authors. All rights reserved.
// Copyright 2018 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.
#ifndef ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_FOCUS_WATCHER_H_
#define ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_FOCUS_WATCHER_H_
#include "ash/public/cpp/ash_public_export.h"
#include "ui/aura/client/focus_change_observer.h"
#include "ui/aura/client/transient_window_client_observer.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/wm/public/activation_change_observer.h"
namespace ash {
class ImmersiveFullscreenController;
class ImmersiveRevealedLock;
// ImmersiveFocusWatcher is responsible for grabbing a reveal lock based on
// activation and/or focus.
class ASH_PUBLIC_EXPORT ImmersiveFocusWatcher {
// activation and/or focus. This implementation grabs a lock if views focus is
// in the top view, a bubble is showing that is anchored to the top view, or
// the focused window is a transient child of the top view's widget.
class ImmersiveFocusWatcher
: public views::FocusChangeListener,
public aura::client::TransientWindowClientObserver,
public ::wm::ActivationChangeObserver {
public:
virtual ~ImmersiveFocusWatcher() {}
explicit ImmersiveFocusWatcher(ImmersiveFullscreenController* controller);
~ImmersiveFocusWatcher() override;
// Forces updating the status of the lock. That is, this determines whether
// a lock should be held and updates accordingly. The lock is automatically
// maintained, but this function may be called to force an update.
virtual void UpdateFocusRevealedLock() = 0;
void UpdateFocusRevealedLock();
// Explicitly releases the lock, does nothing if a lock is not held.
virtual void ReleaseLock() = 0;
void ReleaseLock();
private:
class BubbleObserver;
views::Widget* GetWidget();
aura::Window* GetWidgetWindow();
// Recreate |bubble_observer_| and start observing any bubbles anchored to a
// child of |top_container_|.
void RecreateBubbleObserver();
// views::FocusChangeListener overrides:
void OnWillChangeFocus(views::View* focused_before,
views::View* focused_now) override;
void OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) override;
// aura::client::TransientWindowClientObserver overrides:
void OnTransientChildWindowAdded(aura::Window* window,
aura::Window* transient) override;
void OnTransientChildWindowRemoved(aura::Window* window,
aura::Window* transient) override;
// ::wm::ActivationChangeObserver:
void OnWindowActivated(
::wm::ActivationChangeObserver::ActivationReason reason,
aura::Window* gaining_active,
aura::Window* losing_active) override;
ImmersiveFullscreenController* immersive_fullscreen_controller_;
// Lock which keeps the top-of-window views revealed based on the focused view
// and the active widget. Acquiring the lock never triggers a reveal because
// a view is not focusable till a reveal has made it visible.
std::unique_ptr<ImmersiveRevealedLock> lock_;
// Manages bubbles which are anchored to a child of
// |ImmersiveFullscreenController::top_container_|.
std::unique_ptr<BubbleObserver> bubble_observer_;
DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcher);
};
} // namespace ash
......
......@@ -327,8 +327,7 @@ void ImmersiveFullscreenController::EnableEventObservers(bool enable) {
aura::Env* env = widget_->GetNativeWindow()->env();
if (enable) {
immersive_focus_watcher_ =
ImmersiveHandlerFactory::Get()->CreateFocusWatcher(this);
immersive_focus_watcher_ = std::make_unique<ImmersiveFocusWatcher>(this);
immersive_gesture_handler_ =
ImmersiveHandlerFactory::Get()->CreateGestureHandler(this);
std::set<ui::EventType> types = {
......
......@@ -11,7 +11,6 @@
namespace ash {
class ImmersiveFocusWatcher;
class ImmersiveFullscreenController;
class ImmersiveGestureHandler;
......@@ -20,9 +19,6 @@ class ASH_PUBLIC_EXPORT ImmersiveHandlerFactory {
public:
static ImmersiveHandlerFactory* Get() { return instance_; }
virtual std::unique_ptr<ImmersiveFocusWatcher> CreateFocusWatcher(
ImmersiveFullscreenController* controller) = 0;
virtual std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
ImmersiveFullscreenController* controller) = 0;
......
// Copyright 2016 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.
#ifndef ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_
#define ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_
#include "ash/ash_export.h"
#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/views/widget/widget_observer.h"
#include "ui/wm/core/transient_window_observer.h"
namespace ash {
class ImmersiveFullscreenController;
class ImmersiveRevealedLock;
// ImmersiveFocusWatcher is responsible for grabbing a reveal lock based on
// activation and/or focus. This implementation grabs a lock if views focus is
// in the top view, or a bubble is showing that is anchored to the top view.
class ASH_EXPORT ImmersiveFocusWatcherClassic
: public ImmersiveFocusWatcher,
public views::FocusChangeListener,
public views::WidgetObserver,
public ::wm::TransientWindowObserver {
public:
explicit ImmersiveFocusWatcherClassic(
ImmersiveFullscreenController* controller);
~ImmersiveFocusWatcherClassic() override;
// ImmersiveFocusWatcher:
void UpdateFocusRevealedLock() override;
void ReleaseLock() override;
private:
class BubbleObserver;
views::Widget* GetWidget();
aura::Window* GetWidgetWindow();
// Recreate |bubble_observer_| and start observing any bubbles anchored to a
// child of |top_container_|.
void RecreateBubbleObserver();
// views::FocusChangeObserver overrides:
void OnWillChangeFocus(views::View* focused_before,
views::View* focused_now) override;
void OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) override;
// views::WidgetObserver overrides:
void OnWidgetActivationChanged(views::Widget* widget, bool active) override;
// ::wm::TransientWindowObserver overrides:
void OnTransientChildAdded(aura::Window* window,
aura::Window* transient) override;
void OnTransientChildRemoved(aura::Window* window,
aura::Window* transient) override;
ImmersiveFullscreenController* immersive_fullscreen_controller_;
// Lock which keeps the top-of-window views revealed based on the focused view
// and the active widget. Acquiring the lock never triggers a reveal because
// a view is not focusable till a reveal has made it visible.
std::unique_ptr<ImmersiveRevealedLock> lock_;
// Manages bubbles which are anchored to a child of
// |ImmersiveFullscreenController::top_container_|.
std::unique_ptr<BubbleObserver> bubble_observer_;
DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcherClassic);
};
} // namespace ash
#endif // ASH_WM_IMMERSIVE_FOCUS_WATCHER_CLASSIC_H_
......@@ -6,7 +6,6 @@
#include <memory>
#include "ash/wm/immersive_focus_watcher_classic.h"
#include "ash/wm/immersive_gesture_handler_classic.h"
namespace ash {
......@@ -15,12 +14,6 @@ ImmersiveHandlerFactoryAsh::ImmersiveHandlerFactoryAsh() = default;
ImmersiveHandlerFactoryAsh::~ImmersiveHandlerFactoryAsh() = default;
std::unique_ptr<ImmersiveFocusWatcher>
ImmersiveHandlerFactoryAsh::CreateFocusWatcher(
ImmersiveFullscreenController* controller) {
return std::make_unique<ImmersiveFocusWatcherClassic>(controller);
}
std::unique_ptr<ImmersiveGestureHandler>
ImmersiveHandlerFactoryAsh::CreateGestureHandler(
ImmersiveFullscreenController* controller) {
......
......@@ -17,8 +17,6 @@ class ASH_EXPORT ImmersiveHandlerFactoryAsh : public ImmersiveHandlerFactory {
~ImmersiveHandlerFactoryAsh() override;
// ImmersiveHandlerFactory:
std::unique_ptr<ImmersiveFocusWatcher> CreateFocusWatcher(
ImmersiveFullscreenController* controller) override;
std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
ImmersiveFullscreenController* controller) override;
......
......@@ -1444,8 +1444,6 @@ jumbo_split_static_library("ui") {
"views/frame/browser_non_client_frame_view_ash.h",
"views/frame/immersive_context_mus.cc",
"views/frame/immersive_context_mus.h",
"views/frame/immersive_focus_watcher_mus.cc",
"views/frame/immersive_focus_watcher_mus.h",
"views/frame/immersive_handler_factory_mus.cc",
"views/frame/immersive_handler_factory_mus.h",
"views/frame/immersive_mode_controller_ash.cc",
......
// Copyright 2018 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.
#ifndef CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_
#define CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_
#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
#include "ui/aura/client/focus_change_observer.h"
#include "ui/aura/client/transient_window_client_observer.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/wm/public/activation_change_observer.h"
namespace ash {
class ImmersiveFullscreenController;
class ImmersiveRevealedLock;
} // namespace ash
// ImmersiveFocusWatcherMus is responsible for grabbing a reveal lock based on
// activation and/or focus. This implementation grabs a lock if views focus is
// in the top view, a bubble is showing that is anchored to the top view, or
// the focused window is a transient child of the top view's widget.
class ImmersiveFocusWatcherMus
: public ash::ImmersiveFocusWatcher,
public views::FocusChangeListener,
public aura::client::TransientWindowClientObserver,
public ::wm::ActivationChangeObserver {
public:
explicit ImmersiveFocusWatcherMus(
ash::ImmersiveFullscreenController* controller);
~ImmersiveFocusWatcherMus() override;
// ImmersiveFocusWatcher:
void UpdateFocusRevealedLock() override;
void ReleaseLock() override;
private:
class BubbleObserver;
views::Widget* GetWidget();
aura::Window* GetWidgetWindow();
// Recreate |bubble_observer_| and start observing any bubbles anchored to a
// child of |top_container_|.
void RecreateBubbleObserver();
// views::FocusChangeListener overrides:
void OnWillChangeFocus(views::View* focused_before,
views::View* focused_now) override;
void OnDidChangeFocus(views::View* focused_before,
views::View* focused_now) override;
// aura::client::TransientWindowClientObserver overrides:
void OnTransientChildWindowAdded(aura::Window* window,
aura::Window* transient) override;
void OnTransientChildWindowRemoved(aura::Window* window,
aura::Window* transient) override;
// ::wm::ActivationChangeObserver:
void OnWindowActivated(
::wm::ActivationChangeObserver::ActivationReason reason,
aura::Window* gaining_active,
aura::Window* losing_active) override;
ash::ImmersiveFullscreenController* immersive_fullscreen_controller_;
// Lock which keeps the top-of-window views revealed based on the focused view
// and the active widget. Acquiring the lock never triggers a reveal because
// a view is not focusable till a reveal has made it visible.
std::unique_ptr<ash::ImmersiveRevealedLock> lock_;
// Manages bubbles which are anchored to a child of
// |ImmersiveFullscreenController::top_container_|.
std::unique_ptr<BubbleObserver> bubble_observer_;
DISALLOW_COPY_AND_ASSIGN(ImmersiveFocusWatcherMus);
};
#endif // CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_FOCUS_WATCHER_MUS_H_
......@@ -4,21 +4,13 @@
#include "chrome/browser/ui/views/frame/immersive_handler_factory_mus.h"
#include "ash/public/cpp/immersive/immersive_focus_watcher.h"
#include "ash/public/cpp/immersive/immersive_gesture_handler.h"
#include "base/logging.h"
#include "chrome/browser/ui/views/frame/immersive_focus_watcher_mus.h"
ImmersiveHandlerFactoryMus::ImmersiveHandlerFactoryMus() {}
ImmersiveHandlerFactoryMus::~ImmersiveHandlerFactoryMus() {}
std::unique_ptr<ash::ImmersiveFocusWatcher>
ImmersiveHandlerFactoryMus::CreateFocusWatcher(
ash::ImmersiveFullscreenController* controller) {
return std::make_unique<ImmersiveFocusWatcherMus>(controller);
}
std::unique_ptr<ash::ImmersiveGestureHandler>
ImmersiveHandlerFactoryMus::CreateGestureHandler(
ash::ImmersiveFullscreenController* controller) {
......
......@@ -14,8 +14,6 @@ class ImmersiveHandlerFactoryMus : public ash::ImmersiveHandlerFactory {
~ImmersiveHandlerFactoryMus() override;
// ImmersiveHandlerFactory:
std::unique_ptr<ash::ImmersiveFocusWatcher> CreateFocusWatcher(
ash::ImmersiveFullscreenController* controller) override;
std::unique_ptr<ash::ImmersiveGestureHandler> CreateGestureHandler(
ash::ImmersiveFullscreenController* controller) override;
......
......@@ -224,9 +224,6 @@
-WindowOpenApiTest.UpdateWindowToLockedFullscreen
-WindowOpenApiTest.VerifyCommandsInLockedFullscreen
# Value of: immersive_controller->IsRevealed()
-ZoomBubbleBrowserTest.ImmersiveFullscreen
# Flaky tests. crbug.com/833144
-GetAuthTokenFunctionPublicSessionTest.NonWhitelisted
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment