Adjust display_size_change lock_mutex scope, window resize and test;

remove build.gn rssurface include

Signed-off-by: shiyueeee <nieshiyue@huawei.com>
Change-Id: Ia324a4c6f3fcbd711598ed85e27f3e2ef9450a2e

dm/test/systemtest/BUILD.gn

@@ -117,9 +117,6 @@ config("dm_systemtest_common_public_config") {
     "//foundation/windowmanager/interfaces/innerkits/dm",
     "//foundation/windowmanager/interfaces/innerkits/wm",
     "//foundation/windowmanager/utils/include",
-
-    # RSSurface
-    "//foundation/graphic/standard/rosen/modules/render_service_client",
   ]
 }
 

dm/test/systemtest/display_change_test.cpp

@@ -50,8 +50,8 @@ public:
         isCallbackCalled_ = true;
         displayId_ = displayId;
     }
-    bool isCallbackCalled_ { false };
-    DisplayId displayId_ { DISPLAY_ID_INVALID };
+    bool isCallbackCalled_ = false;
+    DisplayId displayId_ = DISPLAY_ID_INVALID;
 };
 
 class DisplayChangeTest : public testing::Test {
@@ -62,27 +62,32 @@ public:
     virtual void TearDown() override;
     void ResetDisplayChangeListener();
     bool CheckDisplayChangeEventCallback(bool valueExpected);
-    bool ScreenSizeEqual(const sptr<Screen> screen, const sptr<SupportedScreenModes> curInfo);
-    bool DisplaySizeEqual(const sptr<Display> display, const sptr<SupportedScreenModes> curInfo);
+    bool ScreenSizeEqual(const sptr<Screen> screen, const sptr<SupportedScreenModes> curInfo) const;
+    bool DisplaySizeEqual(const sptr<Display> display, const sptr<SupportedScreenModes> curInfo) const;
     inline bool CheckModeSizeChange(const sptr<SupportedScreenModes> usedInfo,
         const sptr<SupportedScreenModes> curInfo) const;
 
     static DisplayId defaultDisplayId_;
+    static sptr<Screen> defaultScreen_;
     static sptr<DisplayChangeEventListener> listener_;
     static inline uint32_t times_ = 0;
 };
 DisplayId DisplayChangeTest::defaultDisplayId_ = DISPLAY_ID_INVALID;
+sptr<Screen> DisplayChangeTest::defaultScreen_ = nullptr;
 sptr<DisplayChangeEventListener> DisplayChangeTest::listener_ = new DisplayChangeEventListener();
 
 void DisplayChangeTest::SetUpTestCase()
 {
     defaultDisplayId_ = DisplayManager::GetInstance().GetDefaultDisplayId();
-    if (defaultDisplayId_ == DISPLAY_ID_INVALID) {
-        WLOGE("DisplayId is invalid!");
-    }
-    if (!DisplayManager::GetInstance().RegisterDisplayListener(listener_)) {
-        WLOGE("Fail to register display listener");
-    }
+    ASSERT_NE(DISPLAY_ID_INVALID, defaultDisplayId_);
+    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
+    ASSERT_NE(nullptr, defaultDisplay);
+    ScreenId screenId = defaultDisplay->GetScreenId();
+    ASSERT_NE(INVALID_SCREEN_ID, screenId);
+    defaultScreen_ = ScreenManager::GetInstance().GetScreenById(screenId);
+    ASSERT_NE(nullptr, defaultScreen_);
+
+    ASSERT_EQ(true, DisplayManager::GetInstance().RegisterDisplayListener(listener_));
 }
 
 void DisplayChangeTest::TearDownTestCase()
@@ -102,6 +107,7 @@ void DisplayChangeTest::TearDown()
 
 void DisplayChangeTest::ResetDisplayChangeListener()
 {
+    ASSERT_NE(nullptr, listener_);
     listener_->isCallbackCalled_ = false;
     listener_->displayId_ = DISPLAY_ID_INVALID;
 }
@@ -119,10 +125,11 @@ bool DisplayChangeTest::CheckDisplayChangeEventCallback(bool valueExpected)
         usleep(SLEEP_TIME_IN_US);
         ++times_;
     } while (times_ <= MAX_TIME_WAITING_FOR_CALLBACK);
+    WLOGI("CheckDisplayChangeEventCallback: cannot get valueExpected");
     return false;
 }
 
