OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "components/sync_sessions/tab_node_pool.h" | 5 #include "components/sync_sessions/tab_node_pool.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "components/sync/model/sync_change.h" | |
10 #include "components/sync/protocol/session_specifics.pb.h" | |
11 #include "components/sync/protocol/sync.pb.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
13 | 10 |
14 namespace sync_sessions { | 11 namespace sync_sessions { |
15 | 12 |
16 class SyncTabNodePoolTest : public testing::Test { | 13 class SyncTabNodePoolTest : public testing::Test { |
17 protected: | 14 protected: |
18 SyncTabNodePoolTest() { pool_.SetMachineTag("tag"); } | 15 SyncTabNodePoolTest() {} |
19 | 16 |
20 int GetMaxUsedTabNodeId() const { return pool_.max_used_tab_node_id_; } | 17 int GetMaxUsedTabNodeId() const { return pool_.max_used_tab_node_id_; } |
21 | 18 |
22 void AddFreeTabNodes(size_t size, const int node_ids[]); | 19 void AddFreeTabNodes(size_t size, const int node_ids[]); |
23 | 20 |
24 TabNodePool pool_; | 21 TabNodePool pool_; |
25 }; | 22 }; |
26 | 23 |
27 void SyncTabNodePoolTest::AddFreeTabNodes(size_t size, const int node_ids[]) { | 24 void SyncTabNodePoolTest::AddFreeTabNodes(size_t size, const int node_ids[]) { |
28 for (size_t i = 0; i < size; ++i) { | 25 for (size_t i = 0; i < size; ++i) { |
29 pool_.free_nodes_pool_.insert(node_ids[i]); | 26 pool_.free_nodes_pool_.insert(node_ids[i]); |
30 } | 27 } |
31 } | 28 } |
32 | 29 |
33 namespace { | 30 namespace { |
34 | 31 |
| 32 const int kTabNodeId1 = 10; |
| 33 const int kTabNodeId2 = 5; |
| 34 const int kTabNodeId3 = 1000; |
| 35 const int kTabId1 = 1; |
| 36 const int kTabId2 = 2; |
| 37 const int kTabId3 = 3; |
| 38 |
35 TEST_F(SyncTabNodePoolTest, TabNodeIdIncreases) { | 39 TEST_F(SyncTabNodePoolTest, TabNodeIdIncreases) { |
36 syncer::SyncChangeList changes; | 40 std::set<int> deleted_node_ids; |
| 41 |
37 // max_used_tab_node_ always increases. | 42 // max_used_tab_node_ always increases. |
38 pool_.AddTabNode(10); | 43 pool_.ReassociateTabNode(kTabNodeId1, kTabId1); |
39 EXPECT_EQ(10, GetMaxUsedTabNodeId()); | 44 EXPECT_EQ(kTabNodeId1, GetMaxUsedTabNodeId()); |
40 pool_.AddTabNode(5); | 45 pool_.ReassociateTabNode(kTabNodeId2, kTabId2); |
41 EXPECT_EQ(10, GetMaxUsedTabNodeId()); | 46 EXPECT_EQ(kTabNodeId1, GetMaxUsedTabNodeId()); |
42 pool_.AddTabNode(1000); | 47 pool_.ReassociateTabNode(kTabNodeId3, kTabId3); |
43 EXPECT_EQ(1000, GetMaxUsedTabNodeId()); | 48 EXPECT_EQ(kTabNodeId3, GetMaxUsedTabNodeId()); |
44 pool_.ReassociateTabNode(1000, 1); | |
45 pool_.ReassociateTabNode(5, 2); | |
46 pool_.ReassociateTabNode(10, 3); | |
47 // Freeing a tab node does not change max_used_tab_node_id_. | 49 // Freeing a tab node does not change max_used_tab_node_id_. |
48 pool_.FreeTabNode(1000, &changes); | 50 pool_.FreeTab(kTabId3); |
49 EXPECT_TRUE(changes.empty()); | 51 pool_.CleanupTabNodes(&deleted_node_ids); |
50 pool_.FreeTabNode(5, &changes); | 52 EXPECT_TRUE(deleted_node_ids.empty()); |
51 EXPECT_TRUE(changes.empty()); | 53 pool_.FreeTab(kTabId2); |
52 pool_.FreeTabNode(10, &changes); | 54 pool_.CleanupTabNodes(&deleted_node_ids); |
53 EXPECT_TRUE(changes.empty()); | 55 EXPECT_TRUE(deleted_node_ids.empty()); |
| 56 pool_.FreeTab(kTabId1); |
| 57 pool_.CleanupTabNodes(&deleted_node_ids); |
| 58 EXPECT_TRUE(deleted_node_ids.empty()); |
54 for (int i = 0; i < 3; ++i) { | 59 for (int i = 0; i < 3; ++i) { |
55 pool_.AssociateTabNode(pool_.GetFreeTabNode(&changes), i + 1); | 60 int tab_node_id = -1; |
56 EXPECT_EQ(1000, GetMaxUsedTabNodeId()); | 61 EXPECT_TRUE(pool_.GetTabNodeForTab(i + 1, &tab_node_id)); |
| 62 EXPECT_EQ(kTabNodeId3, GetMaxUsedTabNodeId()); |
57 } | 63 } |
58 EXPECT_TRUE(changes.empty()); | 64 pool_.CleanupTabNodes(&deleted_node_ids); |
59 EXPECT_EQ(1000, GetMaxUsedTabNodeId()); | 65 EXPECT_TRUE(deleted_node_ids.empty()); |
| 66 EXPECT_EQ(kTabNodeId3, GetMaxUsedTabNodeId()); |
60 EXPECT_TRUE(pool_.Empty()); | 67 EXPECT_TRUE(pool_.Empty()); |
61 } | 68 } |
62 | 69 |
63 TEST_F(SyncTabNodePoolTest, OldTabNodesAddAndRemove) { | 70 TEST_F(SyncTabNodePoolTest, Reassociation) { |
64 syncer::SyncChangeList changes; | 71 // Reassociate tab node 1 with tab id 1. |
65 // VerifyOldTabNodes are added. | 72 pool_.ReassociateTabNode(kTabNodeId1, kTabId1); |
66 pool_.AddTabNode(1); | 73 EXPECT_EQ(1U, pool_.Capacity()); |
67 pool_.AddTabNode(2); | |
68 EXPECT_EQ(2u, pool_.Capacity()); | |
69 EXPECT_TRUE(pool_.Empty()); | |
70 EXPECT_TRUE(pool_.IsUnassociatedTabNode(1)); | |
71 EXPECT_TRUE(pool_.IsUnassociatedTabNode(2)); | |
72 pool_.ReassociateTabNode(1, 2); | |
73 EXPECT_TRUE(pool_.Empty()); | |
74 pool_.AssociateTabNode(2, 3); | |
75 EXPECT_FALSE(pool_.IsUnassociatedTabNode(1)); | |
76 EXPECT_FALSE(pool_.IsUnassociatedTabNode(2)); | |
77 pool_.FreeTabNode(2, &changes); | |
78 EXPECT_TRUE(changes.empty()); | |
79 // 2 should be returned to free node pool_. | |
80 EXPECT_EQ(2u, pool_.Capacity()); | |
81 // Should be able to free 1. | |
82 pool_.FreeTabNode(1, &changes); | |
83 EXPECT_FALSE(pool_.Empty()); | |
84 EXPECT_TRUE(pool_.Full()); | |
85 EXPECT_EQ(1, pool_.GetFreeTabNode(&changes)); | |
86 EXPECT_TRUE(changes.empty()); | |
87 pool_.AssociateTabNode(1, 1); | |
88 EXPECT_EQ(2, pool_.GetFreeTabNode(&changes)); | |
89 EXPECT_TRUE(changes.empty()); | |
90 pool_.AssociateTabNode(2, 1); | |
91 EXPECT_TRUE(pool_.Empty()); | 74 EXPECT_TRUE(pool_.Empty()); |
92 EXPECT_FALSE(pool_.Full()); | 75 EXPECT_FALSE(pool_.Full()); |
| 76 EXPECT_EQ(kTabId1, pool_.GetTabIdFromTabNodeId(kTabNodeId1)); |
| 77 EXPECT_EQ(TabNodePool::kInvalidTabNodeID, |
| 78 pool_.GetTabIdFromTabNodeId(kTabNodeId2)); |
| 79 |
| 80 // Introduce a new tab node associated with the same tab. The old tab node |
| 81 // should get added to the free pool |
| 82 pool_.ReassociateTabNode(kTabNodeId2, kTabId1); |
| 83 EXPECT_EQ(2U, pool_.Capacity()); |
| 84 EXPECT_FALSE(pool_.Empty()); |
93 EXPECT_FALSE(pool_.Full()); | 85 EXPECT_FALSE(pool_.Full()); |
| 86 EXPECT_EQ(TabNodePool::kInvalidTabNodeID, |
| 87 pool_.GetTabIdFromTabNodeId(kTabNodeId1)); |
| 88 EXPECT_EQ(kTabId1, pool_.GetTabIdFromTabNodeId(kTabNodeId2)); |
| 89 |
| 90 // Reassociating the same tab node/tab should have no effect. |
| 91 pool_.ReassociateTabNode(kTabNodeId2, kTabId1); |
| 92 EXPECT_EQ(2U, pool_.Capacity()); |
| 93 EXPECT_FALSE(pool_.Empty()); |
| 94 EXPECT_FALSE(pool_.Full()); |
| 95 EXPECT_EQ(TabNodePool::kInvalidTabNodeID, |
| 96 pool_.GetTabIdFromTabNodeId(kTabNodeId1)); |
| 97 EXPECT_EQ(kTabId1, pool_.GetTabIdFromTabNodeId(kTabNodeId2)); |
| 98 |
| 99 // Reassociating the new tab node with a new tab should just update the |
| 100 // association tables. |
| 101 pool_.ReassociateTabNode(kTabNodeId2, kTabId2); |
| 102 EXPECT_EQ(2U, pool_.Capacity()); |
| 103 EXPECT_FALSE(pool_.Empty()); |
| 104 EXPECT_FALSE(pool_.Full()); |
| 105 EXPECT_EQ(TabNodePool::kInvalidTabNodeID, |
| 106 pool_.GetTabIdFromTabNodeId(kTabNodeId1)); |
| 107 EXPECT_EQ(kTabId2, pool_.GetTabIdFromTabNodeId(kTabNodeId2)); |
| 108 |
| 109 // Reassociating the first tab node should make the pool empty. |
| 110 pool_.ReassociateTabNode(kTabNodeId1, kTabId1); |
| 111 EXPECT_EQ(2U, pool_.Capacity()); |
| 112 EXPECT_TRUE(pool_.Empty()); |
| 113 EXPECT_FALSE(pool_.Full()); |
| 114 EXPECT_EQ(kTabId1, pool_.GetTabIdFromTabNodeId(kTabNodeId1)); |
| 115 EXPECT_EQ(kTabId2, pool_.GetTabIdFromTabNodeId(kTabNodeId2)); |
94 } | 116 } |
95 | 117 |
96 TEST_F(SyncTabNodePoolTest, OldTabNodesReassociation) { | 118 TEST_F(SyncTabNodePoolTest, ReassociateThenFree) { |
97 // VerifyOldTabNodes are reassociated correctly. | 119 std::set<int> deleted_node_ids; |
98 pool_.AddTabNode(4); | 120 |
99 pool_.AddTabNode(5); | 121 // Verify old tab nodes are reassociated correctly. |
100 pool_.AddTabNode(6); | 122 pool_.ReassociateTabNode(kTabNodeId1, kTabId1); |
| 123 pool_.ReassociateTabNode(kTabNodeId2, kTabId2); |
| 124 pool_.ReassociateTabNode(kTabNodeId3, kTabId3); |
101 EXPECT_EQ(3u, pool_.Capacity()); | 125 EXPECT_EQ(3u, pool_.Capacity()); |
102 EXPECT_TRUE(pool_.Empty()); | 126 EXPECT_TRUE(pool_.Empty()); |
103 EXPECT_TRUE(pool_.IsUnassociatedTabNode(4)); | 127 // Free tabs 2 and 3. |
104 pool_.ReassociateTabNode(4, 5); | 128 pool_.FreeTab(kTabId2); |
105 pool_.AssociateTabNode(5, 6); | 129 pool_.FreeTab(kTabId3); |
106 pool_.AssociateTabNode(6, 7); | 130 pool_.CleanupTabNodes(&deleted_node_ids); |
107 // Free 5 and 6. | 131 EXPECT_TRUE(deleted_node_ids.empty()); |
108 syncer::SyncChangeList changes; | 132 // Free node pool should have 2 and 3. |
109 pool_.FreeTabNode(5, &changes); | |
110 pool_.FreeTabNode(6, &changes); | |
111 EXPECT_TRUE(changes.empty()); | |
112 // 5 and 6 nodes should not be unassociated. | |
113 EXPECT_FALSE(pool_.IsUnassociatedTabNode(5)); | |
114 EXPECT_FALSE(pool_.IsUnassociatedTabNode(6)); | |
115 // Free node pool should have 5 and 6. | |
116 EXPECT_FALSE(pool_.Empty()); | 133 EXPECT_FALSE(pool_.Empty()); |
117 EXPECT_EQ(3u, pool_.Capacity()); | 134 EXPECT_EQ(3u, pool_.Capacity()); |
118 | 135 |
119 // Free all nodes | 136 // Free all nodes |
120 pool_.FreeTabNode(4, &changes); | 137 pool_.FreeTab(kTabId1); |
121 EXPECT_TRUE(changes.empty()); | 138 pool_.CleanupTabNodes(&deleted_node_ids); |
| 139 EXPECT_TRUE(deleted_node_ids.empty()); |
122 EXPECT_TRUE(pool_.Full()); | 140 EXPECT_TRUE(pool_.Full()); |
123 std::set<int> free_sync_ids; | 141 std::set<int> free_sync_ids; |
124 for (int i = 0; i < 3; ++i) { | 142 for (int i = 0; i < 3; ++i) { |
125 free_sync_ids.insert(pool_.GetFreeTabNode(&changes)); | 143 int tab_node_id = -1; |
126 // GetFreeTabNode will return the same value till the node is | 144 EXPECT_TRUE(pool_.GetTabNodeForTab(i, &tab_node_id)); |
127 // reassociated. | 145 free_sync_ids.insert(tab_node_id); |
128 pool_.AssociateTabNode(pool_.GetFreeTabNode(&changes), i + 1); | |
129 } | 146 } |
130 | 147 |
131 EXPECT_TRUE(pool_.Empty()); | 148 EXPECT_TRUE(pool_.Empty()); |
132 EXPECT_EQ(3u, free_sync_ids.size()); | 149 EXPECT_EQ(3u, free_sync_ids.size()); |
133 EXPECT_EQ(1u, free_sync_ids.count(4)); | 150 EXPECT_EQ(1u, free_sync_ids.count(kTabNodeId1)); |
134 EXPECT_EQ(1u, free_sync_ids.count(5)); | 151 EXPECT_EQ(1u, free_sync_ids.count(kTabNodeId2)); |
135 EXPECT_EQ(1u, free_sync_ids.count(6)); | 152 EXPECT_EQ(1u, free_sync_ids.count(kTabNodeId3)); |
136 } | 153 } |
137 | 154 |
138 TEST_F(SyncTabNodePoolTest, Init) { | 155 TEST_F(SyncTabNodePoolTest, Init) { |
139 EXPECT_TRUE(pool_.Empty()); | 156 EXPECT_TRUE(pool_.Empty()); |
140 EXPECT_TRUE(pool_.Full()); | 157 EXPECT_TRUE(pool_.Full()); |
141 } | 158 } |
142 | 159 |
143 TEST_F(SyncTabNodePoolTest, AddGet) { | 160 TEST_F(SyncTabNodePoolTest, AddGet) { |
144 syncer::SyncChangeList changes; | |
145 int free_nodes[] = {5, 10}; | 161 int free_nodes[] = {5, 10}; |
146 AddFreeTabNodes(2, free_nodes); | 162 AddFreeTabNodes(2, free_nodes); |
147 | 163 |
148 EXPECT_EQ(2U, pool_.Capacity()); | 164 EXPECT_EQ(2U, pool_.Capacity()); |
149 EXPECT_EQ(5, pool_.GetFreeTabNode(&changes)); | 165 int tab_node_id = -1; |
150 pool_.AssociateTabNode(5, 1); | 166 EXPECT_TRUE(pool_.GetTabNodeForTab(1, &tab_node_id)); |
| 167 EXPECT_EQ(5, tab_node_id); |
151 EXPECT_FALSE(pool_.Empty()); | 168 EXPECT_FALSE(pool_.Empty()); |
152 EXPECT_FALSE(pool_.Full()); | 169 EXPECT_FALSE(pool_.Full()); |
153 EXPECT_EQ(2U, pool_.Capacity()); | 170 EXPECT_EQ(2U, pool_.Capacity()); |
154 // 5 is now used, should return 10. | 171 // 5 is now used, should return 10. |
155 EXPECT_EQ(10, pool_.GetFreeTabNode(&changes)); | 172 EXPECT_TRUE(pool_.GetTabNodeForTab(2, &tab_node_id)); |
| 173 EXPECT_EQ(10, tab_node_id); |
156 } | 174 } |
157 | 175 |
158 TEST_F(SyncTabNodePoolTest, All) { | 176 TEST_F(SyncTabNodePoolTest, GetTabNodeForTabCreate) { |
159 syncer::SyncChangeList changes; | 177 int tab_node_id = -1; |
160 EXPECT_TRUE(pool_.Empty()); | 178 EXPECT_FALSE(pool_.GetTabNodeForTab(1, &tab_node_id)); |
161 EXPECT_TRUE(pool_.Full()); | 179 EXPECT_EQ(0, tab_node_id); |
162 EXPECT_EQ(0U, pool_.Capacity()); | |
163 | |
164 // GetFreeTabNode returns the lowest numbered free node. | |
165 EXPECT_EQ(0, pool_.GetFreeTabNode(&changes)); | |
166 EXPECT_EQ(1U, changes.size()); | |
167 EXPECT_FALSE(pool_.Empty()); | |
168 EXPECT_TRUE(pool_.Full()); | |
169 EXPECT_EQ(1U, pool_.Capacity()); | |
170 | |
171 // Associate 5, next free node should be 10. | |
172 pool_.AssociateTabNode(0, 1); | |
173 EXPECT_EQ(1, pool_.GetFreeTabNode(&changes)); | |
174 EXPECT_EQ(2U, changes.size()); | |
175 changes.clear(); | |
176 pool_.AssociateTabNode(1, 2); | |
177 EXPECT_TRUE(pool_.Empty()); | |
178 EXPECT_FALSE(pool_.Full()); | |
179 EXPECT_EQ(2U, pool_.Capacity()); | |
180 // Release them in reverse order. | |
181 pool_.FreeTabNode(1, &changes); | |
182 pool_.FreeTabNode(0, &changes); | |
183 EXPECT_EQ(2U, pool_.Capacity()); | |
184 EXPECT_FALSE(pool_.Empty()); | |
185 EXPECT_TRUE(pool_.Full()); | |
186 EXPECT_EQ(0, pool_.GetFreeTabNode(&changes)); | |
187 EXPECT_TRUE(changes.empty()); | |
188 EXPECT_FALSE(pool_.Empty()); | |
189 EXPECT_TRUE(pool_.Full()); | |
190 EXPECT_EQ(2U, pool_.Capacity()); | |
191 EXPECT_FALSE(pool_.Empty()); | |
192 EXPECT_TRUE(pool_.Full()); | |
193 pool_.AssociateTabNode(0, 1); | |
194 EXPECT_EQ(2U, pool_.Capacity()); | |
195 EXPECT_EQ(1, pool_.GetFreeTabNode(&changes)); | |
196 EXPECT_TRUE(changes.empty()); | |
197 pool_.AssociateTabNode(1, 2); | |
198 EXPECT_TRUE(pool_.Empty()); | |
199 EXPECT_FALSE(pool_.Full()); | |
200 EXPECT_EQ(2U, pool_.Capacity()); | |
201 // Release them again. | |
202 pool_.FreeTabNode(1, &changes); | |
203 pool_.FreeTabNode(0, &changes); | |
204 EXPECT_FALSE(pool_.Empty()); | |
205 EXPECT_TRUE(pool_.Full()); | |
206 EXPECT_EQ(2U, pool_.Capacity()); | |
207 pool_.Clear(); | |
208 EXPECT_TRUE(pool_.Empty()); | |
209 EXPECT_TRUE(pool_.Full()); | |
210 EXPECT_EQ(0U, pool_.Capacity()); | |
211 } | |
212 | |
213 TEST_F(SyncTabNodePoolTest, GetFreeTabNodeCreate) { | |
214 syncer::SyncChangeList changes; | |
215 EXPECT_EQ(0, pool_.GetFreeTabNode(&changes)); | |
216 EXPECT_TRUE(changes[0].IsValid()); | |
217 EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type()); | |
218 EXPECT_TRUE(changes[0].sync_data().IsValid()); | |
219 sync_pb::EntitySpecifics entity = changes[0].sync_data().GetSpecifics(); | |
220 sync_pb::SessionSpecifics specifics(entity.session()); | |
221 EXPECT_EQ(0, specifics.tab_node_id()); | |
222 } | 180 } |
223 | 181 |
224 TEST_F(SyncTabNodePoolTest, TabPoolFreeNodeLimits) { | 182 TEST_F(SyncTabNodePoolTest, TabPoolFreeNodeLimits) { |
| 183 std::set<int> deleted_node_ids; |
| 184 |
225 // Allocate TabNodePool::kFreeNodesHighWatermark + 1 nodes and verify that | 185 // Allocate TabNodePool::kFreeNodesHighWatermark + 1 nodes and verify that |
226 // freeing the last node reduces the free node pool size to | 186 // freeing the last node reduces the free node pool size to |
227 // kFreeNodesLowWatermark. | 187 // kFreeNodesLowWatermark. |
228 syncer::SyncChangeList changes; | |
229 SessionID session_id; | 188 SessionID session_id; |
230 std::vector<int> used_sync_ids; | 189 std::vector<int> used_sync_ids; |
231 for (size_t i = 1; i <= TabNodePool::kFreeNodesHighWatermark + 1; ++i) { | 190 for (size_t i = 1; i <= TabNodePool::kFreeNodesHighWatermark + 1; ++i) { |
232 session_id.set_id(i); | 191 session_id.set_id(i); |
233 int sync_id = pool_.GetFreeTabNode(&changes); | 192 int sync_id = -1; |
234 pool_.AssociateTabNode(sync_id, i); | 193 EXPECT_FALSE(pool_.GetTabNodeForTab(i, &sync_id)); |
235 used_sync_ids.push_back(sync_id); | 194 used_sync_ids.push_back(sync_id); |
236 } | 195 } |
237 | 196 |
238 // Free all except one node. | 197 // Free all except one node. |
239 int last_sync_id = used_sync_ids.back(); | |
240 used_sync_ids.pop_back(); | 198 used_sync_ids.pop_back(); |
241 | 199 |
242 for (size_t i = 0; i < used_sync_ids.size(); ++i) { | 200 for (size_t i = 1; i <= used_sync_ids.size(); ++i) { |
243 pool_.FreeTabNode(used_sync_ids[i], &changes); | 201 pool_.FreeTab(i); |
| 202 pool_.CleanupTabNodes(&deleted_node_ids); |
| 203 EXPECT_TRUE(deleted_node_ids.empty()); |
244 } | 204 } |
245 | 205 |
246 // Except one node all nodes should be in FreeNode pool. | 206 // Except one node all nodes should be in FreeNode pool. |
247 EXPECT_FALSE(pool_.Full()); | 207 EXPECT_FALSE(pool_.Full()); |
248 EXPECT_FALSE(pool_.Empty()); | 208 EXPECT_FALSE(pool_.Empty()); |
249 // Total capacity = 1 Associated Node + kFreeNodesHighWatermark free node. | 209 // Total capacity = 1 Associated Node + kFreeNodesHighWatermark free node. |
250 EXPECT_EQ(TabNodePool::kFreeNodesHighWatermark + 1, pool_.Capacity()); | 210 EXPECT_EQ(TabNodePool::kFreeNodesHighWatermark + 1, pool_.Capacity()); |
251 | 211 |
252 // Freeing the last sync node should drop the free nodes to | 212 // Freeing the last sync node should drop the free nodes to |
253 // kFreeNodesLowWatermark. | 213 // kFreeNodesLowWatermark. |
254 pool_.FreeTabNode(last_sync_id, &changes); | 214 pool_.FreeTab(TabNodePool::kFreeNodesHighWatermark + 1); |
| 215 pool_.CleanupTabNodes(&deleted_node_ids); |
| 216 EXPECT_EQ(TabNodePool::kFreeNodesHighWatermark + 1 - |
| 217 TabNodePool::kFreeNodesLowWatermark, |
| 218 deleted_node_ids.size()); |
255 EXPECT_FALSE(pool_.Empty()); | 219 EXPECT_FALSE(pool_.Empty()); |
256 EXPECT_TRUE(pool_.Full()); | 220 EXPECT_TRUE(pool_.Full()); |
257 EXPECT_EQ(TabNodePool::kFreeNodesLowWatermark, pool_.Capacity()); | 221 EXPECT_EQ(TabNodePool::kFreeNodesLowWatermark, pool_.Capacity()); |
258 } | 222 } |
259 | 223 |
260 } // namespace | 224 } // namespace |
261 | 225 |
262 } // namespace sync_sessions | 226 } // namespace sync_sessions |
OLD | NEW |