Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3)

Side by Side Diff: services/resource_coordinator/coordination_unit/coordination_unit_graph_observer_unittest.cc

Issue 2942403002: [GRC] Coordination Unit Graph Observer (Closed)
Patch Set: Rename API function calls Created 3 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include <string>
6 #include <utility>
7
8 #include "base/memory/ptr_util.h"
9 #include "base/process/process_handle.h"
10 #include "base/run_loop.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"
13 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl .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"
16 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
17 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
18 #include "services/resource_coordinator/public/interfaces/coordination_unit.mojo m.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20
21 namespace resource_coordinator {
22
23 namespace {
24
25 class CoordinationUnitGraphObserverTest : public CoordinationUnitImplTestBase {
26 };
27
28 class TestBasicAPICoordinationUnitGraphObserver
29 : public CoordinationUnitGraphObserver {
30 public:
31 TestBasicAPICoordinationUnitGraphObserver()
32 : TestBasicAPICoordinationUnitGraphObserver(
33 CoordinationUnitType::kInvalidType) {}
34
35 void OnCoordinationUnitCreatedEvent(
36 CoordinationUnitImpl* coordination_unit) override {
37 ++on_coordination_unit_created_invocations_;
38
39 coordination_unit->ObserveOnChildAddedEvent(this);
40 coordination_unit->ObserveOnParentAddedEvent(this);
41 coordination_unit->ObserveOnPropertyChangedEvent(this);
42 coordination_unit->ObserveOnChildRemovedEvent(this);
43 coordination_unit->ObserveOnParentRemovedEvent(this);
44 coordination_unit->ObserveOnWillBeDestroyedEvent(this);
45 }
46
47 size_t on_child_added_listener_invocations() {
48 return on_child_added_listener_invocations_;
49 }
50 size_t on_parent_added_listener_invocations() {
51 return on_parent_added_listener_invocations_;
52 }
53 size_t on_coordination_unit_created_invocations() {
54 return on_coordination_unit_created_invocations_;
55 }
56 size_t on_property_changed_listener_invocations() {
57 return on_property_changed_listener_invocations_;
58 }
59 size_t on_child_removed_listener_invocations() {
60 return on_child_removed_listener_invocations_;
61 }
62 size_t on_parent_removed_listener_invocations() {
63 return on_parent_removed_listener_invocations_;
64 }
65 size_t on_will_be_destroyed_listener_invocations() {
66 return on_will_be_destroyed_listener_invocations_;
67 }
68
69 void OnChildAddedEvent(
70 const CoordinationUnitImpl* coordination_unit,
71 const CoordinationUnitImpl* child_coordination_unit) override {
72 ++on_child_added_listener_invocations_;
73 }
74 void OnParentAddedEvent(
75 const CoordinationUnitImpl* coordination_unit,
76 const CoordinationUnitImpl* parent_coordination_unit) override {
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 };
146
147 } // namespace
148
149 TEST_F(CoordinationUnitGraphObserverTest, CallbacksInvokedNoFilters) {
150 TestBasicAPICoordinationUnitGraphObserver* observer =
151 new TestBasicAPICoordinationUnitGraphObserver();
152
153 // The observer will be deleted after this test executes when the
154 // CoordinationUnitManager object goes out of scope and destructs.
155 coordination_unit_manager()->RegisterObserver(
156 std::unique_ptr<TestBasicAPICoordinationUnitGraphObserver>(observer));
Zhen Wang 2017/06/19 22:54:25 This is for line 150-156. In general using raw po
matthalp 2017/06/20 19:02:51 Done.
157
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());
Zhen Wang 2017/06/19 22:54:24 nit: it probably helps readability to do this chec
matthalp 2017/06/20 19:02:51 Good suggestion. I moved the EXPECT_EQ directly af
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) {
Zhen Wang 2017/06/19 22:54:25 Do you mean "With" filters here? And "WithoutFilte
matthalp 2017/06/20 19:02:52 Filtering has been removed -- this is no longer ap
195 TestFilterAPICoordinationUnitGraphObserver* observer =
Zhen Wang 2017/06/19 22:54:24 ditto. Do not use raw pointers here.
matthalp 2017/06/20 19:02:52 Filtering has been removed -- this is no longer ap
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,
204 std::string());
205 CoordinationUnitID tab_cu_id(CoordinationUnitType::kWebContents,
206 std::string());
207 CoordinationUnitID root_frame_cu_id(CoordinationUnitType::kFrame,
208 std::string());
209 CoordinationUnitID frame_cu_id(CoordinationUnitType::kFrame, std::string());
210 CoordinationUnitID navigation_cu_id(CoordinationUnitType::kNavigation,
211 std::string());
212
213 std::unique_ptr<CoordinationUnitImpl> process_coordination_unit =
214 coordination_unit_factory::CreateCoordinationUnit(
215 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 =
220 coordination_unit_factory::CreateCoordinationUnit(
221 root_frame_cu_id, service_context_ref_factory()->CreateRef());
222 std::unique_ptr<CoordinationUnitImpl> frame_coordination_unit =
223 coordination_unit_factory::CreateCoordinationUnit(
224 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
229 // Should only invoke the OnCoordinationUnitCreated listener for
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());
234 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated(
235 tab_coordination_unit.get());
236 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated(
237 root_frame_coordination_unit.get());
238 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated(
239 frame_coordination_unit.get());
240 coordination_unit_manager()->NotifyObserversCoordinationUnitCreated(
241 navigation_coordination_unit.get());
242
243 // Test AddChild filtering. The AddChild filter for the frame
244 // CoordinationUnit has been set to only execute when the child
245 // is a CoordinationUnitType::kFrame so the callback will execute.
246 root_frame_coordination_unit->AddChild(frame_coordination_unit->id());
247 // The child is CoordinationUnitType::kNavigation so the callback
248 // should not be executed. The navigation Coordination Unit is not
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
253 // Test AddParent filtering. The AddParent filter for the frame
254 // CoordinationUnit has been set to only execute when the parent
255 // is a CoordinationUnitType::kProcess so the callback will execute.
256 // Note that AddParent is called within Add child.
Zhen Wang 2017/06/19 22:54:24 s/within Add child/as a consequence of AddChild.
matthalp 2017/06/20 19:02:52 Filtering has been removed -- this is no longer ap
257 process_coordination_unit->AddChild(root_frame_coordination_unit->id());
258 // The parent is CoordinationUnitType::kFrame so the callback
259 // should not be executed.
260 tab_coordination_unit->AddChild(root_frame_coordination_unit->id());
261
262 // Test RemoveChild filtering. The RemoveChild filter for the frame
263 // CoordinationUnit has been set to only execute when the child
264 // is a CoordinationUnitType::kFrame so the callback will execute.
265 root_frame_coordination_unit->RemoveChild(frame_coordination_unit->id());
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,
285 base::Value(42));
286
287 frame_coordination_unit->WillBeDestroyed();
288 navigation_coordination_unit->WillBeDestroyed();
289 process_coordination_unit->WillBeDestroyed();
290 root_frame_coordination_unit->WillBeDestroyed();
291 tab_coordination_unit->WillBeDestroyed();
292
293 EXPECT_EQ(1u, observer->on_child_added_listener_invocations());
294 EXPECT_EQ(1u, observer->on_child_removed_listener_invocations());
295 EXPECT_EQ(2u, observer->on_coordination_unit_created_invocations());
Zhen Wang 2017/06/19 22:54:24 nit: it probably helps readability to do this chec
matthalp 2017/06/20 19:02:52 Filtering has been removed -- this is no longer ap
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 }
301
302 } // namespace resource_coordinator
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698