OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 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/synced_session_tracker.h" | 5 #include "components/sync_sessions/synced_session_tracker.h" |
6 | 6 |
7 #include "base/rand_util.h" | 7 #include "base/rand_util.h" |
8 #include "base/strings/stringprintf.h" | 8 #include "base/strings/stringprintf.h" |
9 #include "base/strings/utf_string_conversions.h" | 9 #include "base/strings/utf_string_conversions.h" |
10 #include "components/sessions/core/serialized_navigation_entry_test_helper.h" | 10 #include "components/sessions/core/serialized_navigation_entry_test_helper.h" |
11 #include "components/sync_sessions/fake_sync_sessions_client.h" | 11 #include "components/sync_sessions/fake_sync_sessions_client.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 | 13 |
14 namespace sync_sessions { | 14 namespace sync_sessions { |
15 | 15 |
16 namespace { | 16 namespace { |
17 | 17 |
18 const char kValidUrl[] = "http://www.example.com"; | 18 const char kValidUrl[] = "http://www.example.com"; |
19 const char kInvalidUrl[] = "invalid.url"; | 19 const char kInvalidUrl[] = "invalid.url"; |
20 const char kTag[] = "tag"; | |
21 const char kTag2[] = "tag2"; | |
22 const char kTag3[] = "tag3"; | |
23 const char kTitle[] = "title"; | |
24 const int kWindow1 = 1; | |
25 const int kTabNode = 0; | |
26 const int kTab1 = 15; | |
27 const int kTab2 = 25; | |
28 const int kTab3 = 35; | |
29 | 20 |
30 } // namespace | 21 } // namespace |
31 | 22 |
32 class SyncedSessionTrackerTest : public testing::Test { | 23 class SyncedSessionTrackerTest : public testing::Test { |
33 public: | 24 public: |
34 SyncedSessionTrackerTest() : tracker_(&sessions_client_) {} | 25 SyncedSessionTrackerTest() : tracker_(&sessions_client_) {} |
35 ~SyncedSessionTrackerTest() override {} | 26 ~SyncedSessionTrackerTest() override {} |
36 | 27 |
37 SyncedSessionTracker* GetTracker() { return &tracker_; } | 28 SyncedSessionTracker* GetTracker() { return &tracker_; } |
38 TabNodePool* GetTabNodePool() { return &tracker_.local_tab_pool_; } | |
39 | 29 |
40 private: | 30 private: |
41 FakeSyncSessionsClient sessions_client_; | 31 FakeSyncSessionsClient sessions_client_; |
42 SyncedSessionTracker tracker_; | 32 SyncedSessionTracker tracker_; |
43 }; | 33 }; |
44 | 34 |
45 TEST_F(SyncedSessionTrackerTest, GetSession) { | 35 TEST_F(SyncedSessionTrackerTest, GetSession) { |
46 SyncedSession* session1 = GetTracker()->GetSession(kTag); | 36 SyncedSession* session1 = GetTracker()->GetSession("tag"); |
47 SyncedSession* session2 = GetTracker()->GetSession(kTag2); | 37 SyncedSession* session2 = GetTracker()->GetSession("tag2"); |
48 ASSERT_EQ(session1, GetTracker()->GetSession(kTag)); | 38 ASSERT_EQ(session1, GetTracker()->GetSession("tag")); |
49 ASSERT_NE(session1, session2); | 39 ASSERT_NE(session1, session2); |
50 // Should clean up memory on its own. | 40 // Should clean up memory on its own. |
51 } | 41 } |
52 | 42 |
53 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { | 43 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { |
54 sessions::SessionTab* tab = GetTracker()->GetTab(kTag, 0); | 44 sessions::SessionTab* tab = GetTracker()->GetTab("tag", 0, 0); |
55 ASSERT_EQ(tab, GetTracker()->GetTab(kTag, 0)); | 45 ASSERT_EQ(tab, GetTracker()->GetTab("tag", 0, 0)); |
56 // Should clean up memory on its own. | 46 // Should clean up memory on its own. |
57 } | 47 } |
58 | 48 |
59 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { | 49 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { |
60 GetTracker()->PutWindowInSession(kTag, 0); | 50 GetTracker()->PutWindowInSession("tag", 0); |
61 SyncedSession* session = GetTracker()->GetSession(kTag); | 51 SyncedSession* session = GetTracker()->GetSession("tag"); |
62 ASSERT_EQ(1U, session->windows.size()); | 52 ASSERT_EQ(1U, session->windows.size()); |
63 // Should clean up memory on its own. | 53 // Should clean up memory on its own. |
64 } | 54 } |
65 | 55 |
66 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { | 56 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { |
67 GetTracker()->PutWindowInSession(kTag, 10); | 57 GetTracker()->PutWindowInSession("tag", 10); |
68 GetTracker()->PutTabInWindow(kTag, 10, 15); // win id 10, tab id 15 | 58 GetTracker()->PutTabInWindow("tag", 10, 15, |
69 SyncedSession* session = GetTracker()->GetSession(kTag); | 59 0); // win id 10, tab id 15, tab ind 0. |
| 60 SyncedSession* session = GetTracker()->GetSession("tag"); |
70 ASSERT_EQ(1U, session->windows.size()); | 61 ASSERT_EQ(1U, session->windows.size()); |
71 ASSERT_EQ(1U, session->windows[10]->tabs.size()); | 62 ASSERT_EQ(1U, session->windows[10]->tabs.size()); |
72 ASSERT_EQ(GetTracker()->GetTab(kTag, 15), | 63 ASSERT_EQ(GetTracker()->GetTab("tag", 15, 1), |
73 session->windows[10]->tabs[0].get()); | 64 session->windows[10]->tabs[0].get()); |
74 // Should clean up memory on its own. | 65 // Should clean up memory on its own. |
75 } | 66 } |
76 | 67 |
77 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { | 68 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { |
78 std::vector<const SyncedSession*> sessions; | 69 std::vector<const SyncedSession*> sessions; |
79 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( | 70 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( |
80 &sessions, SyncedSessionTracker::PRESENTABLE)); | 71 &sessions, SyncedSessionTracker::PRESENTABLE)); |
81 GetTracker()->GetSession(kTag); | 72 GetTracker()->GetSession("tag1"); |
82 GetTracker()->PutWindowInSession(kTag, 0); | 73 GetTracker()->PutWindowInSession("tag1", 0); |
83 GetTracker()->PutTabInWindow(kTag, 0, 15); | 74 GetTracker()->PutTabInWindow("tag1", 0, 15, 0); |
84 sessions::SessionTab* tab = GetTracker()->GetTab(kTag, 15); | 75 sessions::SessionTab* tab = GetTracker()->GetTab("tag1", 15, 1); |
85 ASSERT_TRUE(tab); | 76 ASSERT_TRUE(tab); |
86 tab->navigations.push_back( | 77 tab->navigations.push_back( |
87 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl, | 78 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl, |
88 kTitle)); | 79 "title")); |
89 GetTracker()->GetSession(kTag2); | 80 GetTracker()->GetSession("tag2"); |
90 GetTracker()->GetSession(kTag3); | 81 GetTracker()->GetSession("tag3"); |
91 GetTracker()->PutWindowInSession(kTag3, 0); | 82 GetTracker()->PutWindowInSession("tag3", 0); |
92 GetTracker()->PutTabInWindow(kTag3, 0, 15); | 83 GetTracker()->PutTabInWindow("tag3", 0, 15, 0); |
93 tab = GetTracker()->GetTab(kTag3, 15); | 84 tab = GetTracker()->GetTab("tag3", 15, 1); |
94 ASSERT_TRUE(tab); | 85 ASSERT_TRUE(tab); |
95 tab->navigations.push_back( | 86 tab->navigations.push_back( |
96 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( | 87 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( |
97 kInvalidUrl, kTitle)); | 88 kInvalidUrl, "title")); |
98 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 89 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
99 &sessions, SyncedSessionTracker::PRESENTABLE)); | 90 &sessions, SyncedSessionTracker::PRESENTABLE)); |
100 // Only the session with a valid window and tab gets returned. | 91 // Only the session with a valid window and tab gets returned. |
101 ASSERT_EQ(1U, sessions.size()); | 92 ASSERT_EQ(1U, sessions.size()); |
102 ASSERT_EQ(kTag, sessions[0]->session_tag); | 93 ASSERT_EQ("tag1", sessions[0]->session_tag); |
103 | 94 |
104 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 95 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
105 &sessions, SyncedSessionTracker::RAW)); | 96 &sessions, SyncedSessionTracker::RAW)); |
106 ASSERT_EQ(3U, sessions.size()); | 97 ASSERT_EQ(3U, sessions.size()); |
107 } | 98 } |
108 | 99 |
109 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { | 100 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { |
110 std::vector<const sessions::SessionWindow*> windows; | 101 std::vector<const sessions::SessionWindow*> windows; |
111 ASSERT_FALSE(GetTracker()->LookupSessionWindows(kTag, &windows)); | 102 ASSERT_FALSE(GetTracker()->LookupSessionWindows("tag1", &windows)); |
112 GetTracker()->GetSession(kTag); | 103 GetTracker()->GetSession("tag1"); |
113 GetTracker()->PutWindowInSession(kTag, 0); | 104 GetTracker()->PutWindowInSession("tag1", 0); |
114 GetTracker()->PutWindowInSession(kTag, 2); | 105 GetTracker()->PutWindowInSession("tag1", 2); |
115 GetTracker()->GetSession(kTag2); | 106 GetTracker()->GetSession("tag2"); |
116 GetTracker()->PutWindowInSession(kTag2, 0); | 107 GetTracker()->PutWindowInSession("tag2", 0); |
117 GetTracker()->PutWindowInSession(kTag2, 2); | 108 GetTracker()->PutWindowInSession("tag2", 2); |
118 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag, &windows)); | 109 ASSERT_TRUE(GetTracker()->LookupSessionWindows("tag1", &windows)); |
119 ASSERT_EQ(2U, windows.size()); // Only windows from kTag session. | 110 ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session. |
120 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); | 111 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); |
121 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); | 112 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); |
122 ASSERT_NE(windows[1], windows[0]); | 113 ASSERT_NE(windows[1], windows[0]); |
123 } | 114 } |
124 | 115 |
125 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { | 116 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { |
126 const sessions::SessionTab* tab; | 117 const sessions::SessionTab* tab; |
127 ASSERT_FALSE( | 118 ASSERT_FALSE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); |
128 GetTracker()->LookupSessionTab(kTag, TabNodePool::kInvalidTabID, &tab)); | 119 GetTracker()->GetSession("tag1"); |
129 ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, 5, &tab)); | 120 GetTracker()->PutWindowInSession("tag1", 0); |
130 GetTracker()->GetSession(kTag); | 121 GetTracker()->PutTabInWindow("tag1", 0, 5, 0); |
131 GetTracker()->PutWindowInSession(kTag, 0); | 122 ASSERT_TRUE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); |
132 GetTracker()->PutTabInWindow(kTag, 0, 5); | |
133 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 5, &tab)); | |
134 ASSERT_NE((sessions::SessionTab*)nullptr, tab); | 123 ASSERT_NE((sessions::SessionTab*)nullptr, tab); |
135 } | 124 } |
136 | 125 |
137 TEST_F(SyncedSessionTrackerTest, Complex) { | 126 TEST_F(SyncedSessionTrackerTest, Complex) { |
| 127 const std::string tag1 = "tag"; |
| 128 const std::string tag2 = "tag2"; |
| 129 const std::string tag3 = "tag3"; |
138 std::vector<sessions::SessionTab *> tabs1, tabs2; | 130 std::vector<sessions::SessionTab *> tabs1, tabs2; |
139 sessions::SessionTab* temp_tab; | 131 sessions::SessionTab* temp_tab; |
140 ASSERT_TRUE(GetTracker()->Empty()); | 132 ASSERT_TRUE(GetTracker()->Empty()); |
141 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 133 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
142 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag)); | 134 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); |
143 tabs1.push_back(GetTracker()->GetTab(kTag, 0)); | 135 tabs1.push_back(GetTracker()->GetTab(tag1, 0, 0)); |
144 tabs1.push_back(GetTracker()->GetTab(kTag, 1)); | 136 tabs1.push_back(GetTracker()->GetTab(tag1, 1, 1)); |
145 tabs1.push_back(GetTracker()->GetTab(kTag, 2)); | 137 tabs1.push_back(GetTracker()->GetTab(tag1, 2, 2)); |
146 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); | 138 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); |
147 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 139 ASSERT_EQ(1U, GetTracker()->num_synced_sessions()); |
148 temp_tab = GetTracker()->GetTab(kTag, 0); // Already created. | 140 temp_tab = GetTracker()->GetTab(tag1, 0, 0); // Already created. |
149 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); | 141 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); |
150 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 142 ASSERT_EQ(1U, GetTracker()->num_synced_sessions()); |
151 ASSERT_EQ(tabs1[0], temp_tab); | 143 ASSERT_EQ(tabs1[0], temp_tab); |
152 tabs2.push_back(GetTracker()->GetTab(kTag2, 0)); | 144 tabs2.push_back(GetTracker()->GetTab(tag2, 0, 0)); |
153 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); | 145 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
154 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 146 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
155 ASSERT_FALSE(GetTracker()->DeleteForeignSession(kTag3)); | 147 ASSERT_FALSE(GetTracker()->DeleteSession(tag3)); |
156 | 148 |
157 SyncedSession* session = GetTracker()->GetSession(kTag); | 149 SyncedSession* session = GetTracker()->GetSession(tag1); |
158 SyncedSession* session2 = GetTracker()->GetSession(kTag2); | 150 SyncedSession* session2 = GetTracker()->GetSession(tag2); |
159 SyncedSession* session3 = GetTracker()->GetSession(kTag3); | 151 SyncedSession* session3 = GetTracker()->GetSession(tag3); |
160 session3->device_type = SyncedSession::TYPE_OTHER; | 152 session3->device_type = SyncedSession::TYPE_OTHER; |
161 ASSERT_EQ(3U, GetTracker()->num_synced_sessions()); | 153 ASSERT_EQ(3U, GetTracker()->num_synced_sessions()); |
162 | 154 |
163 ASSERT_TRUE(session); | 155 ASSERT_TRUE(session); |
164 ASSERT_TRUE(session2); | 156 ASSERT_TRUE(session2); |
165 ASSERT_TRUE(session3); | 157 ASSERT_TRUE(session3); |
166 ASSERT_NE(session, session2); | 158 ASSERT_NE(session, session2); |
167 ASSERT_NE(session2, session3); | 159 ASSERT_NE(session2, session3); |
168 ASSERT_TRUE(GetTracker()->DeleteForeignSession(kTag3)); | 160 ASSERT_TRUE(GetTracker()->DeleteSession(tag3)); |
169 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); | 161 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
170 | 162 |
171 GetTracker()->PutWindowInSession(kTag, 0); // Create a window. | 163 GetTracker()->PutWindowInSession(tag1, 0); // Create a window. |
172 GetTracker()->PutTabInWindow(kTag, 0, 2); // No longer unmapped. | 164 GetTracker()->PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped. |
173 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); // Has not changed. | 165 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); // Has not changed. |
174 | 166 |
175 const sessions::SessionTab* tab_ptr; | 167 const sessions::SessionTab* tab_ptr; |
176 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 0, &tab_ptr)); | 168 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 0, &tab_ptr)); |
177 ASSERT_EQ(tab_ptr, tabs1[0]); | 169 ASSERT_EQ(tab_ptr, tabs1[0]); |
178 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 2, &tab_ptr)); | 170 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 2, &tab_ptr)); |
179 ASSERT_EQ(tab_ptr, tabs1[2]); | 171 ASSERT_EQ(tab_ptr, tabs1[2]); |
180 ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, 3, &tab_ptr)); | 172 ASSERT_FALSE(GetTracker()->LookupSessionTab(tag1, 3, &tab_ptr)); |
181 ASSERT_FALSE(tab_ptr); | 173 ASSERT_FALSE(tab_ptr); |
182 | 174 |
183 std::vector<const sessions::SessionWindow*> windows; | 175 std::vector<const sessions::SessionWindow*> windows; |
184 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag, &windows)); | 176 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag1, &windows)); |
185 ASSERT_EQ(1U, windows.size()); | 177 ASSERT_EQ(1U, windows.size()); |
186 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag2, &windows)); | 178 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag2, &windows)); |
187 ASSERT_EQ(0U, windows.size()); | 179 ASSERT_EQ(0U, windows.size()); |
188 | 180 |
189 // The sessions don't have valid tabs, lookup should not succeed. | 181 // The sessions don't have valid tabs, lookup should not succeed. |
190 std::vector<const SyncedSession*> sessions; | 182 std::vector<const SyncedSession*> sessions; |
191 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( | 183 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( |
192 &sessions, SyncedSessionTracker::PRESENTABLE)); | 184 &sessions, SyncedSessionTracker::PRESENTABLE)); |
193 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 185 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
194 &sessions, SyncedSessionTracker::RAW)); | 186 &sessions, SyncedSessionTracker::RAW)); |
195 ASSERT_EQ(2U, sessions.size()); | 187 ASSERT_EQ(2U, sessions.size()); |
196 | 188 |
197 GetTracker()->Clear(); | 189 GetTracker()->Clear(); |
198 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag)); | 190 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); |
199 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag2)); | 191 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag2)); |
200 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 192 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
201 } | 193 } |
202 | 194 |
203 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { | 195 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { |
204 ASSERT_TRUE(GetTracker()->Empty()); | 196 ASSERT_TRUE(GetTracker()->Empty()); |
205 const int kMaxSessions = 10; | 197 const int kMaxSessions = 10; |
206 const int kMaxTabs = 1000; | 198 const int kMaxTabs = 1000; |
207 const int kMaxAttempts = 10000; | 199 const int kMaxAttempts = 10000; |
208 for (int j = 0; j < kMaxSessions; ++j) { | 200 for (int j = 0; j < kMaxSessions; ++j) { |
209 std::string tag = base::StringPrintf("tag%d", j); | 201 std::string tag = base::StringPrintf("tag%d", j); |
210 for (int i = 0; i < kMaxAttempts; ++i) { | 202 for (int i = 0; i < kMaxAttempts; ++i) { |
211 // More attempts than tabs means we'll sometimes get the same tabs, | 203 // More attempts than tabs means we'll sometimes get the same tabs, |
212 // sometimes have to allocate new tabs. | 204 // sometimes have to allocate new tabs. |
213 int rand_tab_num = base::RandInt(0, kMaxTabs); | 205 int rand_tab_num = base::RandInt(0, kMaxTabs); |
214 sessions::SessionTab* tab = GetTracker()->GetTab(tag, rand_tab_num + 1); | 206 sessions::SessionTab* tab = |
| 207 GetTracker()->GetTab(tag, rand_tab_num, rand_tab_num + 1); |
215 ASSERT_TRUE(tab); | 208 ASSERT_TRUE(tab); |
216 } | 209 } |
217 } | 210 } |
218 } | 211 } |
219 | 212 |
220 TEST_F(SyncedSessionTrackerTest, LookupForeignTabNodeIds) { | 213 TEST_F(SyncedSessionTrackerTest, LookupTabNodeIds) { |
221 std::set<int> result; | 214 std::set<int> result; |
| 215 std::string tag1 = "session1"; |
| 216 std::string tag2 = "session2"; |
| 217 std::string tag3 = "session3"; |
222 | 218 |
223 GetTracker()->OnTabNodeSeen(kTag, 1); | 219 GetTracker()->GetTab(tag1, 1, 1); |
224 GetTracker()->OnTabNodeSeen(kTag, 2); | 220 GetTracker()->GetTab(tag1, 2, 2); |
225 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 221 GetTracker()->LookupTabNodeIds(tag1, &result); |
226 EXPECT_EQ(2U, result.size()); | 222 EXPECT_EQ(2U, result.size()); |
227 EXPECT_FALSE(result.end() == result.find(1)); | 223 EXPECT_FALSE(result.end() == result.find(1)); |
228 EXPECT_FALSE(result.end() == result.find(2)); | 224 EXPECT_FALSE(result.end() == result.find(2)); |
229 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); | 225 GetTracker()->LookupTabNodeIds(tag2, &result); |
230 EXPECT_TRUE(result.empty()); | 226 EXPECT_TRUE(result.empty()); |
231 | 227 |
232 GetTracker()->PutWindowInSession(kTag, 0); | 228 GetTracker()->PutWindowInSession(tag1, 0); |
233 GetTracker()->PutTabInWindow(kTag, 0, 3); | 229 GetTracker()->PutTabInWindow(tag1, 0, 3, 0); |
234 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 230 GetTracker()->LookupTabNodeIds(tag1, &result); |
235 EXPECT_EQ(2U, result.size()); | 231 EXPECT_EQ(2U, result.size()); |
236 | 232 |
237 GetTracker()->OnTabNodeSeen(kTag, 3); | 233 GetTracker()->GetTab(tag1, 3, 3); |
238 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 234 GetTracker()->LookupTabNodeIds(tag1, &result); |
239 EXPECT_EQ(3U, result.size()); | 235 EXPECT_EQ(3U, result.size()); |
240 EXPECT_FALSE(result.end() == result.find(3)); | 236 EXPECT_FALSE(result.end() == result.find(3)); |
241 | 237 |
242 GetTracker()->OnTabNodeSeen(kTag2, 21); | 238 GetTracker()->GetTab(tag2, 1, 21); |
243 GetTracker()->OnTabNodeSeen(kTag2, 22); | 239 GetTracker()->GetTab(tag2, 2, 22); |
244 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); | 240 GetTracker()->LookupTabNodeIds(tag2, &result); |
245 EXPECT_EQ(2U, result.size()); | 241 EXPECT_EQ(2U, result.size()); |
246 EXPECT_FALSE(result.end() == result.find(21)); | 242 EXPECT_FALSE(result.end() == result.find(21)); |
247 EXPECT_FALSE(result.end() == result.find(22)); | 243 EXPECT_FALSE(result.end() == result.find(22)); |
248 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 244 GetTracker()->LookupTabNodeIds(tag1, &result); |
249 EXPECT_EQ(3U, result.size()); | 245 EXPECT_EQ(3U, result.size()); |
250 EXPECT_FALSE(result.end() == result.find(1)); | 246 EXPECT_FALSE(result.end() == result.find(1)); |
251 EXPECT_FALSE(result.end() == result.find(2)); | 247 EXPECT_FALSE(result.end() == result.find(2)); |
252 | 248 |
253 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); | 249 GetTracker()->LookupTabNodeIds(tag3, &result); |
254 EXPECT_TRUE(result.empty()); | 250 EXPECT_TRUE(result.empty()); |
255 GetTracker()->PutWindowInSession(kTag3, 1); | 251 GetTracker()->PutWindowInSession(tag3, 1); |
256 GetTracker()->PutTabInWindow(kTag3, 1, 5); | 252 GetTracker()->PutTabInWindow(tag3, 1, 5, 0); |
257 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); | 253 GetTracker()->LookupTabNodeIds(tag3, &result); |
258 EXPECT_TRUE(result.empty()); | 254 EXPECT_TRUE(result.empty()); |
259 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag3)); | 255 EXPECT_FALSE(GetTracker()->DeleteSession(tag3)); |
260 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); | 256 GetTracker()->LookupTabNodeIds(tag3, &result); |
261 EXPECT_TRUE(result.empty()); | 257 EXPECT_TRUE(result.empty()); |
262 | 258 |
263 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag)); | 259 EXPECT_FALSE(GetTracker()->DeleteSession(tag1)); |
264 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 260 GetTracker()->LookupTabNodeIds(tag1, &result); |
265 EXPECT_TRUE(result.empty()); | 261 EXPECT_TRUE(result.empty()); |
266 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); | 262 GetTracker()->LookupTabNodeIds(tag2, &result); |
267 EXPECT_EQ(2U, result.size()); | 263 EXPECT_EQ(2U, result.size()); |
268 EXPECT_FALSE(result.end() == result.find(21)); | 264 EXPECT_FALSE(result.end() == result.find(21)); |
269 EXPECT_FALSE(result.end() == result.find(22)); | 265 EXPECT_FALSE(result.end() == result.find(22)); |
270 | 266 |
271 GetTracker()->OnTabNodeSeen(kTag2, 21); | 267 GetTracker()->GetTab(tag2, 1, 21); |
272 GetTracker()->OnTabNodeSeen(kTag2, 23); | 268 GetTracker()->GetTab(tag2, 2, 23); |
273 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); | 269 GetTracker()->LookupTabNodeIds(tag2, &result); |
274 EXPECT_EQ(3U, result.size()); | 270 EXPECT_EQ(3U, result.size()); |
275 EXPECT_FALSE(result.end() == result.find(21)); | 271 EXPECT_FALSE(result.end() == result.find(21)); |
276 EXPECT_FALSE(result.end() == result.find(22)); | 272 EXPECT_FALSE(result.end() == result.find(22)); |
277 EXPECT_FALSE(result.end() == result.find(23)); | 273 EXPECT_FALSE(result.end() == result.find(23)); |
278 | 274 |
279 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag2)); | 275 EXPECT_FALSE(GetTracker()->DeleteSession(tag2)); |
280 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); | 276 GetTracker()->LookupTabNodeIds(tag2, &result); |
281 EXPECT_TRUE(result.empty()); | 277 EXPECT_TRUE(result.empty()); |
282 } | 278 } |
283 | 279 |
284 TEST_F(SyncedSessionTrackerTest, SessionTracking) { | 280 TEST_F(SyncedSessionTrackerTest, SessionTracking) { |
285 ASSERT_TRUE(GetTracker()->Empty()); | 281 ASSERT_TRUE(GetTracker()->Empty()); |
| 282 std::string tag1 = "tag1"; |
| 283 std::string tag2 = "tag2"; |
286 | 284 |
287 // Create some session information that is stale. | 285 // Create some session information that is stale. |
288 SyncedSession* session1 = GetTracker()->GetSession(kTag); | 286 SyncedSession* session1 = GetTracker()->GetSession(tag1); |
289 GetTracker()->PutWindowInSession(kTag, 0); | 287 GetTracker()->PutWindowInSession(tag1, 0); |
290 GetTracker()->PutTabInWindow(kTag, 0, 0); | 288 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); |
291 GetTracker()->PutTabInWindow(kTag, 0, 1); | 289 GetTracker()->PutTabInWindow(tag1, 0, 1, 1); |
292 GetTracker()->GetTab(kTag, 2)->window_id.set_id(0); // Will be unmapped. | 290 GetTracker()->GetTab(tag1, 2, 3U)->window_id.set_id(0); // Will be unmapped. |
293 GetTracker()->GetTab(kTag, 3)->window_id.set_id(0); // Will be unmapped. | 291 GetTracker()->GetTab(tag1, 3, 4U)->window_id.set_id(0); // Will be unmapped. |
294 GetTracker()->PutWindowInSession(kTag, 1); | 292 GetTracker()->PutWindowInSession(tag1, 1); |
295 GetTracker()->PutTabInWindow(kTag, 1, 4); | 293 GetTracker()->PutTabInWindow(tag1, 1, 4, 0); |
296 GetTracker()->PutTabInWindow(kTag, 1, 5); | 294 GetTracker()->PutTabInWindow(tag1, 1, 5, 1); |
297 ASSERT_EQ(2U, session1->windows.size()); | 295 ASSERT_EQ(2U, session1->windows.size()); |
298 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); | 296 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); |
299 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); | 297 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); |
300 ASSERT_EQ(6U, GetTracker()->num_synced_tabs(kTag)); | 298 ASSERT_EQ(6U, GetTracker()->num_synced_tabs(tag1)); |
301 | 299 |
302 // Create a session that should not be affected. | 300 // Create a session that should not be affected. |
303 SyncedSession* session2 = GetTracker()->GetSession(kTag2); | 301 SyncedSession* session2 = GetTracker()->GetSession(tag2); |
304 GetTracker()->PutWindowInSession(kTag2, 2); | 302 GetTracker()->PutWindowInSession(tag2, 2); |
305 GetTracker()->PutTabInWindow(kTag2, 2, 1); | 303 GetTracker()->PutTabInWindow(tag2, 2, 1, 0); |
306 ASSERT_EQ(1U, session2->windows.size()); | 304 ASSERT_EQ(1U, session2->windows.size()); |
307 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 305 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
308 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); | 306 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
309 | 307 |
310 // Reset tracking and get the current windows/tabs. | 308 // Reset tracking and get the current windows/tabs. |
311 // We simulate moving a tab from one window to another, then closing the | 309 // We simulate moving a tab from one window to another, then closing the |
312 // first window (including its one remaining tab), and opening a new tab | 310 // first window (including its one remaining tab), and opening a new tab |
313 // on the remaining window. | 311 // on the remaining window. |
314 | 312 |
315 // New tab, arrived before meta node so unmapped. | 313 // New tab, arrived before meta node so unmapped. |
316 GetTracker()->GetTab(kTag, 6); | 314 GetTracker()->GetTab(tag1, 6, 7U); |
317 GetTracker()->ResetSessionTracking(kTag); | 315 GetTracker()->ResetSessionTracking(tag1); |
318 GetTracker()->PutWindowInSession(kTag, 0); | 316 GetTracker()->PutWindowInSession(tag1, 0); |
319 GetTracker()->PutTabInWindow(kTag, 0, 0); | 317 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); |
320 // Tab 1 is closed. | 318 // Tab 1 is closed. |
321 GetTracker()->PutTabInWindow(kTag, 0, 2); // No longer unmapped. | 319 GetTracker()->PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped. |
322 // Tab 3 was unmapped and does not get used. | 320 // Tab 3 was unmapped and does not get used. |
323 GetTracker()->PutTabInWindow(kTag, 0, 4); // Moved from window 1. | 321 GetTracker()->PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1. |
324 // Window 1 was closed, along with tab 5. | 322 // Window 1 was closed, along with tab 5. |
325 GetTracker()->PutTabInWindow(kTag, 0, 6); // No longer unmapped. | 323 GetTracker()->PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped. |
326 // Session 2 should not be affected. | 324 // Session 2 should not be affected. |
327 GetTracker()->CleanupForeignSession(kTag); | 325 GetTracker()->CleanupSession(tag1); |
328 | 326 |
329 // Verify that only those parts of the session not owned have been removed. | 327 // Verify that only those parts of the session not owned have been removed. |
330 ASSERT_EQ(1U, session1->windows.size()); | 328 ASSERT_EQ(1U, session1->windows.size()); |
331 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); | 329 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); |
332 ASSERT_EQ(1U, session2->windows.size()); | 330 ASSERT_EQ(1U, session2->windows.size()); |
333 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 331 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
334 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); | 332 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
335 ASSERT_EQ(4U, GetTracker()->num_synced_tabs(kTag)); | 333 ASSERT_EQ(4U, GetTracker()->num_synced_tabs(tag1)); |
336 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); | 334 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
337 | 335 |
338 // All memory should be properly deallocated by destructor for the | 336 // All memory should be properly deallocated by destructor for the |
339 // SyncedSessionTracker. | 337 // SyncedSessionTracker. |
340 } | 338 } |
341 | 339 |
342 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) { | 340 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) { |
343 int tab_node_id_1 = 1; | 341 std::string session_tag = "session_tag"; |
344 int tab_node_id_2 = 2; | 342 int tab_id_1 = 1; |
| 343 int tab_id_2 = 2; |
| 344 int tab_node_id_3 = 3; |
| 345 int tab_node_id_4 = 4; |
345 std::set<int> result; | 346 std::set<int> result; |
346 | 347 |
347 GetTracker()->OnTabNodeSeen(kTag, tab_node_id_1); | 348 GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_3); |
348 GetTracker()->OnTabNodeSeen(kTag, tab_node_id_2); | 349 GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_4); |
| 350 GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_3); |
| 351 GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_4); |
349 | 352 |
350 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 353 GetTracker()->LookupTabNodeIds(session_tag, &result); |
351 EXPECT_EQ(2U, result.size()); | 354 EXPECT_EQ(2U, result.size()); |
352 EXPECT_TRUE(result.find(tab_node_id_1) != result.end()); | 355 EXPECT_TRUE(result.find(tab_node_id_3) != result.end()); |
353 EXPECT_TRUE(result.find(tab_node_id_2) != result.end()); | 356 EXPECT_TRUE(result.find(tab_node_id_4) != result.end()); |
354 | 357 |
355 GetTracker()->DeleteForeignTab(kTag, tab_node_id_1); | 358 GetTracker()->DeleteForeignTab(session_tag, tab_node_id_3); |
356 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 359 GetTracker()->LookupTabNodeIds(session_tag, &result); |
357 EXPECT_EQ(1U, result.size()); | 360 EXPECT_EQ(1U, result.size()); |
358 EXPECT_TRUE(result.find(tab_node_id_2) != result.end()); | 361 EXPECT_TRUE(result.find(tab_node_id_4) != result.end()); |
359 | 362 |
360 GetTracker()->DeleteForeignTab(kTag, tab_node_id_2); | 363 GetTracker()->DeleteForeignTab(session_tag, tab_node_id_4); |
361 GetTracker()->LookupForeignTabNodeIds(kTag, &result); | 364 GetTracker()->LookupTabNodeIds(session_tag, &result); |
362 EXPECT_TRUE(result.empty()); | 365 EXPECT_TRUE(result.empty()); |
363 } | 366 } |
364 | 367 |
365 TEST_F(SyncedSessionTrackerTest, CleanupLocalTabs) { | |
366 std::set<int> free_node_ids; | |
367 int tab_node_id = TabNodePool::kInvalidTabNodeID; | |
368 const int kTabNode1 = 1; | |
369 const int kTabNode2 = 2; | |
370 const int kTabNode3 = 3; | |
371 | |
372 GetTracker()->SetLocalSessionTag(kTag); | |
373 | |
374 // Start with two restored tab nodes. | |
375 GetTracker()->ReassociateLocalTab(kTabNode1, kTab1); | |
376 GetTracker()->ReassociateLocalTab(kTabNode2, kTab2); | |
377 EXPECT_TRUE(GetTabNodePool()->Empty()); | |
378 EXPECT_FALSE(GetTabNodePool()->Full()); | |
379 EXPECT_EQ(2U, GetTabNodePool()->Capacity()); | |
380 | |
381 // Associate with no tabs. The tab pool should now be full. | |
382 GetTracker()->ResetSessionTracking(kTag); | |
383 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
384 EXPECT_TRUE(free_node_ids.empty()); | |
385 EXPECT_TRUE(GetTabNodePool()->Full()); | |
386 | |
387 // Associate with only 1 tab open. A tab node should be reused. | |
388 GetTracker()->ResetSessionTracking(kTag); | |
389 GetTracker()->PutWindowInSession(kTag, kWindow1); | |
390 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1); | |
391 EXPECT_TRUE(GetTracker()->GetTabNodeFromLocalTabId(kTab1, &tab_node_id)); | |
392 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
393 EXPECT_TRUE(free_node_ids.empty()); | |
394 | |
395 // TabNodePool should have one free tab node and one used. | |
396 EXPECT_EQ(2U, GetTabNodePool()->Capacity()); | |
397 EXPECT_FALSE(GetTabNodePool()->Empty()); | |
398 EXPECT_FALSE(GetTabNodePool()->Full()); | |
399 | |
400 // Simulate a tab opening, which should use the last free tab node. | |
401 EXPECT_TRUE(GetTracker()->GetTabNodeFromLocalTabId(kTab2, &tab_node_id)); | |
402 EXPECT_TRUE(GetTabNodePool()->Empty()); | |
403 | |
404 // Simulate another tab opening, which should create a new associated tab | |
405 // node. | |
406 EXPECT_FALSE(GetTracker()->GetTabNodeFromLocalTabId(kTab3, &tab_node_id)); | |
407 EXPECT_EQ(kTabNode3, tab_node_id); | |
408 EXPECT_EQ(3U, GetTabNodePool()->Capacity()); | |
409 EXPECT_TRUE(GetTabNodePool()->Empty()); | |
410 | |
411 // Fetching the same tab should return the same tab node id. | |
412 EXPECT_TRUE(GetTracker()->GetTabNodeFromLocalTabId(kTab3, &tab_node_id)); | |
413 EXPECT_EQ(kTabNode3, tab_node_id); | |
414 EXPECT_TRUE(GetTabNodePool()->Empty()); | |
415 | |
416 // Associate with no tabs. All tabs should be freed again, and the pool | |
417 // should now be full. | |
418 GetTracker()->ResetSessionTracking(kTag); | |
419 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
420 EXPECT_TRUE(free_node_ids.empty()); | |
421 EXPECT_TRUE(GetTabNodePool()->Full()); | |
422 EXPECT_FALSE(GetTabNodePool()->Empty()); | |
423 } | |
424 | |
425 TEST_F(SyncedSessionTrackerTest, ReassociateTabMapped) { | |
426 std::set<int> free_node_ids; | |
427 | |
428 // First create the tab normally. | |
429 GetTracker()->SetLocalSessionTag(kTag); | |
430 EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
431 GetTracker()->ReassociateLocalTab(kTabNode, kTab1); | |
432 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
433 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1)); | |
434 | |
435 // Map it to a window with the same tab id as it was created with. | |
436 GetTracker()->ResetSessionTracking(kTag); | |
437 GetTracker()->PutWindowInSession(kTag, kWindow1); | |
438 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1); | |
439 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
440 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); | |
441 SyncedSession* session = GetTracker()->GetSession(kTag); | |
442 ASSERT_EQ(1U, session->windows.size()); | |
443 ASSERT_EQ(1U, session->windows[kWindow1]->tabs.size()); | |
444 ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1), | |
445 session->windows[kWindow1]->tabs[0].get()); | |
446 | |
447 // Then reassociate with a new tab id. | |
448 GetTracker()->ReassociateLocalTab(kTabNode, kTab2); | |
449 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
450 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); | |
451 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); | |
452 | |
453 // Reset tracking, and put the new tab id into the window. | |
454 GetTracker()->ResetSessionTracking(kTag); | |
455 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2)); | |
456 GetTracker()->PutWindowInSession(kTag, kWindow1); | |
457 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2); | |
458 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
459 EXPECT_TRUE(free_node_ids.empty()); | |
460 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); | |
461 | |
462 // Now that it's been mapped, it should be accessible both via the | |
463 // GetSession as well as the GetTab. | |
464 ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2), | |
465 session->windows[kWindow1]->tabs[0].get()); | |
466 ASSERT_EQ(session->tab_node_ids.size(), | |
467 session->tab_node_ids.count(kTabNode)); | |
468 ASSERT_EQ(1U, GetTabNodePool()->Capacity()); | |
469 } | |
470 | |
471 TEST_F(SyncedSessionTrackerTest, ReassociateTabUnmapped) { | |
472 std::set<int> free_node_ids; | |
473 | |
474 // First create the old tab in an unmapped state. | |
475 GetTracker()->SetLocalSessionTag(kTag); | |
476 EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
477 GetTracker()->ReassociateLocalTab(kTabNode, kTab1); | |
478 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
479 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1)); | |
480 | |
481 // Map it to a window, but reassociated with a new tab id. | |
482 GetTracker()->ResetSessionTracking(kTag); | |
483 GetTracker()->ReassociateLocalTab(kTabNode, kTab2); | |
484 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); | |
485 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2)); | |
486 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); | |
487 GetTracker()->PutWindowInSession(kTag, kWindow1); | |
488 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2); | |
489 GetTracker()->CleanupLocalTabs(&free_node_ids); | |
490 EXPECT_TRUE(free_node_ids.empty()); | |
491 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); | |
492 | |
493 // Now that it's been mapped, it should be accessible both via the | |
494 // GetSession as well as GetTab. | |
495 SyncedSession* session = GetTracker()->GetSession(kTag); | |
496 ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2), | |
497 session->windows[kWindow1]->tabs[0].get()); | |
498 ASSERT_EQ(session->tab_node_ids.size(), | |
499 session->tab_node_ids.count(kTabNode)); | |
500 ASSERT_EQ(1U, GetTabNodePool()->Capacity()); | |
501 } | |
502 | |
503 } // namespace sync_sessions | 368 } // namespace sync_sessions |
OLD | NEW |