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; |
20 | 29 |
21 } // namespace | 30 } // namespace |
22 | 31 |
23 class SyncedSessionTrackerTest : public testing::Test { | 32 class SyncedSessionTrackerTest : public testing::Test { |
24 public: | 33 public: |
25 SyncedSessionTrackerTest() : tracker_(&sessions_client_) {} | 34 SyncedSessionTrackerTest() : tracker_(&sessions_client_) {} |
26 ~SyncedSessionTrackerTest() override {} | 35 ~SyncedSessionTrackerTest() override {} |
27 | 36 |
28 SyncedSessionTracker* GetTracker() { return &tracker_; } | 37 SyncedSessionTracker* GetTracker() { return &tracker_; } |
| 38 TabNodePool* GetTabNodePool() { return &tracker_.local_tab_pool_; } |
29 | 39 |
30 private: | 40 private: |
31 FakeSyncSessionsClient sessions_client_; | 41 FakeSyncSessionsClient sessions_client_; |
32 SyncedSessionTracker tracker_; | 42 SyncedSessionTracker tracker_; |
33 }; | 43 }; |
34 | 44 |
35 TEST_F(SyncedSessionTrackerTest, GetSession) { | 45 TEST_F(SyncedSessionTrackerTest, GetSession) { |
36 SyncedSession* session1 = GetTracker()->GetSession("tag"); | 46 SyncedSession* session1 = GetTracker()->GetSession(kTag); |
37 SyncedSession* session2 = GetTracker()->GetSession("tag2"); | 47 SyncedSession* session2 = GetTracker()->GetSession(kTag2); |
38 ASSERT_EQ(session1, GetTracker()->GetSession("tag")); | 48 ASSERT_EQ(session1, GetTracker()->GetSession(kTag)); |
39 ASSERT_NE(session1, session2); | 49 ASSERT_NE(session1, session2); |
40 // Should clean up memory on its own. | 50 // Should clean up memory on its own. |
41 } | 51 } |
42 | 52 |
43 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { | 53 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { |
44 sessions::SessionTab* tab = GetTracker()->GetTab("tag", 0, 0); | 54 sessions::SessionTab* tab = GetTracker()->GetTab(kTag, 0); |
45 ASSERT_EQ(tab, GetTracker()->GetTab("tag", 0, 0)); | 55 ASSERT_EQ(tab, GetTracker()->GetTab(kTag, 0)); |
46 // Should clean up memory on its own. | 56 // Should clean up memory on its own. |
47 } | 57 } |
48 | 58 |
49 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { | 59 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { |
50 GetTracker()->PutWindowInSession("tag", 0); | 60 GetTracker()->PutWindowInSession(kTag, 0); |
51 SyncedSession* session = GetTracker()->GetSession("tag"); | 61 SyncedSession* session = GetTracker()->GetSession(kTag); |
52 ASSERT_EQ(1U, session->windows.size()); | 62 ASSERT_EQ(1U, session->windows.size()); |
53 // Should clean up memory on its own. | 63 // Should clean up memory on its own. |
54 } | 64 } |
55 | 65 |
56 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { | 66 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { |
57 GetTracker()->PutWindowInSession("tag", 10); | 67 GetTracker()->PutWindowInSession(kTag, 10); |
58 GetTracker()->PutTabInWindow("tag", 10, 15, | 68 GetTracker()->PutTabInWindow(kTag, 10, 15); // win id 10, tab id 15 |
59 0); // win id 10, tab id 15, tab ind 0. | 69 SyncedSession* session = GetTracker()->GetSession(kTag); |
60 SyncedSession* session = GetTracker()->GetSession("tag"); | |
61 ASSERT_EQ(1U, session->windows.size()); | 70 ASSERT_EQ(1U, session->windows.size()); |
62 ASSERT_EQ(1U, session->windows[10]->tabs.size()); | 71 ASSERT_EQ(1U, session->windows[10]->tabs.size()); |
63 ASSERT_EQ(GetTracker()->GetTab("tag", 15, 1), | 72 ASSERT_EQ(GetTracker()->GetTab(kTag, 15), |
64 session->windows[10]->tabs[0].get()); | 73 session->windows[10]->tabs[0].get()); |
65 // Should clean up memory on its own. | 74 // Should clean up memory on its own. |
66 } | 75 } |
67 | 76 |
68 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { | 77 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { |
69 std::vector<const SyncedSession*> sessions; | 78 std::vector<const SyncedSession*> sessions; |
70 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( | 79 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( |
71 &sessions, SyncedSessionTracker::PRESENTABLE)); | 80 &sessions, SyncedSessionTracker::PRESENTABLE)); |
72 GetTracker()->GetSession("tag1"); | 81 GetTracker()->GetSession(kTag); |
73 GetTracker()->PutWindowInSession("tag1", 0); | 82 GetTracker()->PutWindowInSession(kTag, 0); |
74 GetTracker()->PutTabInWindow("tag1", 0, 15, 0); | 83 GetTracker()->PutTabInWindow(kTag, 0, 15); |
75 sessions::SessionTab* tab = GetTracker()->GetTab("tag1", 15, 1); | 84 sessions::SessionTab* tab = GetTracker()->GetTab(kTag, 15); |
76 ASSERT_TRUE(tab); | 85 ASSERT_TRUE(tab); |
77 tab->navigations.push_back( | 86 tab->navigations.push_back( |
78 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl, | 87 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl, |
79 "title")); | 88 kTitle)); |
80 GetTracker()->GetSession("tag2"); | 89 GetTracker()->GetSession(kTag2); |
81 GetTracker()->GetSession("tag3"); | 90 GetTracker()->GetSession(kTag3); |
82 GetTracker()->PutWindowInSession("tag3", 0); | 91 GetTracker()->PutWindowInSession(kTag3, 0); |
83 GetTracker()->PutTabInWindow("tag3", 0, 15, 0); | 92 GetTracker()->PutTabInWindow(kTag3, 0, 15); |
84 tab = GetTracker()->GetTab("tag3", 15, 1); | 93 tab = GetTracker()->GetTab(kTag3, 15); |
85 ASSERT_TRUE(tab); | 94 ASSERT_TRUE(tab); |
86 tab->navigations.push_back( | 95 tab->navigations.push_back( |
87 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( | 96 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( |
88 kInvalidUrl, "title")); | 97 kInvalidUrl, kTitle)); |
89 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 98 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
90 &sessions, SyncedSessionTracker::PRESENTABLE)); | 99 &sessions, SyncedSessionTracker::PRESENTABLE)); |
91 // Only the session with a valid window and tab gets returned. | 100 // Only the session with a valid window and tab gets returned. |
92 ASSERT_EQ(1U, sessions.size()); | 101 ASSERT_EQ(1U, sessions.size()); |
93 ASSERT_EQ("tag1", sessions[0]->session_tag); | 102 ASSERT_EQ(kTag, sessions[0]->session_tag); |
94 | 103 |
95 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 104 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
96 &sessions, SyncedSessionTracker::RAW)); | 105 &sessions, SyncedSessionTracker::RAW)); |
97 ASSERT_EQ(3U, sessions.size()); | 106 ASSERT_EQ(3U, sessions.size()); |
98 } | 107 } |
99 | 108 |
100 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { | 109 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { |
101 std::vector<const sessions::SessionWindow*> windows; | 110 std::vector<const sessions::SessionWindow*> windows; |
102 ASSERT_FALSE(GetTracker()->LookupSessionWindows("tag1", &windows)); | 111 ASSERT_FALSE(GetTracker()->LookupSessionWindows(kTag, &windows)); |
103 GetTracker()->GetSession("tag1"); | 112 GetTracker()->GetSession(kTag); |
104 GetTracker()->PutWindowInSession("tag1", 0); | 113 GetTracker()->PutWindowInSession(kTag, 0); |
105 GetTracker()->PutWindowInSession("tag1", 2); | 114 GetTracker()->PutWindowInSession(kTag, 2); |
106 GetTracker()->GetSession("tag2"); | 115 GetTracker()->GetSession(kTag2); |
107 GetTracker()->PutWindowInSession("tag2", 0); | 116 GetTracker()->PutWindowInSession(kTag2, 0); |
108 GetTracker()->PutWindowInSession("tag2", 2); | 117 GetTracker()->PutWindowInSession(kTag2, 2); |
109 ASSERT_TRUE(GetTracker()->LookupSessionWindows("tag1", &windows)); | 118 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag, &windows)); |
110 ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session. | 119 ASSERT_EQ(2U, windows.size()); // Only windows from kTag session. |
111 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); | 120 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); |
112 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); | 121 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); |
113 ASSERT_NE(windows[1], windows[0]); | 122 ASSERT_NE(windows[1], windows[0]); |
114 } | 123 } |
115 | 124 |
116 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { | 125 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { |
117 const sessions::SessionTab* tab; | 126 const sessions::SessionTab* tab; |
118 ASSERT_FALSE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); | 127 ASSERT_FALSE( |
119 GetTracker()->GetSession("tag1"); | 128 GetTracker()->LookupSessionTab(kTag, TabNodePool::kInvalidTabID, &tab)); |
120 GetTracker()->PutWindowInSession("tag1", 0); | 129 ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, 5, &tab)); |
121 GetTracker()->PutTabInWindow("tag1", 0, 5, 0); | 130 GetTracker()->GetSession(kTag); |
122 ASSERT_TRUE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); | 131 GetTracker()->PutWindowInSession(kTag, 0); |
| 132 GetTracker()->PutTabInWindow(kTag, 0, 5); |
| 133 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 5, &tab)); |
123 ASSERT_NE((sessions::SessionTab*)nullptr, tab); | 134 ASSERT_NE((sessions::SessionTab*)nullptr, tab); |
124 } | 135 } |
125 | 136 |
126 TEST_F(SyncedSessionTrackerTest, Complex) { | 137 TEST_F(SyncedSessionTrackerTest, Complex) { |
127 const std::string tag1 = "tag"; | |
128 const std::string tag2 = "tag2"; | |
129 const std::string tag3 = "tag3"; | |
130 std::vector<sessions::SessionTab *> tabs1, tabs2; | 138 std::vector<sessions::SessionTab *> tabs1, tabs2; |
131 sessions::SessionTab* temp_tab; | 139 sessions::SessionTab* temp_tab; |
132 ASSERT_TRUE(GetTracker()->Empty()); | 140 ASSERT_TRUE(GetTracker()->Empty()); |
133 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 141 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
134 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); | 142 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag)); |
135 tabs1.push_back(GetTracker()->GetTab(tag1, 0, 0)); | 143 tabs1.push_back(GetTracker()->GetTab(kTag, 0)); |
136 tabs1.push_back(GetTracker()->GetTab(tag1, 1, 1)); | 144 tabs1.push_back(GetTracker()->GetTab(kTag, 1)); |
137 tabs1.push_back(GetTracker()->GetTab(tag1, 2, 2)); | 145 tabs1.push_back(GetTracker()->GetTab(kTag, 2)); |
138 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); | 146 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); |
139 ASSERT_EQ(1U, GetTracker()->num_synced_sessions()); | 147 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
140 temp_tab = GetTracker()->GetTab(tag1, 0, 0); // Already created. | 148 temp_tab = GetTracker()->GetTab(kTag, 0); // Already created. |
141 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); | 149 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); |
142 ASSERT_EQ(1U, GetTracker()->num_synced_sessions()); | 150 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
143 ASSERT_EQ(tabs1[0], temp_tab); | 151 ASSERT_EQ(tabs1[0], temp_tab); |
144 tabs2.push_back(GetTracker()->GetTab(tag2, 0, 0)); | 152 tabs2.push_back(GetTracker()->GetTab(kTag2, 0)); |
145 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); | 153 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); |
146 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); | 154 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
147 ASSERT_FALSE(GetTracker()->DeleteSession(tag3)); | 155 ASSERT_FALSE(GetTracker()->DeleteForeignSession(kTag3)); |
148 | 156 |
149 SyncedSession* session = GetTracker()->GetSession(tag1); | 157 SyncedSession* session = GetTracker()->GetSession(kTag); |
150 SyncedSession* session2 = GetTracker()->GetSession(tag2); | 158 SyncedSession* session2 = GetTracker()->GetSession(kTag2); |
151 SyncedSession* session3 = GetTracker()->GetSession(tag3); | 159 SyncedSession* session3 = GetTracker()->GetSession(kTag3); |
152 session3->device_type = SyncedSession::TYPE_OTHER; | 160 session3->device_type = SyncedSession::TYPE_OTHER; |
153 ASSERT_EQ(3U, GetTracker()->num_synced_sessions()); | 161 ASSERT_EQ(3U, GetTracker()->num_synced_sessions()); |
154 | 162 |
155 ASSERT_TRUE(session); | 163 ASSERT_TRUE(session); |
156 ASSERT_TRUE(session2); | 164 ASSERT_TRUE(session2); |
157 ASSERT_TRUE(session3); | 165 ASSERT_TRUE(session3); |
158 ASSERT_NE(session, session2); | 166 ASSERT_NE(session, session2); |
159 ASSERT_NE(session2, session3); | 167 ASSERT_NE(session2, session3); |
160 ASSERT_TRUE(GetTracker()->DeleteSession(tag3)); | 168 ASSERT_TRUE(GetTracker()->DeleteForeignSession(kTag3)); |
161 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); | 169 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
162 | 170 |
163 GetTracker()->PutWindowInSession(tag1, 0); // Create a window. | 171 GetTracker()->PutWindowInSession(kTag, 0); // Create a window. |
164 GetTracker()->PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped. | 172 GetTracker()->PutTabInWindow(kTag, 0, 2); // No longer unmapped. |
165 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); // Has not changed. | 173 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(kTag)); // Has not changed. |
166 | 174 |
167 const sessions::SessionTab* tab_ptr; | 175 const sessions::SessionTab* tab_ptr; |
168 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 0, &tab_ptr)); | 176 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 0, &tab_ptr)); |
169 ASSERT_EQ(tab_ptr, tabs1[0]); | 177 ASSERT_EQ(tab_ptr, tabs1[0]); |
170 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 2, &tab_ptr)); | 178 ASSERT_TRUE(GetTracker()->LookupSessionTab(kTag, 2, &tab_ptr)); |
171 ASSERT_EQ(tab_ptr, tabs1[2]); | 179 ASSERT_EQ(tab_ptr, tabs1[2]); |
172 ASSERT_FALSE(GetTracker()->LookupSessionTab(tag1, 3, &tab_ptr)); | 180 ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, 3, &tab_ptr)); |
173 ASSERT_FALSE(tab_ptr); | 181 ASSERT_FALSE(tab_ptr); |
174 | 182 |
175 std::vector<const sessions::SessionWindow*> windows; | 183 std::vector<const sessions::SessionWindow*> windows; |
176 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag1, &windows)); | 184 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag, &windows)); |
177 ASSERT_EQ(1U, windows.size()); | 185 ASSERT_EQ(1U, windows.size()); |
178 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag2, &windows)); | 186 ASSERT_TRUE(GetTracker()->LookupSessionWindows(kTag2, &windows)); |
179 ASSERT_EQ(0U, windows.size()); | 187 ASSERT_EQ(0U, windows.size()); |
180 | 188 |
181 // The sessions don't have valid tabs, lookup should not succeed. | 189 // The sessions don't have valid tabs, lookup should not succeed. |
182 std::vector<const SyncedSession*> sessions; | 190 std::vector<const SyncedSession*> sessions; |
183 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( | 191 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions( |
184 &sessions, SyncedSessionTracker::PRESENTABLE)); | 192 &sessions, SyncedSessionTracker::PRESENTABLE)); |
185 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( | 193 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions( |
186 &sessions, SyncedSessionTracker::RAW)); | 194 &sessions, SyncedSessionTracker::RAW)); |
187 ASSERT_EQ(2U, sessions.size()); | 195 ASSERT_EQ(2U, sessions.size()); |
188 | 196 |
189 GetTracker()->Clear(); | 197 GetTracker()->Clear(); |
190 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); | 198 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag)); |
191 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag2)); | 199 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag2)); |
192 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); | 200 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
193 } | 201 } |
194 | 202 |
195 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { | 203 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { |
196 ASSERT_TRUE(GetTracker()->Empty()); | 204 ASSERT_TRUE(GetTracker()->Empty()); |
197 const int kMaxSessions = 10; | 205 const int kMaxSessions = 10; |
198 const int kMaxTabs = 1000; | 206 const int kMaxTabs = 1000; |
199 const int kMaxAttempts = 10000; | 207 const int kMaxAttempts = 10000; |
200 for (int j = 0; j < kMaxSessions; ++j) { | 208 for (int j = 0; j < kMaxSessions; ++j) { |
201 std::string tag = base::StringPrintf("tag%d", j); | 209 std::string tag = base::StringPrintf("tag%d", j); |
202 for (int i = 0; i < kMaxAttempts; ++i) { | 210 for (int i = 0; i < kMaxAttempts; ++i) { |
203 // More attempts than tabs means we'll sometimes get the same tabs, | 211 // More attempts than tabs means we'll sometimes get the same tabs, |
204 // sometimes have to allocate new tabs. | 212 // sometimes have to allocate new tabs. |
205 int rand_tab_num = base::RandInt(0, kMaxTabs); | 213 int rand_tab_num = base::RandInt(0, kMaxTabs); |
206 sessions::SessionTab* tab = | 214 sessions::SessionTab* tab = GetTracker()->GetTab(tag, rand_tab_num + 1); |
207 GetTracker()->GetTab(tag, rand_tab_num, rand_tab_num + 1); | |
208 ASSERT_TRUE(tab); | 215 ASSERT_TRUE(tab); |
209 } | 216 } |
210 } | 217 } |
211 } | 218 } |
212 | 219 |
213 TEST_F(SyncedSessionTrackerTest, LookupTabNodeIds) { | 220 TEST_F(SyncedSessionTrackerTest, LookupForeignTabNodeIds) { |
214 std::set<int> result; | 221 std::set<int> result; |
215 std::string tag1 = "session1"; | |
216 std::string tag2 = "session2"; | |
217 std::string tag3 = "session3"; | |
218 | 222 |
219 GetTracker()->GetTab(tag1, 1, 1); | 223 GetTracker()->OnTabNodeSeen(kTag, 1); |
220 GetTracker()->GetTab(tag1, 2, 2); | 224 GetTracker()->OnTabNodeSeen(kTag, 2); |
221 GetTracker()->LookupTabNodeIds(tag1, &result); | 225 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
222 EXPECT_EQ(2U, result.size()); | 226 EXPECT_EQ(2U, result.size()); |
223 EXPECT_FALSE(result.end() == result.find(1)); | 227 EXPECT_FALSE(result.end() == result.find(1)); |
224 EXPECT_FALSE(result.end() == result.find(2)); | 228 EXPECT_FALSE(result.end() == result.find(2)); |
225 GetTracker()->LookupTabNodeIds(tag2, &result); | 229 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); |
226 EXPECT_TRUE(result.empty()); | 230 EXPECT_TRUE(result.empty()); |
227 | 231 |
228 GetTracker()->PutWindowInSession(tag1, 0); | 232 GetTracker()->PutWindowInSession(kTag, 0); |
229 GetTracker()->PutTabInWindow(tag1, 0, 3, 0); | 233 GetTracker()->PutTabInWindow(kTag, 0, 3); |
230 GetTracker()->LookupTabNodeIds(tag1, &result); | 234 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
231 EXPECT_EQ(2U, result.size()); | 235 EXPECT_EQ(2U, result.size()); |
232 | 236 |
233 GetTracker()->GetTab(tag1, 3, 3); | 237 GetTracker()->OnTabNodeSeen(kTag, 3); |
234 GetTracker()->LookupTabNodeIds(tag1, &result); | 238 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
235 EXPECT_EQ(3U, result.size()); | 239 EXPECT_EQ(3U, result.size()); |
236 EXPECT_FALSE(result.end() == result.find(3)); | 240 EXPECT_FALSE(result.end() == result.find(3)); |
237 | 241 |
238 GetTracker()->GetTab(tag2, 1, 21); | 242 GetTracker()->OnTabNodeSeen(kTag2, 21); |
239 GetTracker()->GetTab(tag2, 2, 22); | 243 GetTracker()->OnTabNodeSeen(kTag2, 22); |
240 GetTracker()->LookupTabNodeIds(tag2, &result); | 244 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); |
241 EXPECT_EQ(2U, result.size()); | 245 EXPECT_EQ(2U, result.size()); |
242 EXPECT_FALSE(result.end() == result.find(21)); | 246 EXPECT_FALSE(result.end() == result.find(21)); |
243 EXPECT_FALSE(result.end() == result.find(22)); | 247 EXPECT_FALSE(result.end() == result.find(22)); |
244 GetTracker()->LookupTabNodeIds(tag1, &result); | 248 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
245 EXPECT_EQ(3U, result.size()); | 249 EXPECT_EQ(3U, result.size()); |
246 EXPECT_FALSE(result.end() == result.find(1)); | 250 EXPECT_FALSE(result.end() == result.find(1)); |
247 EXPECT_FALSE(result.end() == result.find(2)); | 251 EXPECT_FALSE(result.end() == result.find(2)); |
248 | 252 |
249 GetTracker()->LookupTabNodeIds(tag3, &result); | 253 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); |
250 EXPECT_TRUE(result.empty()); | 254 EXPECT_TRUE(result.empty()); |
251 GetTracker()->PutWindowInSession(tag3, 1); | 255 GetTracker()->PutWindowInSession(kTag3, 1); |
252 GetTracker()->PutTabInWindow(tag3, 1, 5, 0); | 256 GetTracker()->PutTabInWindow(kTag3, 1, 5); |
253 GetTracker()->LookupTabNodeIds(tag3, &result); | 257 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); |
254 EXPECT_TRUE(result.empty()); | 258 EXPECT_TRUE(result.empty()); |
255 EXPECT_FALSE(GetTracker()->DeleteSession(tag3)); | 259 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag3)); |
256 GetTracker()->LookupTabNodeIds(tag3, &result); | 260 GetTracker()->LookupForeignTabNodeIds(kTag3, &result); |
257 EXPECT_TRUE(result.empty()); | 261 EXPECT_TRUE(result.empty()); |
258 | 262 |
259 EXPECT_FALSE(GetTracker()->DeleteSession(tag1)); | 263 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag)); |
260 GetTracker()->LookupTabNodeIds(tag1, &result); | 264 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
261 EXPECT_TRUE(result.empty()); | 265 EXPECT_TRUE(result.empty()); |
262 GetTracker()->LookupTabNodeIds(tag2, &result); | 266 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); |
263 EXPECT_EQ(2U, result.size()); | 267 EXPECT_EQ(2U, result.size()); |
264 EXPECT_FALSE(result.end() == result.find(21)); | 268 EXPECT_FALSE(result.end() == result.find(21)); |
265 EXPECT_FALSE(result.end() == result.find(22)); | 269 EXPECT_FALSE(result.end() == result.find(22)); |
266 | 270 |
267 GetTracker()->GetTab(tag2, 1, 21); | 271 GetTracker()->OnTabNodeSeen(kTag2, 21); |
268 GetTracker()->GetTab(tag2, 2, 23); | 272 GetTracker()->OnTabNodeSeen(kTag2, 23); |
269 GetTracker()->LookupTabNodeIds(tag2, &result); | 273 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); |
270 EXPECT_EQ(3U, result.size()); | 274 EXPECT_EQ(3U, result.size()); |
271 EXPECT_FALSE(result.end() == result.find(21)); | 275 EXPECT_FALSE(result.end() == result.find(21)); |
272 EXPECT_FALSE(result.end() == result.find(22)); | 276 EXPECT_FALSE(result.end() == result.find(22)); |
273 EXPECT_FALSE(result.end() == result.find(23)); | 277 EXPECT_FALSE(result.end() == result.find(23)); |
274 | 278 |
275 EXPECT_FALSE(GetTracker()->DeleteSession(tag2)); | 279 EXPECT_FALSE(GetTracker()->DeleteForeignSession(kTag2)); |
276 GetTracker()->LookupTabNodeIds(tag2, &result); | 280 GetTracker()->LookupForeignTabNodeIds(kTag2, &result); |
277 EXPECT_TRUE(result.empty()); | 281 EXPECT_TRUE(result.empty()); |
278 } | 282 } |
279 | 283 |
280 TEST_F(SyncedSessionTrackerTest, SessionTracking) { | 284 TEST_F(SyncedSessionTrackerTest, SessionTracking) { |
281 ASSERT_TRUE(GetTracker()->Empty()); | 285 ASSERT_TRUE(GetTracker()->Empty()); |
282 std::string tag1 = "tag1"; | |
283 std::string tag2 = "tag2"; | |
284 | 286 |
285 // Create some session information that is stale. | 287 // Create some session information that is stale. |
286 SyncedSession* session1 = GetTracker()->GetSession(tag1); | 288 SyncedSession* session1 = GetTracker()->GetSession(kTag); |
287 GetTracker()->PutWindowInSession(tag1, 0); | 289 GetTracker()->PutWindowInSession(kTag, 0); |
288 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); | 290 GetTracker()->PutTabInWindow(kTag, 0, 0); |
289 GetTracker()->PutTabInWindow(tag1, 0, 1, 1); | 291 GetTracker()->PutTabInWindow(kTag, 0, 1); |
290 GetTracker()->GetTab(tag1, 2, 3U)->window_id.set_id(0); // Will be unmapped. | 292 GetTracker()->GetTab(kTag, 2)->window_id.set_id(0); // Will be unmapped. |
291 GetTracker()->GetTab(tag1, 3, 4U)->window_id.set_id(0); // Will be unmapped. | 293 GetTracker()->GetTab(kTag, 3)->window_id.set_id(0); // Will be unmapped. |
292 GetTracker()->PutWindowInSession(tag1, 1); | 294 GetTracker()->PutWindowInSession(kTag, 1); |
293 GetTracker()->PutTabInWindow(tag1, 1, 4, 0); | 295 GetTracker()->PutTabInWindow(kTag, 1, 4); |
294 GetTracker()->PutTabInWindow(tag1, 1, 5, 1); | 296 GetTracker()->PutTabInWindow(kTag, 1, 5); |
295 ASSERT_EQ(2U, session1->windows.size()); | 297 ASSERT_EQ(2U, session1->windows.size()); |
296 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); | 298 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); |
297 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); | 299 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); |
298 ASSERT_EQ(6U, GetTracker()->num_synced_tabs(tag1)); | 300 ASSERT_EQ(6U, GetTracker()->num_synced_tabs(kTag)); |
299 | 301 |
300 // Create a session that should not be affected. | 302 // Create a session that should not be affected. |
301 SyncedSession* session2 = GetTracker()->GetSession(tag2); | 303 SyncedSession* session2 = GetTracker()->GetSession(kTag2); |
302 GetTracker()->PutWindowInSession(tag2, 2); | 304 GetTracker()->PutWindowInSession(kTag2, 2); |
303 GetTracker()->PutTabInWindow(tag2, 2, 1, 0); | 305 GetTracker()->PutTabInWindow(kTag2, 2, 1); |
304 ASSERT_EQ(1U, session2->windows.size()); | 306 ASSERT_EQ(1U, session2->windows.size()); |
305 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 307 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
306 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); | 308 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); |
307 | 309 |
308 // Reset tracking and get the current windows/tabs. | 310 // Reset tracking and get the current windows/tabs. |
309 // We simulate moving a tab from one window to another, then closing the | 311 // We simulate moving a tab from one window to another, then closing the |
310 // first window (including its one remaining tab), and opening a new tab | 312 // first window (including its one remaining tab), and opening a new tab |
311 // on the remaining window. | 313 // on the remaining window. |
312 | 314 |
313 // New tab, arrived before meta node so unmapped. | 315 // New tab, arrived before meta node so unmapped. |
314 GetTracker()->GetTab(tag1, 6, 7U); | 316 GetTracker()->GetTab(kTag, 6); |
315 GetTracker()->ResetSessionTracking(tag1); | 317 GetTracker()->ResetSessionTracking(kTag); |
316 GetTracker()->PutWindowInSession(tag1, 0); | 318 GetTracker()->PutWindowInSession(kTag, 0); |
317 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); | 319 GetTracker()->PutTabInWindow(kTag, 0, 0); |
318 // Tab 1 is closed. | 320 // Tab 1 is closed. |
319 GetTracker()->PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped. | 321 GetTracker()->PutTabInWindow(kTag, 0, 2); // No longer unmapped. |
320 // Tab 3 was unmapped and does not get used. | 322 // Tab 3 was unmapped and does not get used. |
321 GetTracker()->PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1. | 323 GetTracker()->PutTabInWindow(kTag, 0, 4); // Moved from window 1. |
322 // Window 1 was closed, along with tab 5. | 324 // Window 1 was closed, along with tab 5. |
323 GetTracker()->PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped. | 325 GetTracker()->PutTabInWindow(kTag, 0, 6); // No longer unmapped. |
324 // Session 2 should not be affected. | 326 // Session 2 should not be affected. |
325 GetTracker()->CleanupSession(tag1); | 327 GetTracker()->CleanupForeignSession(kTag); |
326 | 328 |
327 // Verify that only those parts of the session not owned have been removed. | 329 // Verify that only those parts of the session not owned have been removed. |
328 ASSERT_EQ(1U, session1->windows.size()); | 330 ASSERT_EQ(1U, session1->windows.size()); |
329 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); | 331 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); |
330 ASSERT_EQ(1U, session2->windows.size()); | 332 ASSERT_EQ(1U, session2->windows.size()); |
331 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 333 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
332 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); | 334 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
333 ASSERT_EQ(4U, GetTracker()->num_synced_tabs(tag1)); | 335 ASSERT_EQ(4U, GetTracker()->num_synced_tabs(kTag)); |
334 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); | 336 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2)); |
335 | 337 |
336 // All memory should be properly deallocated by destructor for the | 338 // All memory should be properly deallocated by destructor for the |
337 // SyncedSessionTracker. | 339 // SyncedSessionTracker. |
338 } | 340 } |
339 | 341 |
340 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) { | 342 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) { |
341 std::string session_tag = "session_tag"; | 343 int tab_node_id_1 = 1; |
342 int tab_id_1 = 1; | 344 int tab_node_id_2 = 2; |
343 int tab_id_2 = 2; | |
344 int tab_node_id_3 = 3; | |
345 int tab_node_id_4 = 4; | |
346 std::set<int> result; | 345 std::set<int> result; |
347 | 346 |
348 GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_3); | 347 GetTracker()->OnTabNodeSeen(kTag, tab_node_id_1); |
349 GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_4); | 348 GetTracker()->OnTabNodeSeen(kTag, tab_node_id_2); |
350 GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_3); | 349 |
351 GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_4); | 350 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
352 | |
353 GetTracker()->LookupTabNodeIds(session_tag, &result); | |
354 EXPECT_EQ(2U, result.size()); | 351 EXPECT_EQ(2U, result.size()); |
355 EXPECT_TRUE(result.find(tab_node_id_3) != result.end()); | 352 EXPECT_TRUE(result.find(tab_node_id_1) != result.end()); |
356 EXPECT_TRUE(result.find(tab_node_id_4) != result.end()); | 353 EXPECT_TRUE(result.find(tab_node_id_2) != result.end()); |
357 | 354 |
358 GetTracker()->DeleteForeignTab(session_tag, tab_node_id_3); | 355 GetTracker()->DeleteForeignTab(kTag, tab_node_id_1); |
359 GetTracker()->LookupTabNodeIds(session_tag, &result); | 356 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
360 EXPECT_EQ(1U, result.size()); | 357 EXPECT_EQ(1U, result.size()); |
361 EXPECT_TRUE(result.find(tab_node_id_4) != result.end()); | 358 EXPECT_TRUE(result.find(tab_node_id_2) != result.end()); |
362 | 359 |
363 GetTracker()->DeleteForeignTab(session_tag, tab_node_id_4); | 360 GetTracker()->DeleteForeignTab(kTag, tab_node_id_2); |
364 GetTracker()->LookupTabNodeIds(session_tag, &result); | 361 GetTracker()->LookupForeignTabNodeIds(kTag, &result); |
365 EXPECT_TRUE(result.empty()); | 362 EXPECT_TRUE(result.empty()); |
366 } | 363 } |
367 | 364 |
| 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, ReassociateTabMappedTwice) { |
| 472 std::set<int> free_node_ids; |
| 473 |
| 474 // First create the tab normally. |
| 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 with the same tab id as it was created with. |
| 482 GetTracker()->ResetSessionTracking(kTag); |
| 483 GetTracker()->PutWindowInSession(kTag, kWindow1); |
| 484 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1); |
| 485 GetTracker()->CleanupLocalTabs(&free_node_ids); |
| 486 EXPECT_TRUE(free_node_ids.empty()); |
| 487 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); |
| 488 SyncedSession* session = GetTracker()->GetSession(kTag); |
| 489 ASSERT_EQ(1U, session->windows.size()); |
| 490 ASSERT_EQ(1U, session->windows[kWindow1]->tabs.size()); |
| 491 EXPECT_EQ(GetTracker()->GetTab(kTag, kTab1), |
| 492 session->windows[kWindow1]->tabs[0].get()); |
| 493 |
| 494 // Then reassociate with a new tab id. |
| 495 GetTracker()->ReassociateLocalTab(kTabNode, kTab2); |
| 496 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); |
| 497 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); |
| 498 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); |
| 499 |
| 500 // Tab 1 should no longer be associated with any SessionTab object. At this |
| 501 // point there's no need to verify it's unmapped state. |
| 502 const sessions::SessionTab* tab_ptr = nullptr; |
| 503 EXPECT_FALSE(GetTracker()->LookupSessionTab(kTag, kTab1, &tab_ptr)); |
| 504 |
| 505 // Reset tracking and add back both the old tab and the new tab (both of which |
| 506 // refer to the same tab node id). |
| 507 GetTracker()->ResetSessionTracking(kTag); |
| 508 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2)); |
| 509 GetTracker()->PutWindowInSession(kTag, kWindow1); |
| 510 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1); |
| 511 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2); |
| 512 GetTracker()->CleanupLocalTabs(&free_node_ids); |
| 513 EXPECT_TRUE(free_node_ids.empty()); |
| 514 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); |
| 515 |
| 516 // Now that it's been mapped, it should be accessible both via the |
| 517 // GetSession as well as the GetTab. |
| 518 EXPECT_EQ(GetTracker()->GetTab(kTag, kTab2), |
| 519 session->windows[kWindow1]->tabs[1].get()); |
| 520 EXPECT_EQ(session->tab_node_ids.size(), |
| 521 session->tab_node_ids.count(kTabNode)); |
| 522 EXPECT_EQ(1U, GetTabNodePool()->Capacity()); |
| 523 |
| 524 // Attempting to access the original tab will create a new SessionTab object. |
| 525 EXPECT_NE(GetTracker()->GetTab(kTag, kTab1), |
| 526 GetTracker()->GetTab(kTag, kTab2)); |
| 527 int tab_node_id = -1; |
| 528 EXPECT_FALSE(GetTracker()->GetTabNodeFromLocalTabId(kTab1, &tab_node_id)); |
| 529 } |
| 530 |
| 531 TEST_F(SyncedSessionTrackerTest, ReassociateTabUnmapped) { |
| 532 std::set<int> free_node_ids; |
| 533 |
| 534 // First create the old tab in an unmapped state. |
| 535 GetTracker()->SetLocalSessionTag(kTag); |
| 536 EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); |
| 537 GetTracker()->ReassociateLocalTab(kTabNode, kTab1); |
| 538 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); |
| 539 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1)); |
| 540 |
| 541 // Map it to a window, but reassociated with a new tab id. |
| 542 GetTracker()->ResetSessionTracking(kTag); |
| 543 GetTracker()->ReassociateLocalTab(kTabNode, kTab2); |
| 544 EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode)); |
| 545 EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2)); |
| 546 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1)); |
| 547 GetTracker()->PutWindowInSession(kTag, kWindow1); |
| 548 GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2); |
| 549 GetTracker()->CleanupLocalTabs(&free_node_ids); |
| 550 EXPECT_TRUE(free_node_ids.empty()); |
| 551 EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2)); |
| 552 |
| 553 // Now that it's been mapped, it should be accessible both via the |
| 554 // GetSession as well as GetTab. |
| 555 SyncedSession* session = GetTracker()->GetSession(kTag); |
| 556 ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2), |
| 557 session->windows[kWindow1]->tabs[0].get()); |
| 558 ASSERT_EQ(session->tab_node_ids.size(), |
| 559 session->tab_node_ids.count(kTabNode)); |
| 560 ASSERT_EQ(1U, GetTabNodePool()->Capacity()); |
| 561 } |
| 562 |
368 } // namespace sync_sessions | 563 } // namespace sync_sessions |
OLD | NEW |