Skip to content

GitLab

T
tangled
Commit eb197564 authored by Shawn Gallea's avatar Shawn Gallea Committed by Commit Bot
Browse files
Options

Move rounded corner logic to RoundedWindowCornersManager 

This allows rounded corners to be forced off
when there is a sibling to a webview container window.

Bug: b/155436903
Test: Locally on device
Change-Id: Ida192575a1584192a248ceb1e98b1b54e467e857
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2245187
Commit-Queue: Shawn Gallea <sagallea@google.com>
Reviewed-by: default avatarDaniel Nicoara <dnicoara@chromium.org>
Cr-Commit-Position: refs/heads/master@{#786603}
parent 339887bd
Expand all Show whitespace changes
Inline Side-by-side
Showing with 556 additions and 344 deletions
chromecast/browser/BUILD.gn
View file @ eb197564
......@@ -591,14 +591,6 @@ cast_source_set("unittests") {
"//ui/events:test_support",
]
}
if (is_linux && use_ozone) {
sources += [ "webview/webview_window_manager_unittest.cc" ]
deps += [
"//chromecast/graphics",
"//components/exo",
]
}
}
if (is_android) {
......
chromecast/browser/cast_browser_main_parts.cc
View file @ eb197564
......@@ -106,6 +106,7 @@
#include "chromecast/browser/devtools/cast_ui_devtools.h"
#include "chromecast/graphics/cast_screen.h"
#include "chromecast/graphics/cast_window_manager_aura.h"
#include "chromecast/graphics/rounded_window_corners_manager.h"
#include "chromecast/media/service/cast_renderer.h" // nogncheck
#if !defined(OS_FUCHSIA)
#include "components/ui_devtools/devtools_server.h" // nogncheck
......@@ -610,6 +611,8 @@ void CastBrowserMainParts::PreMainMessageLoopRun() {
CAST_IS_DEBUG_BUILD() ||
GetSwitchValueBoolean(switches::kEnableInput, false));
window_manager_->Setup();
rounded_window_corners_manager_ =
std::make_unique<RoundedWindowCornersManager>(window_manager_.get());
#if BUILDFLAG(ENABLE_CHROMECAST_EXTENSIONS)
cast_browser_process_->SetAccessibilityManager(
......@@ -768,6 +771,10 @@ void CastBrowserMainParts::PostMainMessageLoopRun() {
cast_browser_process_->cast_browser_metrics()->Finalize();
cast_browser_process_.reset();
#if defined(USE_AURA)
rounded_window_corners_manager_.reset();
#endif
window_manager_.reset();
#if defined(USE_AURA)
display::Screen::SetScreenInstance(nullptr);
......
chromecast/browser/cast_browser_main_parts.h
View file @ eb197564
......@@ -42,6 +42,7 @@ class WaylandServerController;
#if defined(USE_AURA)
class CastWindowManagerAura;
class CastScreen;
class RoundedWindowCornersManager;
namespace shell {
class CastUIDevTools;
} // namespace shell
......@@ -100,6 +101,7 @@ class CastBrowserMainParts : public content::BrowserMainParts {
std::unique_ptr<views::ViewsDelegate> views_delegate_;
std::unique_ptr<CastScreen> cast_screen_;
std::unique_ptr<CastWindowManagerAura> window_manager_;
std::unique_ptr<RoundedWindowCornersManager> rounded_window_corners_manager_;
#else
std::unique_ptr<CastWindowManager> window_manager_;
#endif // defined(USE_AURA)
......
chromecast/browser/webview/webview_window_manager.cc
View file @ eb197564
......@@ -4,6 +4,7 @@
#include "chromecast/browser/webview/webview_window_manager.h"
#include "base/optional.h"
#include "base/stl_util.h"
#include "chromecast/graphics/cast_window_manager.h"
#include "components/exo/shell_surface_util.h"
......@@ -12,72 +13,9 @@
namespace chromecast {
// Keeps track of the creation and destruction of webview container windows, and
// adds and removes the root window rounded corner decoration accordingly.
// Rounded corners only need to be present when webviews are being displayed.
class RoundedCornersObserver : public WebviewWindowManager::Observer,
public aura::WindowObserver {
public:
explicit RoundedCornersObserver(CastWindowManager* cast_window_manager)
: cast_window_manager_(cast_window_manager) {
DCHECK(cast_window_manager);
}
~RoundedCornersObserver() override {}
// WebviewWindowManager::Observer implementation
void OnNewWebviewContainerWindow(aura::Window* window, int app_id) override {
// Observe the lifecycle of this window so we can add rounded corners
// when it is visible.
window->AddObserver(this);
observed_container_windows_.insert(window);
if (window->IsVisible())
OnWindowVisibilityChanged(window, true);
}
// aura::WindowObserver implementation
void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
if (!base::Contains(observed_container_windows_, window))
return;
num_visible_container_windows_ += visible ? 1 : -1;
DCHECK_GE(num_visible_container_windows_, 0);
cast_window_manager_->SetEnableRoundedCorners(
num_visible_container_windows_);
}
void OnWindowDestroyed(aura::Window* window) override {
if (!base::Contains(observed_container_windows_, window))
return;
observed_container_windows_.erase(window);
if (window->IsVisible()) {
num_visible_container_windows_--;
DCHECK_GE(num_visible_container_windows_, 0);
} else {
return;
}
// Remove the rounded corners when we're out of container windows.
if (!num_visible_container_windows_) {
cast_window_manager_->SetEnableRoundedCorners(false);
}
}
private:
CastWindowManager* cast_window_manager_;
int num_visible_container_windows_ = 0;
std::unordered_set<aura::Window*> observed_container_windows_;
DISALLOW_COPY_AND_ASSIGN(RoundedCornersObserver);
};
WebviewWindowManager::WebviewWindowManager(
CastWindowManager* cast_window_manager)
: rounded_corners_observer_(
std::make_unique<RoundedCornersObserver>(cast_window_manager)) {
CastWindowManager* cast_window_manager) {
aura::Env::GetInstance()->AddObserver(this);
AddObserver(rounded_corners_observer_.get());
}
WebviewWindowManager::~WebviewWindowManager() {
......
chromecast/browser/webview/webview_window_manager.h
View file @ eb197564
......@@ -12,7 +12,6 @@
namespace chromecast {
class CastWindowManager;
class RoundedCornersObserver;
// Keeps track of new aura::Windows and listen for window property events to
// find Exo windows with the |exo::kClientSurfaceIdKey| property set.
......@@ -46,7 +45,6 @@ class WebviewWindowManager : public aura::EnvObserver,
std::vector<aura::Window*> observed_windows_;
base::ObserverList<Observer>::Unchecked observers_;
std::unique_ptr<RoundedCornersObserver> rounded_corners_observer_;
DISALLOW_COPY_AND_ASSIGN(WebviewWindowManager);
};
......
chromecast/browser/webview/webview_window_manager_unittest.cc deleted 100644 → 0
View file @ 339887bd
// Copyright 2020 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 "chromecast/browser/webview/webview_window_manager.h"
#include "chromecast/graphics/cast_window_manager_aura.h"
#include "components/exo/surface.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/env.h"
#include "ui/aura/window.h"
#include "ui/base/class_property.h"
#include "ui/compositor/layer_type.h"
using ::testing::StrictMock;
namespace chromecast {
class MockCastWindowManager : public CastWindowManagerAura {
public:
MOCK_METHOD(void, SetEnableRoundedCorners, (bool enable), (override));
private:
using CastWindowManagerAura::CastWindowManagerAura;
};
class WebviewWindowManagerTest : public testing::Test {
public:
WebviewWindowManagerTest()
: env_(aura::Env::CreateInstance()),
mock_cast_window_manager_(new StrictMock<MockCastWindowManager>(true)),
webview_window_manager_(
new WebviewWindowManager(mock_cast_window_manager_.get())) {}
WebviewWindowManagerTest(const WebviewWindowManagerTest&) = delete;
WebviewWindowManagerTest& operator=(const WebviewWindowManagerTest&) = delete;
protected:
std::unique_ptr<aura::Env> env_;
std::unique_ptr<StrictMock<MockCastWindowManager>> mock_cast_window_manager_;
std::unique_ptr<WebviewWindowManager> webview_window_manager_;
};
TEST_F(WebviewWindowManagerTest, NoSetProperty) {
std::unique_ptr<aura::Window> window =
std::make_unique<aura::Window>(nullptr);
window->Init(ui::LAYER_TEXTURED);
window->Show();
window->Hide();
// StrictMock is used to verify SetEnableRoundedCorners is not called when
// kClientSurfaceIdKey property is not set.
}
TEST_F(WebviewWindowManagerTest,
SetRoundedCornersOnWindowAfterSettingExoPropertyAndShowing) {
std::unique_ptr<aura::Window> window =
std::make_unique<aura::Window>(nullptr);
window->Init(ui::LAYER_TEXTURED);
window->SetProperty(exo::kClientSurfaceIdKey, 1);
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(true));
window->Show();
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(false));
window = nullptr;
}
TEST_F(WebviewWindowManagerTest,
SetRoundedCornersOnVisibleWindowAfterSettingExoProperty) {
std::unique_ptr<aura::Window> window =
std::make_unique<aura::Window>(nullptr);
window->Init(ui::LAYER_TEXTURED);
window->Show();
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(true));
window->SetProperty(exo::kClientSurfaceIdKey, 1);
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(false));
window = nullptr;
}
TEST_F(WebviewWindowManagerTest, RemoveRoundedCornersAfterHidingWindow) {
std::unique_ptr<aura::Window> window =
std::make_unique<aura::Window>(nullptr);
window->Init(ui::LAYER_TEXTURED);
window->SetProperty(exo::kClientSurfaceIdKey, 1);
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(true));
window->Show();
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(false));
window->Hide();
}
TEST_F(WebviewWindowManagerTest,
RemoveRoundedCornersAfterHidingMultipleWindows) {
std::unique_ptr<aura::Window> window1 =
std::make_unique<aura::Window>(nullptr);
window1->Init(ui::LAYER_TEXTURED);
std::unique_ptr<aura::Window> window2 =
std::make_unique<aura::Window>(nullptr);
window2->Init(ui::LAYER_TEXTURED);
window1->SetProperty(exo::kClientSurfaceIdKey, 1);
window2->SetProperty(exo::kClientSurfaceIdKey, 2);
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(true))
.Times(3);
window1->Show();
window2->Show();
window1->Hide();
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(false));
window2->Hide();
}
TEST_F(WebviewWindowManagerTest,
RemoveRoundedCornersAfterDestroyingMultipleWindows) {
std::unique_ptr<aura::Window> window1 =
std::make_unique<aura::Window>(nullptr);
window1->Init(ui::LAYER_TEXTURED);
std::unique_ptr<aura::Window> window2 =
std::make_unique<aura::Window>(nullptr);
window2->Init(ui::LAYER_TEXTURED);
window1->SetProperty(exo::kClientSurfaceIdKey, 1);
window2->SetProperty(exo::kClientSurfaceIdKey, 2);
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(true))
.Times(2);
window1->Show();
window2->Show();
window1 = nullptr;
EXPECT_CALL(*mock_cast_window_manager_, SetEnableRoundedCorners(false));
window2 = nullptr;
}
} // namespace chromecast
chromecast/graphics/BUILD.gn
View file @ eb197564
......@@ -66,10 +66,13 @@ cast_source_set("graphics") {
"gestures/side_swipe_detector.cc",
"gestures/side_swipe_detector.h",
"rounded_window_corners_aura.cc",
"rounded_window_corners_manager.cc",
"rounded_window_corners_manager.h",
]
deps += [
"//chromecast:chromecast_buildflags",
"//components/exo",
"//components/viz/common",
"//ui/base/ime/init",
"//ui/events:gesture_detection",
......@@ -142,11 +145,13 @@ if (use_aura && !is_cast_audio_only) {
"gestures/cast_system_gesture_dispatcher_test.cc",
"gestures/multiple_tap_detector_test.cc",
"gestures/side_swipe_detector_test.cc",
"rounded_window_corners_manager_unittest.cc",
"run_all_unittests.cc",
]
deps = [
":graphics",
"//base/test:test_support",
"//components/exo",
"//mojo/core/embedder",
"//testing/gmock",
"//testing/gtest",
......
chromecast/graphics/cast_window_manager_aura.cc
View file @ eb197564
......@@ -38,19 +38,6 @@
namespace chromecast {
namespace {
// Returns true if we have something that needs explicit corner decorations in
// the app list. This includes unmanaged apps, boot overlay, etc. Anything which
// is not a managed app or the corners overlay itself.
bool WindowListNeedsCorners(
const std::vector<CastWindowManager::WindowId>& windows) {
for (CastWindowManager::WindowId window_id : windows) {
if (window_id != CastWindowManager::APP &&
window_id != CastWindowManager::CORNERS_OVERLAY)
return true;
}
return false;
}
gfx::Transform GetPrimaryDisplayRotationTransform() {
display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
return display::CreateRotationTransform(display.rotation(),
......@@ -264,17 +251,6 @@ bool CastWindowManagerAura::HasRoundedWindowCorners() const {
void CastWindowManagerAura::OnWindowOrderChanged(
std::vector<WindowId> window_order) {
// Manage window corner state for unmanaged applications that do not provide
// their own. Note: we do not run this logic if rounded_window_corners_
// isn't initialized yet, as it means Setup is running, and will get called
// recursively as the corners are added as a window.
if (rounded_window_corners_) {
bool needs_corners =
WindowListNeedsCorners(window_order) || needs_rounded_corners_;
rounded_window_corners_->SetEnabled(needs_corners);
}
window_order_.swap(window_order);
for (auto& observer : observer_list_) {
observer.WindowOrderChanged();
......@@ -383,10 +359,7 @@ void CastWindowManagerAura::RemoveTouchActivityObserver(
void CastWindowManagerAura::SetEnableRoundedCorners(bool enable) {
DCHECK(rounded_window_corners_);
needs_rounded_corners_ = enable;
bool enable_corners =
needs_rounded_corners_ || WindowListNeedsCorners(window_order_);
rounded_window_corners_->SetEnabled(enable_corners);
rounded_window_corners_->SetEnabled(enable);
}
void CastWindowManagerAura::NotifyColorInversionEnabled(bool enabled) {
......
chromecast/graphics/cast_window_manager_aura.h
View file @ eb197564
......@@ -74,9 +74,6 @@ class CastWindowManagerAura : public CastWindowManager,
private:
const bool enable_input_;
// true if the current app explicitly requested rounded corners
bool needs_rounded_corners_ = false;
std::unique_ptr<CastWindowTreeHostAura> window_tree_host_;
std::unique_ptr<aura::client::DefaultCaptureClient> capture_client_;
std::unique_ptr<CastFocusClientAura> focus_client_;
......
chromecast/graphics/cast_window_manager_aura_test.cc
View file @ eb197564
......@@ -53,43 +53,6 @@ class TestWindow {
DISALLOW_COPY_AND_ASSIGN(TestWindow);
};
class PretendManagedApp {
public:
explicit PretendManagedApp(CastWindowManager* window_manager)
: test_window_(static_cast<int>(CastWindowManager::APP)),
window_manager_(window_manager) {
window_manager->AddWindow(test_window_.window());
test_window_.window()->Show();
}
~PretendManagedApp() { test_window_.window()->Hide(); }
void SetEnableCorners(bool enable) {
window_manager_->SetEnableRoundedCorners(enable);
}
private:
TestWindow test_window_;
CastWindowManager* window_manager_;
DISALLOW_COPY_AND_ASSIGN(PretendManagedApp);
};
class PretendUnmanagedApp {
public:
explicit PretendUnmanagedApp(CastWindowManager* window_manager)
: test_window_(static_cast<int>(CastWindowManager::UNMANAGED_APP)) {
window_manager->AddWindow(test_window_.window());
test_window_.window()->Show();
}
~PretendUnmanagedApp() { test_window_.window()->Hide(); }
private:
TestWindow test_window_;
DISALLOW_COPY_AND_ASSIGN(PretendUnmanagedApp);
};
} // namespace
// ViewsTestBase needed so that views/widget initialization is setup correctly
......@@ -217,74 +180,5 @@ TEST_F(CastWindowManagerAuraTest, CheckProperWindowOrdering) {
EXPECT_EQ(window2.window(), window_manager->GetRootWindow()->children()[3]);
}
TEST_F(CastWindowManagerAuraTest, CheckRoundedCorners) {
std::unique_ptr<CastWindowManagerAura> window_manager =
std::make_unique<CastWindowManagerAura>(false /* enable input */);
window_manager->Setup();
// Adding an unmanaged app should enable rounded corners. Removing it should
// disable them.
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
auto unmanaged = std::make_unique<PretendUnmanagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
unmanaged.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
// Managed apps provide their own rounded corners, so having one there means
// the window manager should not add them itself.
auto managed = std::make_unique<PretendManagedApp>(window_manager.get());
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed->SetEnableCorners(true);
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
managed->SetEnableCorners(false);
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed.reset();
// A mixture of managed and unmanaged should get rounded, no matter what.
managed = std::make_unique<PretendManagedApp>(window_manager.get());
managed->SetEnableCorners(true);
unmanaged = std::make_unique<PretendUnmanagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
managed->SetEnableCorners(false);
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
unmanaged.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed.reset();
// Try with managed apps that have don't use SetEnableCorners (render their
// own externally)
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed = std::make_unique<PretendManagedApp>(window_manager.get());
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
unmanaged = std::make_unique<PretendUnmanagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
unmanaged.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
// Going from unmanaged to managed has rounded until the unmanaged goes away.
unmanaged = std::make_unique<PretendUnmanagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
managed = std::make_unique<PretendManagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
unmanaged.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
managed.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
// Managed (without corners) to unmanaged
managed = std::make_unique<PretendManagedApp>(window_manager.get());
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
unmanaged = std::make_unique<PretendUnmanagedApp>(window_manager.get());
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
// Managed goes away, so we'll get corners for the unmanaged...
managed.reset();
EXPECT_TRUE(window_manager->HasRoundedWindowCorners());
unmanaged.reset();
EXPECT_FALSE(window_manager->HasRoundedWindowCorners());
}
} // namespace test
} // namespace chromecast
chromecast/graphics/rounded_window_corners_manager.cc 0 → 100644
View file @ eb197564
// Copyright 2020 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 "chromecast/graphics/rounded_window_corners_manager.h"
#include "chromecast/graphics/cast_window_manager.h"
#include "components/exo/surface.h"
#include "ui/aura/env.h"
namespace chromecast {
namespace {
aura::Window* FindTopmostVisibleNonCornersWindow(
aura::Window* window,
const std::unordered_set<aura::Window*>& observed_container_windows) {
aura::Window* found_window = nullptr;
if (!window->IsVisible())
return nullptr;
if (base::Contains(observed_container_windows, window))
return window;
for (auto it = window->children().rbegin(); it != window->children().rend();
++it) {
found_window =
FindTopmostVisibleNonCornersWindow(*it, observed_container_windows);
if (found_window)
return found_window;
}
return window->id() != CastWindowManager::CORNERS_OVERLAY ? window : nullptr;
}
} // namespace
// Keeps track of the creation and destruction of webview container windows, and
// adds and removes the root window rounded corner decoration accordingly.
// Rounded corners only need to be present when webviews are being displayed.
class RoundedCornersObserver : public aura::WindowObserver,
public CastWindowManager::Observer {
public:
explicit RoundedCornersObserver(CastWindowManager* cast_window_manager)
: cast_window_manager_(cast_window_manager) {
DCHECK(cast_window_manager);
DCHECK(cast_window_manager_->GetRootWindow());
cast_window_manager_->AddObserver(this);
cast_window_manager_->GetRootWindow()->AddObserver(this);
DecideCorners();
}
RoundedCornersObserver(const RoundedCornersObserver&) = delete;
RoundedCornersObserver& operator=(const RoundedCornersObserver&) = delete;
~RoundedCornersObserver() override {
cast_window_manager_->RemoveObserver(this);
cast_window_manager_->GetRootWindow()->RemoveObserver(this);
}
void OnNewWebviewContainerWindow(aura::Window* window, int app_id) {
// Observe the lifecycle of this window so we can add rounded corners
// when it is visible.
window->AddObserver(this);
observed_container_windows_.insert(window);
if (window->IsVisible())
DecideCorners();
}
// aura::WindowObserver:
void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
DecideCorners();
}
void OnWindowDestroyed(aura::Window* window) override {
if (!base::Contains(observed_container_windows_, window))
return;
observed_container_windows_.erase(window);
DecideCorners();
}
void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override {
DecideCorners();
}
void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override {
DecideCorners();
}
// CastWindowManager::Observer:
void WindowOrderChanged() override { DecideCorners(); }
private:
void DecideCorners() {
aura::Window* root_window = cast_window_manager_->GetRootWindow();
aura::Window* topmost_visible_window = FindTopmostVisibleNonCornersWindow(
root_window, observed_container_windows_);
if (!topmost_visible_window)
return;
int window_id = topmost_visible_window->id();
bool set_rounded_corners =
(window_id != CastWindowManager::APP) ||
base::Contains(observed_container_windows_, topmost_visible_window);
if (rounded_corners_ == set_rounded_corners)
return;
cast_window_manager_->SetEnableRoundedCorners(set_rounded_corners);
rounded_corners_ = set_rounded_corners;
}
bool rounded_corners_ = false;
CastWindowManager* cast_window_manager_;
std::unordered_set<aura::Window*> observed_container_windows_;
};
RoundedWindowCornersManager::RoundedWindowCornersManager(
CastWindowManager* cast_window_manager)
: rounded_corners_observer_(
std::make_unique<RoundedCornersObserver>(cast_window_manager)) {
aura::Env::GetInstance()->AddObserver(this);
}
RoundedWindowCornersManager::~RoundedWindowCornersManager() {
aura::Env::GetInstance()->RemoveObserver(this);
}
void RoundedWindowCornersManager::OnWindowInitialized(aura::Window* window) {
window->AddObserver(this);
}
void RoundedWindowCornersManager::OnWindowDestroying(aura::Window* window) {
window->RemoveObserver(this);
}
void RoundedWindowCornersManager::OnWindowPropertyChanged(aura::Window* window,
const void* key,
intptr_t old) {
if (key != exo::kClientSurfaceIdKey)
return;
int app_id = window->GetProperty(exo::kClientSurfaceIdKey);
LOG(INFO) << "Found window for webview " << app_id;
rounded_corners_observer_->OnNewWebviewContainerWindow(window, app_id);
}
} // namespace chromecast
chromecast/graphics/rounded_window_corners_manager.h 0 → 100644
View file @ eb197564
// Copyright 2020 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 CHROMECAST_GRAPHICS_ROUNDED_WINDOW_CORNERS_MANAGER_H_
#define CHROMECAST_GRAPHICS_ROUNDED_WINDOW_CORNERS_MANAGER_H_
#include "ui/aura/env_observer.h"
#include "ui/aura/window_observer.h"
namespace chromecast {
class CastWindowManager;
class RoundedCornersObserver;
// Manages rounded corner state, removing them when the topmost visible window
// is able to supply its own.
class RoundedWindowCornersManager : public aura::EnvObserver,
public aura::WindowObserver {
public:
explicit RoundedWindowCornersManager(CastWindowManager* cast_window_manager);
RoundedWindowCornersManager(const RoundedWindowCornersManager&) = delete;
RoundedWindowCornersManager& operator=(const RoundedWindowCornersManager&) =
delete;
~RoundedWindowCornersManager() override;
private:
void OnWindowInitialized(aura::Window* window) override;
void OnWindowDestroying(aura::Window* window) override;
void OnWindowPropertyChanged(aura::Window* window,
const void* key,
intptr_t old) override;
std::unique_ptr<RoundedCornersObserver> rounded_corners_observer_;
};
} // namespace chromecast
#endif // CHROMECAST_GRAPHICS_ROUNDED_WINDOW_CORNERS_MANAGER_H_
chromecast/graphics/rounded_window_corners_manager_unittest.cc 0 → 100644
View file @ eb197564
This diff is collapsed.
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