OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 #include <utility> | 6 #include <utility> |
7 | 7 |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "base/process/process_handle.h" | 9 #include "base/process/process_handle.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
11 #include "services/resource_coordinator/coordination_unit/coordination_unit_fact
ory.h" | 11 #include "services/resource_coordinator/coordination_unit/coordination_unit_fact
ory.h" |
12 #include "services/resource_coordinator/coordination_unit/coordination_unit_grap
h_observer.h" | 12 #include "services/resource_coordinator/coordination_unit/coordination_unit_grap
h_observer.h" |
13 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl
.h" | 13 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl
.h" |
14 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl
_unittest_util.h" | 14 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl
_unittest_util.h" |
15 #include "services/resource_coordinator/coordination_unit/coordination_unit_mana
ger.h" | 15 #include "services/resource_coordinator/coordination_unit/coordination_unit_mana
ger.h" |
16 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h" | 16 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h" |
17 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h" | 17 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h" |
18 #include "services/resource_coordinator/public/interfaces/coordination_unit.mojo
m.h" | 18 #include "services/resource_coordinator/public/interfaces/coordination_unit.mojo
m.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
20 | 20 |
21 namespace resource_coordinator { | 21 namespace resource_coordinator { |
22 | 22 |
23 namespace { | 23 namespace { |
24 | 24 |
25 class CoordinationUnitGraphObserverTest : public CoordinationUnitImplTestBase { | 25 class CoordinationUnitGraphObserverTest : public CoordinationUnitImplTestBase { |
26 }; | 26 }; |
27 | 27 |
28 class TestBasicAPICoordinationUnitGraphObserver | 28 class TestCoordinationUnitGraphObserver : public CoordinationUnitGraphObserver { |
29 : public CoordinationUnitGraphObserver { | |
30 public: | 29 public: |
31 TestBasicAPICoordinationUnitGraphObserver() | 30 TestCoordinationUnitGraphObserver() |
32 : TestBasicAPICoordinationUnitGraphObserver( | 31 : on_child_added_count_(0u), |
33 CoordinationUnitType::kInvalidType) {} | 32 on_parent_added_count_(0u), |
| 33 on_coordination_unit_created_count_(0u), |
| 34 on_property_changed_count_(0u), |
| 35 on_child_removed_count_(0u), |
| 36 on_parent_removed_count_(0u), |
| 37 on_coordination_unit_will_be_destroyed_count_(0u) {} |
34 | 38 |
35 void OnCoordinationUnitCreatedEvent( | 39 size_t on_child_added_count() { return on_child_added_count_; } |
36 CoordinationUnitImpl* coordination_unit) override { | 40 size_t on_parent_added_count() { return on_parent_added_count_; } |
37 ++on_coordination_unit_created_invocations_; | 41 size_t on_coordination_unit_created_count() { |
38 | 42 return on_coordination_unit_created_count_; |
39 coordination_unit->ObserveOnChildAddedEvent(this); | 43 } |
40 coordination_unit->ObserveOnParentAddedEvent(this); | 44 size_t on_property_changed_count() { return on_property_changed_count_; } |
41 coordination_unit->ObserveOnPropertyChangedEvent(this); | 45 size_t on_child_removed_count() { return on_child_removed_count_; } |
42 coordination_unit->ObserveOnChildRemovedEvent(this); | 46 size_t on_parent_removed_count() { return on_parent_removed_count_; } |
43 coordination_unit->ObserveOnParentRemovedEvent(this); | 47 size_t on_coordination_unit_will_be_destroyed_count() { |
44 coordination_unit->ObserveOnWillBeDestroyedEvent(this); | 48 return on_coordination_unit_will_be_destroyed_count_; |
45 } | 49 } |
46 | 50 |
47 size_t on_child_added_listener_invocations() { | 51 // Overridden from CoordinationUnitGraphObserver. |
48 return on_child_added_listener_invocations_; | 52 bool ShouldObserve(const CoordinationUnitImpl* coordination_unit) override { |
| 53 return coordination_unit->id().type == CoordinationUnitType::kFrame; |
49 } | 54 } |
50 size_t on_parent_added_listener_invocations() { | 55 void OnCoordinationUnitCreated( |
51 return on_parent_added_listener_invocations_; | 56 const CoordinationUnitImpl* coordination_unit) override { |
| 57 ++on_coordination_unit_created_count_; |
52 } | 58 } |
53 size_t on_coordination_unit_created_invocations() { | 59 void OnChildAdded( |
54 return on_coordination_unit_created_invocations_; | 60 const CoordinationUnitImpl* coordination_unit, |
| 61 const CoordinationUnitImpl* child_coordination_unit) override { |
| 62 ++on_child_added_count_; |
55 } | 63 } |
56 size_t on_property_changed_listener_invocations() { | 64 void OnParentAdded( |
57 return on_property_changed_listener_invocations_; | 65 const CoordinationUnitImpl* coordination_unit, |
| 66 const CoordinationUnitImpl* parent_coordination_unit) override { |
| 67 ++on_parent_added_count_; |
58 } | 68 } |
59 size_t on_child_removed_listener_invocations() { | 69 void OnPropertyChanged(const CoordinationUnitImpl* coordination_unit, |
60 return on_child_removed_listener_invocations_; | 70 mojom::PropertyType property) override { |
| 71 ++on_property_changed_count_; |
61 } | 72 } |
62 size_t on_parent_removed_listener_invocations() { | 73 void OnChildRemoved( |
63 return on_parent_removed_listener_invocations_; | 74 const CoordinationUnitImpl* coordination_unit, |
| 75 const CoordinationUnitImpl* former_child_coordination_unit) override { |
| 76 ++on_child_removed_count_; |
64 } | 77 } |
65 size_t on_will_be_destroyed_listener_invocations() { | 78 void OnParentRemoved( |
66 return on_will_be_destroyed_listener_invocations_; | 79 const CoordinationUnitImpl* coordination_unit, |
| 80 const CoordinationUnitImpl* former_parent_coordination_unit) override { |
| 81 ++on_parent_removed_count_; |
| 82 } |
| 83 void OnCoordinationUnitWillBeDestroyed( |
| 84 const CoordinationUnitImpl* coordination_unit) override { |
| 85 ++on_coordination_unit_will_be_destroyed_count_; |
67 } | 86 } |
68 | 87 |
69 void OnChildAddedEvent( | 88 private: |
70 const CoordinationUnitImpl* coordination_unit, | 89 size_t on_child_added_count_; |
71 const CoordinationUnitImpl* child_coordination_unit) override { | 90 size_t on_parent_added_count_; |
72 ++on_child_added_listener_invocations_; | 91 size_t on_coordination_unit_created_count_; |
73 } | 92 size_t on_property_changed_count_; |
74 void OnParentAddedEvent( | 93 size_t on_child_removed_count_; |
75 const CoordinationUnitImpl* coordination_unit, | 94 size_t on_parent_removed_count_; |
76 const CoordinationUnitImpl* parent_coordination_unit) override { | 95 size_t on_coordination_unit_will_be_destroyed_count_; |
77 ++on_parent_added_listener_invocations_; | |
78 } | |
79 void OnPropertyChangedEvent(const CoordinationUnitImpl* coordination_unit, | |
80 mojom::PropertyType property) override { | |
81 ++on_property_changed_listener_invocations_; | |
82 } | |
83 void OnChildRemovedEvent( | |
84 const CoordinationUnitImpl* coordination_unit, | |
85 const CoordinationUnitImpl* former_child_coordination_unit) override { | |
86 ++on_child_removed_listener_invocations_; | |
87 } | |
88 void OnParentRemovedEvent( | |
89 const CoordinationUnitImpl* coordination_unit, | |
90 const CoordinationUnitImpl* former_parent_coordination_unit) override { | |
91 ++on_parent_removed_listener_invocations_; | |
92 } | |
93 void OnWillBeDestroyedEvent( | |
94 const CoordinationUnitImpl* coordination_unit) override { | |
95 ++on_will_be_destroyed_listener_invocations_; | |
96 } | |
97 | |
98 protected: | |
99 explicit TestBasicAPICoordinationUnitGraphObserver( | |
100 CoordinationUnitType filter) | |
101 : CoordinationUnitGraphObserver(filter), | |
102 on_child_added_listener_invocations_(0u), | |
103 on_parent_added_listener_invocations_(0u), | |
104 on_coordination_unit_created_invocations_(0u), | |
105 on_property_changed_listener_invocations_(0u), | |
106 on_child_removed_listener_invocations_(0u), | |
107 on_parent_removed_listener_invocations_(0u), | |
108 on_will_be_destroyed_listener_invocations_(0u) {} | |
109 | |
110 size_t on_child_added_listener_invocations_; | |
111 size_t on_parent_added_listener_invocations_; | |
112 size_t on_coordination_unit_created_invocations_; | |
113 size_t on_property_changed_listener_invocations_; | |
114 size_t on_child_removed_listener_invocations_; | |
115 size_t on_parent_removed_listener_invocations_; | |
116 size_t on_will_be_destroyed_listener_invocations_; | |
117 }; | |
118 | |
119 class TestFilterAPICoordinationUnitGraphObserver | |
120 : public TestBasicAPICoordinationUnitGraphObserver { | |
121 public: | |
122 explicit TestFilterAPICoordinationUnitGraphObserver( | |
123 CoordinationUnitType filter) | |
124 : TestBasicAPICoordinationUnitGraphObserver(filter) {} | |
125 | |
126 void OnCoordinationUnitCreatedEvent( | |
127 CoordinationUnitImpl* coordination_unit) override { | |
128 ++on_coordination_unit_created_invocations_; | |
129 | |
130 coordination_unit->ObserveOnChildAddedEvent(this, | |
131 CoordinationUnitType::kFrame); | |
132 coordination_unit->ObserveOnParentAddedEvent( | |
133 this, CoordinationUnitType::kProcess); | |
134 // TODO(matthalp) Use property mojom::PropertyType enum once it is created. | |
135 // Currently the only enum is mojom::PropertyType::kTest which is mean to | |
136 // be filtered out in the test this observer class is used in. | |
137 coordination_unit->ObserveOnPropertyChangedEvent( | |
138 this, static_cast<mojom::PropertyType>(1)); | |
139 coordination_unit->ObserveOnChildRemovedEvent( | |
140 this, CoordinationUnitType::kNavigation); | |
141 coordination_unit->ObserveOnParentRemovedEvent( | |
142 this, CoordinationUnitType::kWebContents); | |
143 coordination_unit->ObserveOnWillBeDestroyedEvent(this); | |
144 } | |
145 }; | 96 }; |
146 | 97 |
147 } // namespace | 98 } // namespace |
148 | 99 |
149 TEST_F(CoordinationUnitGraphObserverTest, CallbacksInvokedNoFilters) { | 100 TEST_F(CoordinationUnitGraphObserverTest, CallbacksInvokedNoFilters) { |
150 TestBasicAPICoordinationUnitGraphObserver* observer = | 101 EXPECT_TRUE(coordination_unit_manager().observers().empty()); |
151 new TestBasicAPICoordinationUnitGraphObserver(); | 102 coordination_unit_manager().RegisterObserver( |
| 103 base::MakeUnique<TestCoordinationUnitGraphObserver>()); |
152 | 104 |
153 // The observer will be deleted after this test executes when the | 105 EXPECT_EQ(1u, coordination_unit_manager().observers().size()); |
154 // CoordinationUnitManager object goes out of scope and destructs. | 106 TestCoordinationUnitGraphObserver* observer = |
155 coordination_unit_manager()->RegisterObserver( | 107 static_cast<TestCoordinationUnitGraphObserver*>( |
156 std::unique_ptr<TestBasicAPICoordinationUnitGraphObserver>(observer)); | 108 coordination_unit_manager().observers()[0].get()); |
157 | 109 |
158 // The CoordinationUnit types are intentionally different to make | |
159 // sure filtering, which is not disabled, does not occur. | |
160 CoordinationUnitID parent_cu_id(CoordinationUnitType::kWebContents, | |
161 std::string()); | |
162 CoordinationUnitID child_cu_id(CoordinationUnitType::kFrame, std::string()); | |
163 | |
164 std::unique_ptr<CoordinationUnitImpl> parent_coordination_unit = | |
165 coordination_unit_factory::CreateCoordinationUnit( | |
166 parent_cu_id, service_context_ref_factory()->CreateRef()); | |
167 std::unique_ptr<CoordinationUnitImpl> child_coordination_unit = | |
168 coordination_unit_factory::CreateCoordinationUnit( | |
169 child_cu_id, service_context_ref_factory()->CreateRef()); | |
170 | |
171 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | |
172 parent_coordination_unit.get()); | |
173 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | |
174 child_coordination_unit.get()); | |
175 | |
176 parent_coordination_unit->AddChild(child_coordination_unit->id()); | |
177 parent_coordination_unit->RemoveChild(child_coordination_unit->id()); | |
178 | |
179 parent_coordination_unit->SetProperty(mojom::PropertyType::kTest, | |
180 base::Value(42)); | |
181 | |
182 child_coordination_unit->WillBeDestroyed(); | |
183 parent_coordination_unit->WillBeDestroyed(); | |
184 | |
185 EXPECT_EQ(1u, observer->on_child_added_listener_invocations()); | |
186 EXPECT_EQ(1u, observer->on_child_removed_listener_invocations()); | |
187 EXPECT_EQ(2u, observer->on_coordination_unit_created_invocations()); | |
188 EXPECT_EQ(1u, observer->on_parent_added_listener_invocations()); | |
189 EXPECT_EQ(1u, observer->on_parent_removed_listener_invocations()); | |
190 EXPECT_EQ(1u, observer->on_property_changed_listener_invocations()); | |
191 EXPECT_EQ(2u, observer->on_will_be_destroyed_listener_invocations()); | |
192 } | |
193 | |
194 TEST_F(CoordinationUnitGraphObserverTest, CallbacksInvokedWithoutFilters) { | |
195 TestFilterAPICoordinationUnitGraphObserver* observer = | |
196 new TestFilterAPICoordinationUnitGraphObserver( | |
197 CoordinationUnitType::kFrame); | |
198 coordination_unit_manager()->RegisterObserver( | |
199 std::unique_ptr<TestFilterAPICoordinationUnitGraphObserver>(observer)); | |
200 | |
201 // The CoordinationUnit types are intentionally different to test | |
202 // that filtering is working correctly. | |
203 CoordinationUnitID process_cu_id(CoordinationUnitType::kProcess, | 110 CoordinationUnitID process_cu_id(CoordinationUnitType::kProcess, |
204 std::string()); | 111 std::string()); |
205 CoordinationUnitID tab_cu_id(CoordinationUnitType::kWebContents, | |
206 std::string()); | |
207 CoordinationUnitID root_frame_cu_id(CoordinationUnitType::kFrame, | 112 CoordinationUnitID root_frame_cu_id(CoordinationUnitType::kFrame, |
208 std::string()); | 113 std::string()); |
209 CoordinationUnitID frame_cu_id(CoordinationUnitType::kFrame, std::string()); | 114 CoordinationUnitID frame_cu_id(CoordinationUnitType::kFrame, std::string()); |
210 CoordinationUnitID navigation_cu_id(CoordinationUnitType::kNavigation, | |
211 std::string()); | |
212 | 115 |
213 std::unique_ptr<CoordinationUnitImpl> process_coordination_unit = | 116 std::unique_ptr<CoordinationUnitImpl> process_coordination_unit = |
214 coordination_unit_factory::CreateCoordinationUnit( | 117 coordination_unit_factory::CreateCoordinationUnit( |
215 process_cu_id, service_context_ref_factory()->CreateRef()); | 118 process_cu_id, service_context_ref_factory()->CreateRef()); |
216 std::unique_ptr<CoordinationUnitImpl> tab_coordination_unit = | |
217 coordination_unit_factory::CreateCoordinationUnit( | |
218 tab_cu_id, service_context_ref_factory()->CreateRef()); | |
219 std::unique_ptr<CoordinationUnitImpl> root_frame_coordination_unit = | 119 std::unique_ptr<CoordinationUnitImpl> root_frame_coordination_unit = |
220 coordination_unit_factory::CreateCoordinationUnit( | 120 coordination_unit_factory::CreateCoordinationUnit( |
221 root_frame_cu_id, service_context_ref_factory()->CreateRef()); | 121 root_frame_cu_id, service_context_ref_factory()->CreateRef()); |
222 std::unique_ptr<CoordinationUnitImpl> frame_coordination_unit = | 122 std::unique_ptr<CoordinationUnitImpl> frame_coordination_unit = |
223 coordination_unit_factory::CreateCoordinationUnit( | 123 coordination_unit_factory::CreateCoordinationUnit( |
224 frame_cu_id, service_context_ref_factory()->CreateRef()); | 124 frame_cu_id, service_context_ref_factory()->CreateRef()); |
225 std::unique_ptr<CoordinationUnitImpl> navigation_coordination_unit = | |
226 coordination_unit_factory::CreateCoordinationUnit( | |
227 navigation_cu_id, service_context_ref_factory()->CreateRef()); | |
228 | 125 |
229 // Should only invoke the OnCoordinationUnitCreated listener for | 126 coordination_unit_manager().OnCoordinationUnitCreated( |
230 // the root_frame and frame CoordinationUnits because the observer | |
231 // filter is set to CoordinationUnitType::kFrame. | |
232 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | |
233 process_coordination_unit.get()); | 127 process_coordination_unit.get()); |
234 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | 128 coordination_unit_manager().OnCoordinationUnitCreated( |
235 tab_coordination_unit.get()); | |
236 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | |
237 root_frame_coordination_unit.get()); | 129 root_frame_coordination_unit.get()); |
238 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | 130 coordination_unit_manager().OnCoordinationUnitCreated( |
239 frame_coordination_unit.get()); | 131 frame_coordination_unit.get()); |
240 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated( | 132 EXPECT_EQ(2u, observer->on_coordination_unit_created_count()); |
241 navigation_coordination_unit.get()); | |
242 | 133 |
243 // Test AddChild filtering. The AddChild filter for the frame | 134 // The registered observer will only observe the events that happen to |
244 // CoordinationUnit has been set to only execute when the child | 135 // |root_frame_coordination_unit| and |frame_coordination_unit| because |
245 // is a CoordinationUnitType::kFrame so the callback will execute. | 136 // they are CoordinationUnitType::kFrame. |
| 137 // OnAddParent will called for |root_frame_coordination_unit|. |
| 138 process_coordination_unit->AddChild(root_frame_coordination_unit->id()); |
| 139 // OnAddParent will called for |frame_coordination_unit|. |
| 140 process_coordination_unit->AddChild(frame_coordination_unit->id()); |
| 141 // OnAddChild will called for |root_frame_coordination_unit| and |
| 142 // OnAddParent will called for |frame_coordination_unit|. |
246 root_frame_coordination_unit->AddChild(frame_coordination_unit->id()); | 143 root_frame_coordination_unit->AddChild(frame_coordination_unit->id()); |
247 // The child is CoordinationUnitType::kNavigation so the callback | 144 EXPECT_EQ(1u, observer->on_child_added_count()); |
248 // should not be executed. The navigation Coordination Unit is not | 145 EXPECT_EQ(3u, observer->on_parent_added_count()); |
249 // actually a child of a frame in practice, but is being used here to | |
250 // check filtering on OnChildAdded. | |
251 root_frame_coordination_unit->AddChild(navigation_coordination_unit->id()); | |
252 | 146 |
253 // Test AddParent filtering. The AddParent filter for the frame | 147 // The registered observer will only observe the events that happen to |
254 // CoordinationUnit has been set to only execute when the parent | 148 // |root_frame_coordination_unit| and |frame_coordination_unit| because |
255 // is a CoordinationUnitType::kProcess so the callback will execute. | 149 // they are CoordinationUnitType::kFrame. |
256 // Note that AddParent is called within Add child. | 150 // OnRemoveParent will called for |root_frame_coordination_unit|. |
257 process_coordination_unit->AddChild(root_frame_coordination_unit->id()); | 151 process_coordination_unit->RemoveChild(root_frame_coordination_unit->id()); |
258 // The parent is CoordinationUnitType::kFrame so the callback | 152 // OnRemoveParent will called for |frame_coordination_unit|. |
259 // should not be executed. | 153 process_coordination_unit->RemoveChild(frame_coordination_unit->id()); |
260 tab_coordination_unit->AddChild(root_frame_coordination_unit->id()); | 154 // OnRemoveChild will called for |root_frame_coordination_unit| and |
| 155 // OnRemoveParent will called for |frame_coordination_unit|. |
| 156 root_frame_coordination_unit->RemoveChild(frame_coordination_unit->id()); |
| 157 EXPECT_EQ(1u, observer->on_child_removed_count()); |
| 158 EXPECT_EQ(3u, observer->on_parent_removed_count()); |
261 | 159 |
262 // Test RemoveChild filtering. The RemoveChild filter for the frame | 160 // The registered observer will only observe the events that happen to |
263 // CoordinationUnit has been set to only execute when the child | 161 // |root_frame_coordination_unit| and |frame_coordination_unit| because |
264 // is a CoordinationUnitType::kFrame so the callback will execute. | 162 // they are CoordinationUnitType::kFrame, so OnPropertyChanged |
265 root_frame_coordination_unit->RemoveChild(frame_coordination_unit->id()); | 163 // will only be called for |root_frame_coordination_unit|. |
266 // The child is CoordinationUnitType::kNavigation so the callback | |
267 // should not be executed. The navigation Coordination Unit is not | |
268 // actually a child of a frame in practice, but is being used here to | |
269 // check filtering on OnRemoveChild. | |
270 root_frame_coordination_unit->RemoveChild(navigation_coordination_unit->id()); | |
271 | |
272 // Test RemoveParent filtering. The RemoveParent filter for the frame | |
273 // CoordinationUnit has been set to only execute when the parent | |
274 // is a CoordinationUnitType::kProcess so the callback will execute. | |
275 // Note that RemoveParent is called within Remove child. | |
276 process_coordination_unit->RemoveChild(root_frame_coordination_unit->id()); | |
277 // The parent is CoordinationUnitType::kFrame so the callback | |
278 // should not be executed. | |
279 tab_coordination_unit->RemoveChild(root_frame_coordination_unit->id()); | |
280 | |
281 // TODO(matthalp) Implement this another SetProperty once an additional | |
282 // mojom::PropertyType has been implemented so that the SetProperty | |
283 // filtering API can be tested. | |
284 root_frame_coordination_unit->SetProperty(mojom::PropertyType::kTest, | 164 root_frame_coordination_unit->SetProperty(mojom::PropertyType::kTest, |
285 base::Value(42)); | 165 base::Value(42)); |
| 166 process_coordination_unit->SetProperty(mojom::PropertyType::kTest, |
| 167 base::Value(42)); |
| 168 EXPECT_EQ(1u, observer->on_property_changed_count()); |
286 | 169 |
287 frame_coordination_unit->WillBeDestroyed(); | 170 coordination_unit_manager().OnCoordinationUnitWillBeDestroyed( |
288 navigation_coordination_unit->WillBeDestroyed(); | 171 process_coordination_unit.get()); |
289 process_coordination_unit->WillBeDestroyed(); | 172 coordination_unit_manager().OnCoordinationUnitWillBeDestroyed( |
290 root_frame_coordination_unit->WillBeDestroyed(); | 173 root_frame_coordination_unit.get()); |
291 tab_coordination_unit->WillBeDestroyed(); | 174 coordination_unit_manager().OnCoordinationUnitWillBeDestroyed( |
292 | 175 frame_coordination_unit.get()); |
293 EXPECT_EQ(1u, observer->on_child_added_listener_invocations()); | 176 EXPECT_EQ(2u, observer->on_coordination_unit_will_be_destroyed_count()); |
294 EXPECT_EQ(1u, observer->on_child_removed_listener_invocations()); | |
295 EXPECT_EQ(2u, observer->on_coordination_unit_created_invocations()); | |
296 EXPECT_EQ(1u, observer->on_parent_added_listener_invocations()); | |
297 EXPECT_EQ(1u, observer->on_parent_removed_listener_invocations()); | |
298 EXPECT_EQ(0u, observer->on_property_changed_listener_invocations()); | |
299 EXPECT_EQ(2u, observer->on_will_be_destroyed_listener_invocations()); | |
300 } | 177 } |
301 | 178 |
302 } // namespace resource_coordinator | 179 } // namespace resource_coordinator |
OLD | NEW |