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 <string> | 5 #include <string> |
6 #include <vector> | 6 #include <vector> |
7 | 7 |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/rand_util.h" | 9 #include "base/rand_util.h" |
10 #include "base/strings/stringprintf.h" | 10 #include "base/strings/stringprintf.h" |
11 #include "base/strings/utf_string_conversions.h" | 11 #include "base/strings/utf_string_conversions.h" |
12 #include "chrome/browser/sync/glue/synced_session_tracker.h" | 12 #include "chrome/browser/sync/glue/synced_session_tracker.h" |
13 #include "components/sessions/core/serialized_navigation_entry_test_helper.h" | 13 #include "components/sessions/core/serialized_navigation_entry_test_helper.h" |
14 #include "components/sessions/core/session_types.h" | 14 #include "components/sessions/core/session_types.h" |
| 15 #include "components/sync_sessions/fake_sync_sessions_client.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 | 17 |
17 namespace browser_sync { | 18 namespace browser_sync { |
18 | 19 |
19 typedef testing::Test SyncedSessionTrackerTest; | 20 namespace { |
| 21 |
| 22 const std::string kValidUrl = "http://www.example.com"; |
| 23 const std::string kInvalidUrl = "invalid.url"; |
| 24 |
| 25 } // namespace |
| 26 |
| 27 class SyncedSessionTrackerTest : public testing::Test { |
| 28 public: |
| 29 SyncedSessionTrackerTest() : tracker_(&sessions_client_) {} |
| 30 ~SyncedSessionTrackerTest() override {} |
| 31 |
| 32 SyncedSessionTracker* GetTracker() { return &tracker_; } |
| 33 |
| 34 private: |
| 35 sync_sessions::FakeSyncSessionsClient sessions_client_; |
| 36 SyncedSessionTracker tracker_; |
| 37 }; |
20 | 38 |
21 TEST_F(SyncedSessionTrackerTest, GetSession) { | 39 TEST_F(SyncedSessionTrackerTest, GetSession) { |
22 SyncedSessionTracker tracker; | 40 sync_driver::SyncedSession* session1 = GetTracker()->GetSession("tag"); |
23 sync_driver::SyncedSession* session1 = tracker.GetSession("tag"); | 41 sync_driver::SyncedSession* session2 = GetTracker()->GetSession("tag2"); |
24 sync_driver::SyncedSession* session2 = tracker.GetSession("tag2"); | 42 ASSERT_EQ(session1, GetTracker()->GetSession("tag")); |
25 ASSERT_EQ(session1, tracker.GetSession("tag")); | |
26 ASSERT_NE(session1, session2); | 43 ASSERT_NE(session1, session2); |
27 // Should clean up memory on its own. | 44 // Should clean up memory on its own. |
28 } | 45 } |
29 | 46 |
30 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { | 47 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) { |
31 SyncedSessionTracker tracker; | 48 sessions::SessionTab* tab = GetTracker()->GetTab("tag", 0, 0); |
32 sessions::SessionTab* tab = tracker.GetTab("tag", 0, 0); | 49 ASSERT_EQ(tab, GetTracker()->GetTab("tag", 0, 0)); |
33 ASSERT_EQ(tab, tracker.GetTab("tag", 0, 0)); | |
34 // Should clean up memory on its own. | 50 // Should clean up memory on its own. |
35 } | 51 } |
36 | 52 |
37 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { | 53 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) { |
38 SyncedSessionTracker tracker; | 54 GetTracker()->PutWindowInSession("tag", 0); |
39 tracker.PutWindowInSession("tag", 0); | 55 sync_driver::SyncedSession* session = GetTracker()->GetSession("tag"); |
40 sync_driver::SyncedSession* session = tracker.GetSession("tag"); | |
41 ASSERT_EQ(1U, session->windows.size()); | 56 ASSERT_EQ(1U, session->windows.size()); |
42 // Should clean up memory on its own. | 57 // Should clean up memory on its own. |
43 } | 58 } |
44 | 59 |
45 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { | 60 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) { |
46 SyncedSessionTracker tracker; | 61 GetTracker()->PutWindowInSession("tag", 10); |
47 tracker.PutWindowInSession("tag", 10); | 62 GetTracker()->PutTabInWindow("tag", 10, 15, |
48 tracker.PutTabInWindow("tag", 10, 15, 0); // win id 10, tab id 15, tab ind 0. | 63 0); // win id 10, tab id 15, tab ind 0. |
49 sync_driver::SyncedSession* session = tracker.GetSession("tag"); | 64 sync_driver::SyncedSession* session = GetTracker()->GetSession("tag"); |
50 ASSERT_EQ(1U, session->windows.size()); | 65 ASSERT_EQ(1U, session->windows.size()); |
51 ASSERT_EQ(1U, session->windows[10]->tabs.size()); | 66 ASSERT_EQ(1U, session->windows[10]->tabs.size()); |
52 ASSERT_EQ(tracker.GetTab("tag", 15, 1), session->windows[10]->tabs[0]); | 67 ASSERT_EQ(GetTracker()->GetTab("tag", 15, 1), session->windows[10]->tabs[0]); |
53 // Should clean up memory on its own. | 68 // Should clean up memory on its own. |
54 } | 69 } |
55 | 70 |
56 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { | 71 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) { |
57 SyncedSessionTracker tracker; | |
58 std::vector<const sync_driver::SyncedSession*> sessions; | 72 std::vector<const sync_driver::SyncedSession*> sessions; |
59 ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions)); | 73 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(&sessions)); |
60 tracker.GetSession("tag1"); | 74 GetTracker()->GetSession("tag1"); |
61 tracker.GetSession("tag2"); | 75 GetTracker()->PutWindowInSession("tag1", 0); |
62 tracker.PutWindowInSession("tag1", 0); | 76 GetTracker()->PutTabInWindow("tag1", 0, 15, 0); |
63 tracker.PutTabInWindow("tag1", 0, 15, 0); | 77 sessions::SessionTab* tab = GetTracker()->GetTab("tag1", 15, 1); |
64 sessions::SessionTab* tab = tracker.GetTab("tag1", 15, 1); | 78 ASSERT_TRUE(tab); |
| 79 tab->navigations.push_back( |
| 80 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl, |
| 81 "title")); |
| 82 GetTracker()->GetSession("tag2"); |
| 83 GetTracker()->GetSession("tag3"); |
| 84 GetTracker()->PutWindowInSession("tag3", 0); |
| 85 GetTracker()->PutTabInWindow("tag3", 0, 15, 0); |
| 86 tab = GetTracker()->GetTab("tag3", 15, 1); |
65 ASSERT_TRUE(tab); | 87 ASSERT_TRUE(tab); |
66 tab->navigations.push_back( | 88 tab->navigations.push_back( |
67 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( | 89 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( |
68 "bla://valid_url", "title")); | 90 kInvalidUrl, "title")); |
69 ASSERT_TRUE(tracker.LookupAllForeignSessions(&sessions)); | 91 ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(&sessions)); |
70 // Only the session with a valid window and tab gets returned. | 92 // Only the session with a valid window and tab gets returned. |
71 ASSERT_EQ(1U, sessions.size()); | 93 ASSERT_EQ(1U, sessions.size()); |
72 ASSERT_EQ("tag1", sessions[0]->session_tag); | 94 ASSERT_EQ("tag1", sessions[0]->session_tag); |
73 } | 95 } |
74 | 96 |
75 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { | 97 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) { |
76 SyncedSessionTracker tracker; | |
77 std::vector<const sessions::SessionWindow*> windows; | 98 std::vector<const sessions::SessionWindow*> windows; |
78 ASSERT_FALSE(tracker.LookupSessionWindows("tag1", &windows)); | 99 ASSERT_FALSE(GetTracker()->LookupSessionWindows("tag1", &windows)); |
79 tracker.GetSession("tag1"); | 100 GetTracker()->GetSession("tag1"); |
80 tracker.PutWindowInSession("tag1", 0); | 101 GetTracker()->PutWindowInSession("tag1", 0); |
81 tracker.PutWindowInSession("tag1", 2); | 102 GetTracker()->PutWindowInSession("tag1", 2); |
82 tracker.GetSession("tag2"); | 103 GetTracker()->GetSession("tag2"); |
83 tracker.PutWindowInSession("tag2", 0); | 104 GetTracker()->PutWindowInSession("tag2", 0); |
84 tracker.PutWindowInSession("tag2", 2); | 105 GetTracker()->PutWindowInSession("tag2", 2); |
85 ASSERT_TRUE(tracker.LookupSessionWindows("tag1", &windows)); | 106 ASSERT_TRUE(GetTracker()->LookupSessionWindows("tag1", &windows)); |
86 ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session. | 107 ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session. |
87 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); | 108 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[0]); |
88 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); | 109 ASSERT_NE((sessions::SessionWindow*)nullptr, windows[1]); |
89 ASSERT_NE(windows[1], windows[0]); | 110 ASSERT_NE(windows[1], windows[0]); |
90 } | 111 } |
91 | 112 |
92 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { | 113 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) { |
93 SyncedSessionTracker tracker; | |
94 const sessions::SessionTab* tab; | 114 const sessions::SessionTab* tab; |
95 ASSERT_FALSE(tracker.LookupSessionTab("tag1", 5, &tab)); | 115 ASSERT_FALSE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); |
96 tracker.GetSession("tag1"); | 116 GetTracker()->GetSession("tag1"); |
97 tracker.PutWindowInSession("tag1", 0); | 117 GetTracker()->PutWindowInSession("tag1", 0); |
98 tracker.PutTabInWindow("tag1", 0, 5, 0); | 118 GetTracker()->PutTabInWindow("tag1", 0, 5, 0); |
99 ASSERT_TRUE(tracker.LookupSessionTab("tag1", 5, &tab)); | 119 ASSERT_TRUE(GetTracker()->LookupSessionTab("tag1", 5, &tab)); |
100 ASSERT_NE((sessions::SessionTab*)nullptr, tab); | 120 ASSERT_NE((sessions::SessionTab*)nullptr, tab); |
101 } | 121 } |
102 | 122 |
103 TEST_F(SyncedSessionTrackerTest, Complex) { | 123 TEST_F(SyncedSessionTrackerTest, Complex) { |
104 const std::string tag1 = "tag"; | 124 const std::string tag1 = "tag"; |
105 const std::string tag2 = "tag2"; | 125 const std::string tag2 = "tag2"; |
106 const std::string tag3 = "tag3"; | 126 const std::string tag3 = "tag3"; |
107 SyncedSessionTracker tracker; | |
108 std::vector<sessions::SessionTab*> tabs1, tabs2; | 127 std::vector<sessions::SessionTab*> tabs1, tabs2; |
109 sessions::SessionTab* temp_tab; | 128 sessions::SessionTab* temp_tab; |
110 ASSERT_TRUE(tracker.Empty()); | 129 ASSERT_TRUE(GetTracker()->Empty()); |
111 ASSERT_EQ(0U, tracker.num_synced_sessions()); | 130 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
112 ASSERT_EQ(0U, tracker.num_synced_tabs(tag1)); | 131 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); |
113 tabs1.push_back(tracker.GetTab(tag1, 0, 0)); | 132 tabs1.push_back(GetTracker()->GetTab(tag1, 0, 0)); |
114 tabs1.push_back(tracker.GetTab(tag1, 1, 1)); | 133 tabs1.push_back(GetTracker()->GetTab(tag1, 1, 1)); |
115 tabs1.push_back(tracker.GetTab(tag1, 2, 2)); | 134 tabs1.push_back(GetTracker()->GetTab(tag1, 2, 2)); |
116 ASSERT_EQ(3U, tracker.num_synced_tabs(tag1)); | 135 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); |
117 ASSERT_EQ(0U, tracker.num_synced_sessions()); | 136 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
118 temp_tab = tracker.GetTab(tag1, 0, 0); // Already created. | 137 temp_tab = GetTracker()->GetTab(tag1, 0, 0); // Already created. |
119 ASSERT_EQ(3U, tracker.num_synced_tabs(tag1)); | 138 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); |
120 ASSERT_EQ(0U, tracker.num_synced_sessions()); | 139 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
121 ASSERT_EQ(tabs1[0], temp_tab); | 140 ASSERT_EQ(tabs1[0], temp_tab); |
122 tabs2.push_back(tracker.GetTab(tag2, 0, 0)); | 141 tabs2.push_back(GetTracker()->GetTab(tag2, 0, 0)); |
123 ASSERT_EQ(1U, tracker.num_synced_tabs(tag2)); | 142 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
124 ASSERT_EQ(0U, tracker.num_synced_sessions()); | 143 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
125 ASSERT_FALSE(tracker.DeleteSession(tag3)); | 144 ASSERT_FALSE(GetTracker()->DeleteSession(tag3)); |
126 | 145 |
127 sync_driver::SyncedSession* session = tracker.GetSession(tag1); | 146 sync_driver::SyncedSession* session = GetTracker()->GetSession(tag1); |
128 sync_driver::SyncedSession* session2 = tracker.GetSession(tag2); | 147 sync_driver::SyncedSession* session2 = GetTracker()->GetSession(tag2); |
129 sync_driver::SyncedSession* session3 = tracker.GetSession(tag3); | 148 sync_driver::SyncedSession* session3 = GetTracker()->GetSession(tag3); |
130 ASSERT_EQ(3U, tracker.num_synced_sessions()); | 149 ASSERT_EQ(3U, GetTracker()->num_synced_sessions()); |
131 | 150 |
132 ASSERT_TRUE(session); | 151 ASSERT_TRUE(session); |
133 ASSERT_TRUE(session2); | 152 ASSERT_TRUE(session2); |
134 ASSERT_TRUE(session3); | 153 ASSERT_TRUE(session3); |
135 ASSERT_NE(session, session2); | 154 ASSERT_NE(session, session2); |
136 ASSERT_NE(session2, session3); | 155 ASSERT_NE(session2, session3); |
137 ASSERT_TRUE(tracker.DeleteSession(tag3)); | 156 ASSERT_TRUE(GetTracker()->DeleteSession(tag3)); |
138 ASSERT_EQ(2U, tracker.num_synced_sessions()); | 157 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
139 | 158 |
140 tracker.PutWindowInSession(tag1, 0); // Create a window. | 159 GetTracker()->PutWindowInSession(tag1, 0); // Create a window. |
141 tracker.PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped. | 160 GetTracker()->PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped. |
142 ASSERT_EQ(3U, tracker.num_synced_tabs(tag1)); // Has not changed. | 161 ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1)); // Has not changed. |
143 | 162 |
144 const sessions::SessionTab *tab_ptr; | 163 const sessions::SessionTab *tab_ptr; |
145 ASSERT_TRUE(tracker.LookupSessionTab(tag1, 0, &tab_ptr)); | 164 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 0, &tab_ptr)); |
146 ASSERT_EQ(tab_ptr, tabs1[0]); | 165 ASSERT_EQ(tab_ptr, tabs1[0]); |
147 ASSERT_TRUE(tracker.LookupSessionTab(tag1, 2, &tab_ptr)); | 166 ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 2, &tab_ptr)); |
148 ASSERT_EQ(tab_ptr, tabs1[2]); | 167 ASSERT_EQ(tab_ptr, tabs1[2]); |
149 ASSERT_FALSE(tracker.LookupSessionTab(tag1, 3, &tab_ptr)); | 168 ASSERT_FALSE(GetTracker()->LookupSessionTab(tag1, 3, &tab_ptr)); |
150 ASSERT_EQ(static_cast<const sessions::SessionTab*>(NULL), tab_ptr); | 169 ASSERT_EQ(static_cast<const sessions::SessionTab*>(NULL), tab_ptr); |
151 | 170 |
152 std::vector<const sessions::SessionWindow*> windows; | 171 std::vector<const sessions::SessionWindow*> windows; |
153 ASSERT_TRUE(tracker.LookupSessionWindows(tag1, &windows)); | 172 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag1, &windows)); |
154 ASSERT_EQ(1U, windows.size()); | 173 ASSERT_EQ(1U, windows.size()); |
155 ASSERT_TRUE(tracker.LookupSessionWindows(tag2, &windows)); | 174 ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag2, &windows)); |
156 ASSERT_EQ(0U, windows.size()); | 175 ASSERT_EQ(0U, windows.size()); |
157 | 176 |
158 // The sessions don't have valid tabs, lookup should not succeed. | 177 // The sessions don't have valid tabs, lookup should not succeed. |
159 std::vector<const sync_driver::SyncedSession*> sessions; | 178 std::vector<const sync_driver::SyncedSession*> sessions; |
160 ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions)); | 179 ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(&sessions)); |
161 | 180 |
162 tracker.Clear(); | 181 GetTracker()->Clear(); |
163 ASSERT_EQ(0U, tracker.num_synced_tabs(tag1)); | 182 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1)); |
164 ASSERT_EQ(0U, tracker.num_synced_tabs(tag2)); | 183 ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag2)); |
165 ASSERT_EQ(0U, tracker.num_synced_sessions()); | 184 ASSERT_EQ(0U, GetTracker()->num_synced_sessions()); |
166 } | 185 } |
167 | 186 |
168 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { | 187 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) { |
169 SyncedSessionTracker tracker; | 188 ASSERT_TRUE(GetTracker()->Empty()); |
170 ASSERT_TRUE(tracker.Empty()); | |
171 const int kMaxSessions = 10; | 189 const int kMaxSessions = 10; |
172 const int kMaxTabs = 1000; | 190 const int kMaxTabs = 1000; |
173 const int kMaxAttempts = 10000; | 191 const int kMaxAttempts = 10000; |
174 for (int j=0; j<kMaxSessions; ++j) { | 192 for (int j=0; j<kMaxSessions; ++j) { |
175 std::string tag = base::StringPrintf("tag%d", j); | 193 std::string tag = base::StringPrintf("tag%d", j); |
176 for (int i=0; i<kMaxAttempts; ++i) { | 194 for (int i=0; i<kMaxAttempts; ++i) { |
177 // More attempts than tabs means we'll sometimes get the same tabs, | 195 // More attempts than tabs means we'll sometimes get the same tabs, |
178 // sometimes have to allocate new tabs. | 196 // sometimes have to allocate new tabs. |
179 int rand_tab_num = base::RandInt(0, kMaxTabs); | 197 int rand_tab_num = base::RandInt(0, kMaxTabs); |
180 sessions::SessionTab* tab = | 198 sessions::SessionTab* tab = |
181 tracker.GetTab(tag, rand_tab_num, rand_tab_num + 1); | 199 GetTracker()->GetTab(tag, rand_tab_num, rand_tab_num + 1); |
182 ASSERT_TRUE(tab); | 200 ASSERT_TRUE(tab); |
183 } | 201 } |
184 } | 202 } |
185 } | 203 } |
186 | 204 |
187 TEST_F(SyncedSessionTrackerTest, LookupTabNodeIds) { | 205 TEST_F(SyncedSessionTrackerTest, LookupTabNodeIds) { |
188 SyncedSessionTracker tracker; | |
189 std::set<int> result; | 206 std::set<int> result; |
190 std::string tag1 = "session1"; | 207 std::string tag1 = "session1"; |
191 std::string tag2 = "session2"; | 208 std::string tag2 = "session2"; |
192 std::string tag3 = "session3"; | 209 std::string tag3 = "session3"; |
193 | 210 |
194 tracker.GetTab(tag1, 1, 1); | 211 GetTracker()->GetTab(tag1, 1, 1); |
195 tracker.GetTab(tag1, 2, 2); | 212 GetTracker()->GetTab(tag1, 2, 2); |
196 EXPECT_TRUE(tracker.LookupTabNodeIds(tag1, &result)); | 213 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result)); |
197 EXPECT_EQ(2U, result.size()); | 214 EXPECT_EQ(2U, result.size()); |
198 EXPECT_FALSE(result.end() == result.find(1)); | 215 EXPECT_FALSE(result.end() == result.find(1)); |
199 EXPECT_FALSE(result.end() == result.find(2)); | 216 EXPECT_FALSE(result.end() == result.find(2)); |
200 EXPECT_FALSE(tracker.LookupTabNodeIds(tag2, &result)); | 217 EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag2, &result)); |
201 | 218 |
202 tracker.PutWindowInSession(tag1, 0); | 219 GetTracker()->PutWindowInSession(tag1, 0); |
203 tracker.PutTabInWindow(tag1, 0, 3, 0); | 220 GetTracker()->PutTabInWindow(tag1, 0, 3, 0); |
204 EXPECT_TRUE(tracker.LookupTabNodeIds(tag1, &result)); | 221 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result)); |
205 EXPECT_EQ(2U, result.size()); | 222 EXPECT_EQ(2U, result.size()); |
206 | 223 |
207 tracker.GetTab(tag1, 3, 3); | 224 GetTracker()->GetTab(tag1, 3, 3); |
208 EXPECT_TRUE(tracker.LookupTabNodeIds(tag1, &result)); | 225 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result)); |
209 EXPECT_EQ(3U, result.size()); | 226 EXPECT_EQ(3U, result.size()); |
210 EXPECT_FALSE(result.end() == result.find(3)); | 227 EXPECT_FALSE(result.end() == result.find(3)); |
211 | 228 |
212 tracker.GetTab(tag2, 1, 21); | 229 GetTracker()->GetTab(tag2, 1, 21); |
213 tracker.GetTab(tag2, 2, 22); | 230 GetTracker()->GetTab(tag2, 2, 22); |
214 EXPECT_TRUE(tracker.LookupTabNodeIds(tag2, &result)); | 231 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag2, &result)); |
215 EXPECT_EQ(2U, result.size()); | 232 EXPECT_EQ(2U, result.size()); |
216 EXPECT_FALSE(result.end() == result.find(21)); | 233 EXPECT_FALSE(result.end() == result.find(21)); |
217 EXPECT_FALSE(result.end() == result.find(22)); | 234 EXPECT_FALSE(result.end() == result.find(22)); |
218 EXPECT_TRUE(tracker.LookupTabNodeIds(tag1, &result)); | 235 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result)); |
219 EXPECT_EQ(3U, result.size()); | 236 EXPECT_EQ(3U, result.size()); |
220 EXPECT_FALSE(result.end() == result.find(1)); | 237 EXPECT_FALSE(result.end() == result.find(1)); |
221 EXPECT_FALSE(result.end() == result.find(2)); | 238 EXPECT_FALSE(result.end() == result.find(2)); |
222 | 239 |
223 EXPECT_FALSE(tracker.LookupTabNodeIds(tag3, &result)); | 240 EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag3, &result)); |
224 tracker.PutWindowInSession(tag3, 1); | 241 GetTracker()->PutWindowInSession(tag3, 1); |
225 tracker.PutTabInWindow(tag3, 1, 5, 0); | 242 GetTracker()->PutTabInWindow(tag3, 1, 5, 0); |
226 EXPECT_TRUE(tracker.LookupTabNodeIds(tag3, &result)); | 243 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag3, &result)); |
227 EXPECT_TRUE(result.empty()); | 244 EXPECT_TRUE(result.empty()); |
228 EXPECT_TRUE(tracker.DeleteSession(tag3)); | 245 EXPECT_TRUE(GetTracker()->DeleteSession(tag3)); |
229 EXPECT_FALSE(tracker.LookupTabNodeIds(tag3, &result)); | 246 EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag3, &result)); |
230 | 247 |
231 EXPECT_TRUE(tracker.DeleteSession(tag1)); | 248 EXPECT_TRUE(GetTracker()->DeleteSession(tag1)); |
232 EXPECT_FALSE(tracker.LookupTabNodeIds(tag1, &result)); | 249 EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag1, &result)); |
233 EXPECT_TRUE(tracker.LookupTabNodeIds(tag2, &result)); | 250 EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag2, &result)); |
234 EXPECT_EQ(2U, result.size()); | 251 EXPECT_EQ(2U, result.size()); |
235 EXPECT_FALSE(result.end() == result.find(21)); | 252 EXPECT_FALSE(result.end() == result.find(21)); |
236 EXPECT_FALSE(result.end() == result.find(22)); | 253 EXPECT_FALSE(result.end() == result.find(22)); |
237 EXPECT_TRUE(tracker.DeleteSession(tag2)); | 254 EXPECT_TRUE(GetTracker()->DeleteSession(tag2)); |
238 EXPECT_FALSE(tracker.LookupTabNodeIds(tag2, &result)); | 255 EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag2, &result)); |
239 } | 256 } |
240 | 257 |
241 TEST_F(SyncedSessionTrackerTest, SessionTracking) { | 258 TEST_F(SyncedSessionTrackerTest, SessionTracking) { |
242 SyncedSessionTracker tracker; | 259 ASSERT_TRUE(GetTracker()->Empty()); |
243 ASSERT_TRUE(tracker.Empty()); | |
244 std::string tag1 = "tag1"; | 260 std::string tag1 = "tag1"; |
245 std::string tag2 = "tag2"; | 261 std::string tag2 = "tag2"; |
246 | 262 |
247 // Create some session information that is stale. | 263 // Create some session information that is stale. |
248 sync_driver::SyncedSession* session1 = tracker.GetSession(tag1); | 264 sync_driver::SyncedSession* session1 = GetTracker()->GetSession(tag1); |
249 tracker.PutWindowInSession(tag1, 0); | 265 GetTracker()->PutWindowInSession(tag1, 0); |
250 tracker.PutTabInWindow(tag1, 0, 0, 0); | 266 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); |
251 tracker.PutTabInWindow(tag1, 0, 1, 1); | 267 GetTracker()->PutTabInWindow(tag1, 0, 1, 1); |
252 tracker.GetTab(tag1, 2, 3U)->window_id.set_id(0); // Will be unmapped. | 268 GetTracker()->GetTab(tag1, 2, 3U)->window_id.set_id(0); // Will be unmapped. |
253 tracker.GetTab(tag1, 3, 4U)->window_id.set_id(0); // Will be unmapped. | 269 GetTracker()->GetTab(tag1, 3, 4U)->window_id.set_id(0); // Will be unmapped. |
254 tracker.PutWindowInSession(tag1, 1); | 270 GetTracker()->PutWindowInSession(tag1, 1); |
255 tracker.PutTabInWindow(tag1, 1, 4, 0); | 271 GetTracker()->PutTabInWindow(tag1, 1, 4, 0); |
256 tracker.PutTabInWindow(tag1, 1, 5, 1); | 272 GetTracker()->PutTabInWindow(tag1, 1, 5, 1); |
257 ASSERT_EQ(2U, session1->windows.size()); | 273 ASSERT_EQ(2U, session1->windows.size()); |
258 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); | 274 ASSERT_EQ(2U, session1->windows[0]->tabs.size()); |
259 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); | 275 ASSERT_EQ(2U, session1->windows[1]->tabs.size()); |
260 ASSERT_EQ(6U, tracker.num_synced_tabs(tag1)); | 276 ASSERT_EQ(6U, GetTracker()->num_synced_tabs(tag1)); |
261 | 277 |
262 // Create a session that should not be affected. | 278 // Create a session that should not be affected. |
263 sync_driver::SyncedSession* session2 = tracker.GetSession(tag2); | 279 sync_driver::SyncedSession* session2 = GetTracker()->GetSession(tag2); |
264 tracker.PutWindowInSession(tag2, 2); | 280 GetTracker()->PutWindowInSession(tag2, 2); |
265 tracker.PutTabInWindow(tag2, 2, 1, 0); | 281 GetTracker()->PutTabInWindow(tag2, 2, 1, 0); |
266 ASSERT_EQ(1U, session2->windows.size()); | 282 ASSERT_EQ(1U, session2->windows.size()); |
267 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 283 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
268 ASSERT_EQ(1U, tracker.num_synced_tabs(tag2)); | 284 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
269 | 285 |
270 // Reset tracking and get the current windows/tabs. | 286 // Reset tracking and get the current windows/tabs. |
271 // We simulate moving a tab from one window to another, then closing the | 287 // We simulate moving a tab from one window to another, then closing the |
272 // first window (including its one remaining tab), and opening a new tab | 288 // first window (including its one remaining tab), and opening a new tab |
273 // on the remaining window. | 289 // on the remaining window. |
274 | 290 |
275 // New tab, arrived before meta node so unmapped. | 291 // New tab, arrived before meta node so unmapped. |
276 tracker.GetTab(tag1, 6, 7U); | 292 GetTracker()->GetTab(tag1, 6, 7U); |
277 tracker.ResetSessionTracking(tag1); | 293 GetTracker()->ResetSessionTracking(tag1); |
278 tracker.PutWindowInSession(tag1, 0); | 294 GetTracker()->PutWindowInSession(tag1, 0); |
279 tracker.PutTabInWindow(tag1, 0, 0, 0); | 295 GetTracker()->PutTabInWindow(tag1, 0, 0, 0); |
280 // Tab 1 is closed. | 296 // Tab 1 is closed. |
281 tracker.PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped. | 297 GetTracker()->PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped. |
282 // Tab 3 was unmapped and does not get used. | 298 // Tab 3 was unmapped and does not get used. |
283 tracker.PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1. | 299 GetTracker()->PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1. |
284 // Window 1 was closed, along with tab 5. | 300 // Window 1 was closed, along with tab 5. |
285 tracker.PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped. | 301 GetTracker()->PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped. |
286 // Session 2 should not be affected. | 302 // Session 2 should not be affected. |
287 tracker.CleanupSession(tag1); | 303 GetTracker()->CleanupSession(tag1); |
288 | 304 |
289 // Verify that only those parts of the session not owned have been removed. | 305 // Verify that only those parts of the session not owned have been removed. |
290 ASSERT_EQ(1U, session1->windows.size()); | 306 ASSERT_EQ(1U, session1->windows.size()); |
291 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); | 307 ASSERT_EQ(4U, session1->windows[0]->tabs.size()); |
292 ASSERT_EQ(1U, session2->windows.size()); | 308 ASSERT_EQ(1U, session2->windows.size()); |
293 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); | 309 ASSERT_EQ(1U, session2->windows[2]->tabs.size()); |
294 ASSERT_EQ(2U, tracker.num_synced_sessions()); | 310 ASSERT_EQ(2U, GetTracker()->num_synced_sessions()); |
295 ASSERT_EQ(4U, tracker.num_synced_tabs(tag1)); | 311 ASSERT_EQ(4U, GetTracker()->num_synced_tabs(tag1)); |
296 ASSERT_EQ(1U, tracker.num_synced_tabs(tag2)); | 312 ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2)); |
297 | 313 |
298 // All memory should be properly deallocated by destructor for the | 314 // All memory should be properly deallocated by destructor for the |
299 // SyncedSessionTracker. | 315 // SyncedSessionTracker. |
300 } | 316 } |
301 | 317 |
302 } // namespace browser_sync | 318 } // namespace browser_sync |
OLD | NEW |