-bool DisplayChangeTest::ScreenSizeEqual(const sptr<Screen> screen, const sptr<SupportedScreenModes> curInfo)
+bool DisplayChangeTest::ScreenSizeEqual(const sptr<Screen> screen, const sptr<SupportedScreenModes> curInfo) const
 {
     if (screen == nullptr || curInfo == nullptr) {
         WLOGFI("param is nullptr");
@@ -135,7 +142,7 @@ bool DisplayChangeTest::ScreenSizeEqual(const sptr<Screen> screen, const sptr<Su
     return ((curInfo->width_ == sWidth) && (curInfo->height_ == sHeight));
 }
 
-bool DisplayChangeTest::DisplaySizeEqual(const sptr<Display> display, const sptr<SupportedScreenModes> curInfo)
+bool DisplayChangeTest::DisplaySizeEqual(const sptr<Display> display, const sptr<SupportedScreenModes> curInfo) const
 {
     if (display == nullptr || curInfo == nullptr) {
         WLOGFI("param is nullptr");
@@ -223,13 +230,8 @@ HWTEST_F(DisplayChangeTest, UnregisterDisplayChangeListener03, Function | SmallT
 HWTEST_F(DisplayChangeTest, CheckDisplayStateChange01, Function | SmallTest | Level2)
 {
     WLOGFI("CheckDisplayStateChange01");
-    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
-    ASSERT_NE(nullptr, defaultDisplay);
-    ScreenId screenId = defaultDisplay->GetScreenId();
-    sptr<Screen> screen = ScreenManager::GetInstance().GetScreenById(screenId);
-    ASSERT_NE(nullptr, screen);
-    uint32_t usedModeIdx = screen->GetModeId();
-    screen->SetScreenActiveMode(usedModeIdx);
+    uint32_t usedModeIdx = defaultScreen_->GetModeId();
+    defaultScreen_->SetScreenActiveMode(usedModeIdx);
     WLOGFI("SetScreenActiveMode: %{public}u", usedModeIdx);
     ASSERT_EQ(false, CheckDisplayChangeEventCallback(true));
 }
@@ -242,29 +244,22 @@ HWTEST_F(DisplayChangeTest, CheckDisplayStateChange01, Function | SmallTest | Le
 HWTEST_F(DisplayChangeTest, CheckDisplayStateChange02, Function | SmallTest | Level2)
 {
     WLOGFI("CheckDisplayStateChange02");
-    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
-    ASSERT_NE(nullptr, defaultDisplay);
-    ScreenId screenId = defaultDisplay->GetScreenId();
-    sptr<Screen> screen = ScreenManager::GetInstance().GetScreenById(screenId);
-    ASSERT_NE(nullptr, screen);
-    auto modes = screen->GetSupportedModes();
-    uint32_t usedModeIdx = screen->GetModeId();
+    auto modes = defaultScreen_->GetSupportedModes();
+    uint32_t usedModeIdx = defaultScreen_->GetModeId();
     WLOGFI("usedModeIdx / SupportMode size: %{public}u %{public}zu", usedModeIdx, modes.size());
 
     for (uint32_t modeIdx = 0; modeIdx < modes.size(); modeIdx++) {
         if (modeIdx != usedModeIdx && CheckModeSizeChange(modes[usedModeIdx], modes[modeIdx])) {
-            screen->SetScreenActiveMode(modeIdx);
-            WLOGFI("SetScreenActiveMode: %{public}u", modeIdx);
+            defaultScreen_->SetScreenActiveMode(modeIdx);
+            WLOGFI("SetScreenActiveMode: %{public}u -> %{public}u", usedModeIdx, modeIdx);
             ASSERT_EQ(true, CheckDisplayChangeEventCallback(true));
-            ASSERT_EQ(defaultDisplayId_, listener_->displayId_);
+            // reset usedMode
+            ResetDisplayChangeListener();
+            defaultScreen_->SetScreenActiveMode(usedModeIdx);
+            CheckDisplayChangeEventCallback(true);
             break;
         }
     }
-    // Set it back as default
-    // Check callback again since display sync in another thread
-    screen->SetScreenActiveMode(usedModeIdx);
-    ResetDisplayChangeListener();
-    CheckDisplayChangeEventCallback(true);
 }
 
 /**
@@ -275,29 +270,23 @@ HWTEST_F(DisplayChangeTest, CheckDisplayStateChange02, Function | SmallTest | Le
 HWTEST_F(DisplayChangeTest, CheckDisplaySizeChange01, Function | MediumTest | Level2)
 {
     WLOGFI("CheckDisplaySizeChange01");
-    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
-    ASSERT_NE(nullptr, defaultDisplay);
-    ScreenId screenId = defaultDisplay->GetScreenId();
-    sptr<Screen> screen = ScreenManager::GetInstance().GetScreenById(screenId);
-    ASSERT_NE(nullptr, screen);
-    auto modes = screen->GetSupportedModes();
-    uint32_t usedModeIdx = screen->GetModeId();
+    auto modes = defaultScreen_->GetSupportedModes();
+    uint32_t usedModeIdx = defaultScreen_->GetModeId();
     WLOGFI("usedModeIdx / SupportMode size: %{public}u %{public}zu", usedModeIdx, modes.size());
 
     for (uint32_t modeIdx = 0; modeIdx < modes.size(); modeIdx++) {
         if (modeIdx != usedModeIdx && CheckModeSizeChange(modes[usedModeIdx], modes[modeIdx])) {
-            screen->SetScreenActiveMode(modeIdx);
+            defaultScreen_->SetScreenActiveMode(modeIdx);
             WLOGFI("SetScreenActiveMode: %{public}u -> %{public}u", usedModeIdx, modeIdx);
-            ASSERT_EQ(true, ScreenSizeEqual(screen, modes[modeIdx]));
+            ASSERT_EQ(true, ScreenSizeEqual(defaultScreen_, modes[modeIdx]));
             ASSERT_EQ(true, CheckDisplayChangeEventCallback(true));
+            // reset usedMode
+            ResetDisplayChangeListener();
+            defaultScreen_->SetScreenActiveMode(usedModeIdx);
+            CheckDisplayChangeEventCallback(true);
             break;
         }
     }
-    // Set it back as default
-    // Check callback again since display sync in another thread
-    screen->SetScreenActiveMode(usedModeIdx);
-    ResetDisplayChangeListener();
-    CheckDisplayChangeEventCallback(true);
 }
 
 /**
@@ -308,31 +297,26 @@ HWTEST_F(DisplayChangeTest, CheckDisplaySizeChange01, Function | MediumTest | Le
 HWTEST_F(DisplayChangeTest, CheckDisplaySizeChange02, Function | MediumTest | Level2)
 {
     WLOGFI("CheckDisplaySizeChange02");
-    sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
-    ASSERT_NE(nullptr, defaultDisplay);
-    ScreenId screenId = defaultDisplay->GetScreenId();
-    sptr<Screen> screen = ScreenManager::GetInstance().GetScreenById(screenId);
-    ASSERT_NE(nullptr, screen);
-    auto modes = screen->GetSupportedModes();
-    uint32_t usedModeIdx = screen->GetModeId();
+    auto modes = defaultScreen_->GetSupportedModes();
+    uint32_t usedModeIdx = defaultScreen_->GetModeId();
     WLOGFI("usedModeIdx / SupportMode size: %{public}u %{public}zu", usedModeIdx, modes.size());
 
     for (uint32_t modeIdx = 0; modeIdx < modes.size(); modeIdx++) {
         if (modeIdx != usedModeIdx && CheckModeSizeChange(modes[usedModeIdx], modes[modeIdx])) {
-            screen->SetScreenActiveMode(modeIdx);
+            defaultScreen_->SetScreenActiveMode(modeIdx);
             WLOGFI("SetScreenActiveMode: %{public}u -> %{public}u", usedModeIdx, modeIdx);
+            ASSERT_EQ(true, ScreenSizeEqual(defaultScreen_, modes[modeIdx]));
             ASSERT_EQ(true, CheckDisplayChangeEventCallback(true));
-            defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
+            sptr<Display> defaultDisplay = DisplayManager::GetInstance().GetDisplayById(defaultDisplayId_);
             ASSERT_NE(nullptr, defaultDisplay);
             ASSERT_EQ(true, DisplaySizeEqual(defaultDisplay, modes[modeIdx]));
+            // reset usedMode
+            ResetDisplayChangeListener();
+            defaultScreen_->SetScreenActiveMode(usedModeIdx);
+            CheckDisplayChangeEventCallback(true);
             break;
         }
     }
-    // Set it back as default
-    // Check callback again since display sync in another thread
-    screen->SetScreenActiveMode(usedModeIdx);
-    ResetDisplayChangeListener();
-    CheckDisplayChangeEventCallback(true);
 }
 }
 } // namespace Rosen

dm/test/systemtest/display_test_utils.h

@@ -28,8 +28,8 @@
 #include "dm_common.h"
 #include "window_manager_hilog.h"
 #include "unique_fd.h"
-#include "core/ui/rs_surface_node.h"
-#include "core/ui/rs_display_node.h"
+#include "ui/rs_surface_node.h"
+#include "ui/rs_display_node.h"
 
 namespace OHOS {
 namespace Rosen {

dmserver/src/abstract_display_controller.cpp

@@ -306,20 +306,28 @@ void AbstractDisplayController::ProcessDisplaySizeChange(sptr<AbstractScreen> ab
         return;
     }
 
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    for (auto iter = abstractDisplayMap_.begin(); iter != abstractDisplayMap_.end(); iter++) {
-        sptr<AbstractDisplay> absDisplay = iter->second;
-        if (absDisplay->GetAbstractScreenId() != absScreen->dmsId_) {
-            continue;
-        }
-        if (UpdateDisplaySize(absDisplay, info)) {
-            WLOGFI("Notify display size change");
-            DisplayManagerService::GetInstance().NotifyDisplayStateChange(
-                iter->first, DisplayStateChangeType::SIZE_CHANGE);
-            DisplayManagerAgentController::GetInstance().OnDisplayChange(
-                absDisplay->ConvertToDisplayInfo(), DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
+    std::map<DisplayId, sptr<AbstractDisplay>> matchedDisplays;
+    {
+        std::lock_guard<std::recursive_mutex> lock(mutex_);
+        for (auto iter = abstractDisplayMap_.begin(); iter != abstractDisplayMap_.end(); ++iter) {
+            sptr<AbstractDisplay> absDisplay = iter->second;
+            if (absDisplay == nullptr || absDisplay->GetAbstractScreenId() != absScreen->dmsId_) {
+                continue;
+            }
+            if (UpdateDisplaySize(absDisplay, info)) {
+                matchedDisplays.insert(std::make_pair(iter->first, iter->second));
+            }
         }
     }
+
+    WLOGFI("Size of matchedDisplays %{public}zu", matchedDisplays.size());
+    for (auto iter = matchedDisplays.begin(); iter != matchedDisplays.end(); ++iter) {
+        WLOGFI("Notify display size change. Id %{public}" PRIu64"", iter->first);
+        DisplayManagerService::GetInstance().NotifyDisplayStateChange(
+            iter->first, DisplayStateChangeType::SIZE_CHANGE);
+        DisplayManagerAgentController::GetInstance().OnDisplayChange(
+            iter->second->ConvertToDisplayInfo(), DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
+    }
 }
 
 bool AbstractDisplayController::UpdateDisplaySize(sptr<AbstractDisplay> absDisplay, sptr<SupportedScreenModes> info)
@@ -329,7 +337,6 @@ bool AbstractDisplayController::UpdateDisplaySize(sptr<AbstractDisplay> absDispl
         WLOGI("keep display size. display:%{public}" PRIu64"", absDisplay->GetId());
         return false;
     }
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     absDisplay->SetHeight(info->height_);
     absDisplay->SetWidth(info->width_);
     WLOGI("update display size. id %{public}" PRIu64", size: %{public}d %{public}d",

wmserver/src/window_controller.cpp

@@ -291,6 +291,7 @@ void WindowController::ProcessDisplayChange(DisplayId displayId, DisplayStateCha
     }
 
     switch (type) {
+        case DisplayStateChangeType::SIZE_CHANGE:
         case DisplayStateChangeType::UPDATE_ROTATION: {
             windowRoot_->NotifyDisplayChange(abstractDisplay);
 
@@ -303,13 +304,6 @@ void WindowController::ProcessDisplayChange(DisplayId displayId, DisplayStateCha
             ResizeRect(sysBarWinId_[WindowType::WINDOW_TYPE_NAVIGATION_BAR], newRect, WindowSizeChangeReason::DRAG);
             break;
         }
-        case DisplayStateChangeType::SIZE_CHANGE: {
-            // Should request different window resolution change but not directly apply resize
-            // show logs of updated display
-            windowRoot_->NotifyDisplayChange(abstractDisplay);
-            WLOGFI("display w/h: %{public}u %{public}u", abstractDisplay->GetWidth(), abstractDisplay->GetHeight());
-            break;
-        }
         default: {
             WLOGFE("unknown DisplayStateChangeType:%{public}u", type);
             return;