| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/scheduler/renderer/render_widget_signals.h" | |
| 6 | |
| 7 #include "base/macros.h" | |
| 8 #include "components/scheduler/renderer/render_widget_scheduling_state.h" | |
| 9 #include "testing/gmock/include/gmock/gmock.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 | |
| 12 using testing::AnyNumber; | |
| 13 using testing::Mock; | |
| 14 using testing::_; | |
| 15 | |
| 16 namespace scheduler { | |
| 17 | |
| 18 namespace { | |
| 19 class MockObserver : public RenderWidgetSignals::Observer { | |
| 20 public: | |
| 21 MockObserver() {} | |
| 22 virtual ~MockObserver() {} | |
| 23 | |
| 24 MOCK_METHOD1(SetAllRenderWidgetsHidden, void(bool hidden)); | |
| 25 MOCK_METHOD1(SetHasVisibleRenderWidgetWithTouchHandler, | |
| 26 void(bool has_visible_render_widget_with_touch_handler)); | |
| 27 | |
| 28 private: | |
| 29 DISALLOW_COPY_AND_ASSIGN(MockObserver); | |
| 30 }; | |
| 31 } | |
| 32 | |
| 33 class RenderWidgetSignalsTest : public testing::Test { | |
| 34 public: | |
| 35 RenderWidgetSignalsTest() {} | |
| 36 ~RenderWidgetSignalsTest() override {} | |
| 37 | |
| 38 void SetUp() override { | |
| 39 mock_observer_.reset(new MockObserver()); | |
| 40 render_widget_signals_.reset(new RenderWidgetSignals(mock_observer_.get())); | |
| 41 } | |
| 42 | |
| 43 void IgnoreWidgetCreationCallbacks() { | |
| 44 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(false)) | |
| 45 .Times(AnyNumber()); | |
| 46 } | |
| 47 | |
| 48 void IgnoreWidgetDestructionCallbacks() { | |
| 49 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)) | |
| 50 .Times(AnyNumber()); | |
| 51 } | |
| 52 | |
| 53 std::unique_ptr<MockObserver> mock_observer_; | |
| 54 std::unique_ptr<RenderWidgetSignals> render_widget_signals_; | |
| 55 }; | |
| 56 | |
| 57 TEST_F(RenderWidgetSignalsTest, RenderWidgetSchedulingStateLifeCycle) { | |
| 58 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(false)).Times(1); | |
| 59 std::unique_ptr<RenderWidgetSchedulingState> widget1_state = | |
| 60 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 61 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 62 | |
| 63 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 64 } | |
| 65 | |
| 66 TEST_F(RenderWidgetSignalsTest, RenderWidget_Hidden) { | |
| 67 IgnoreWidgetCreationCallbacks(); | |
| 68 std::unique_ptr<RenderWidgetSchedulingState> widget1_state = | |
| 69 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 70 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 71 | |
| 72 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 73 widget1_state->SetHidden(true); | |
| 74 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 75 | |
| 76 IgnoreWidgetDestructionCallbacks(); | |
| 77 } | |
| 78 | |
| 79 TEST_F(RenderWidgetSignalsTest, RenderWidget_HiddenThreeTimesShownOnce) { | |
| 80 IgnoreWidgetCreationCallbacks(); | |
| 81 std::unique_ptr<RenderWidgetSchedulingState> widget1_state = | |
| 82 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 83 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 84 | |
| 85 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 86 widget1_state->SetHidden(true); | |
| 87 widget1_state->SetHidden(true); | |
| 88 widget1_state->SetHidden(true); | |
| 89 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 90 | |
| 91 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(false)).Times(1); | |
| 92 widget1_state->SetHidden(false); | |
| 93 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 94 | |
| 95 IgnoreWidgetDestructionCallbacks(); | |
| 96 } | |
| 97 | |
| 98 TEST_F(RenderWidgetSignalsTest, MultipleRenderWidgetsBecomeHiddenThenVisible) { | |
| 99 IgnoreWidgetCreationCallbacks(); | |
| 100 std::unique_ptr<RenderWidgetSchedulingState> widget1_state = | |
| 101 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 102 std::unique_ptr<RenderWidgetSchedulingState> widget2_state = | |
| 103 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 104 std::unique_ptr<RenderWidgetSchedulingState> widget3_state = | |
| 105 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 106 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 107 | |
| 108 // Widgets are initially assumed to be visible so start hiding them, we should | |
| 109 // not get any calls to SetAllRenderWidgetsHidden till the last one is hidden. | |
| 110 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(_)).Times(0); | |
| 111 widget1_state->SetHidden(true); | |
| 112 widget2_state->SetHidden(true); | |
| 113 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 114 | |
| 115 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 116 widget3_state->SetHidden(true); | |
| 117 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 118 | |
| 119 // We should get a call back once the first widget is unhidden and no more | |
| 120 // after that. | |
| 121 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(false)).Times(1); | |
| 122 widget1_state->SetHidden(false); | |
| 123 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 124 | |
| 125 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(_)).Times(0); | |
| 126 widget2_state->SetHidden(false); | |
| 127 widget3_state->SetHidden(false); | |
| 128 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 129 | |
| 130 IgnoreWidgetDestructionCallbacks(); | |
| 131 } | |
| 132 | |
| 133 TEST_F(RenderWidgetSignalsTest, TouchHandlerAddedAndRemoved_VisibleWidget) { | |
| 134 IgnoreWidgetCreationCallbacks(); | |
| 135 | |
| 136 std::unique_ptr<RenderWidgetSchedulingState> widget_state = | |
| 137 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 138 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 139 | |
| 140 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(true)) | |
| 141 .Times(1); | |
| 142 widget_state->SetHasTouchHandler(true); | |
| 143 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 144 | |
| 145 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(false)) | |
| 146 .Times(1); | |
| 147 widget_state->SetHasTouchHandler(false); | |
| 148 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 149 | |
| 150 IgnoreWidgetDestructionCallbacks(); | |
| 151 } | |
| 152 | |
| 153 TEST_F(RenderWidgetSignalsTest, | |
| 154 TouchHandlerAddedThriceAndRemovedOnce_VisibleWidget) { | |
| 155 IgnoreWidgetCreationCallbacks(); | |
| 156 | |
| 157 std::unique_ptr<RenderWidgetSchedulingState> widget_state = | |
| 158 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 159 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 160 | |
| 161 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(true)) | |
| 162 .Times(1); | |
| 163 widget_state->SetHasTouchHandler(true); | |
| 164 widget_state->SetHasTouchHandler(true); | |
| 165 widget_state->SetHasTouchHandler(true); | |
| 166 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 167 | |
| 168 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(false)) | |
| 169 .Times(1); | |
| 170 widget_state->SetHasTouchHandler(false); | |
| 171 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 172 | |
| 173 IgnoreWidgetDestructionCallbacks(); | |
| 174 } | |
| 175 | |
| 176 TEST_F(RenderWidgetSignalsTest, TouchHandlerAddedAndRemoved_HiddenWidget) { | |
| 177 IgnoreWidgetCreationCallbacks(); | |
| 178 | |
| 179 std::unique_ptr<RenderWidgetSchedulingState> widget_state = | |
| 180 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 181 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 182 widget_state->SetHidden(true); | |
| 183 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 184 | |
| 185 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(_)) | |
| 186 .Times(0); | |
| 187 widget_state->SetHasTouchHandler(true); | |
| 188 widget_state->SetHasTouchHandler(false); | |
| 189 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 190 | |
| 191 IgnoreWidgetDestructionCallbacks(); | |
| 192 } | |
| 193 | |
| 194 TEST_F(RenderWidgetSignalsTest, | |
| 195 MultipleTouchHandlerAddedAndRemoved_VisibleWidgets) { | |
| 196 IgnoreWidgetCreationCallbacks(); | |
| 197 | |
| 198 std::unique_ptr<RenderWidgetSchedulingState> widget1_state = | |
| 199 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 200 std::unique_ptr<RenderWidgetSchedulingState> widget2_state = | |
| 201 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 202 std::unique_ptr<RenderWidgetSchedulingState> widget3_state = | |
| 203 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 204 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 205 | |
| 206 // We should only get a callback for the first widget with a touch handler. | |
| 207 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(true)) | |
| 208 .Times(1); | |
| 209 widget1_state->SetHasTouchHandler(true); | |
| 210 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 211 | |
| 212 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(_)) | |
| 213 .Times(0); | |
| 214 widget2_state->SetHasTouchHandler(true); | |
| 215 widget3_state->SetHasTouchHandler(true); | |
| 216 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 217 | |
| 218 // We should only get a callback when the last touch handler is removed. | |
| 219 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(_)) | |
| 220 .Times(0); | |
| 221 widget1_state->SetHasTouchHandler(false); | |
| 222 widget2_state->SetHasTouchHandler(false); | |
| 223 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 224 | |
| 225 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(false)) | |
| 226 .Times(1); | |
| 227 widget3_state->SetHasTouchHandler(false); | |
| 228 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 229 | |
| 230 IgnoreWidgetDestructionCallbacks(); | |
| 231 } | |
| 232 | |
| 233 TEST_F(RenderWidgetSignalsTest, | |
| 234 TouchHandlerAddedThenWigetDeleted_VisibleWidget) { | |
| 235 IgnoreWidgetCreationCallbacks(); | |
| 236 | |
| 237 std::unique_ptr<RenderWidgetSchedulingState> widget_state = | |
| 238 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 239 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 240 | |
| 241 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(true)) | |
| 242 .Times(1); | |
| 243 widget_state->SetHasTouchHandler(true); | |
| 244 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 245 | |
| 246 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(false)) | |
| 247 .Times(1); | |
| 248 IgnoreWidgetDestructionCallbacks(); | |
| 249 } | |
| 250 | |
| 251 TEST_F(RenderWidgetSignalsTest, | |
| 252 TouchHandlerAddedThenWigetDeleted_HiddenWidget) { | |
| 253 IgnoreWidgetCreationCallbacks(); | |
| 254 | |
| 255 std::unique_ptr<RenderWidgetSchedulingState> widget_state = | |
| 256 render_widget_signals_->NewRenderWidgetSchedulingState(); | |
| 257 EXPECT_CALL(*mock_observer_, SetAllRenderWidgetsHidden(true)).Times(1); | |
| 258 widget_state->SetHidden(true); | |
| 259 Mock::VerifyAndClearExpectations(mock_observer_.get()); | |
| 260 | |
| 261 EXPECT_CALL(*mock_observer_, SetHasVisibleRenderWidgetWithTouchHandler(_)) | |
| 262 .Times(0); | |
| 263 IgnoreWidgetDestructionCallbacks(); | |
| 264 } | |
| 265 | |
| 266 } // namespace scheduler | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2118903002:
scheduler: Move the Blink scheduler into Blink (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master