|
OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <vector> | |
6 #include <string> | |
7 | |
8 #include "base/scoped_ptr.h" | |
9 #include "base/values.h" | |
10 #include "chrome/browser/sessions/session_types.h" | |
11 #include "chrome/browser/sync/glue/session_model_associator.h" | |
12 #include "chrome/common/page_transition_types.h" | |
13 #include "chrome/common/url_constants.h" | |
14 #include "chrome/test/testing_profile.h" | |
15 #include "testing/gtest/include/gtest/gtest.h" | |
16 | |
17 using browser_sync::SessionModelAssociator; | |
18 using browser_sync::ForeignSessionTracker; | |
19 namespace browser_sync { | |
20 | |
21 class SessionModelAssociatorTest : public testing::Test { | |
tim (not reviewing)
2011/01/04 14:32:47
note you can do 'typedef testing::Test SessionMode
Nicolas Zea
2011/01/06 01:14:13
Done.
| |
22 }; | |
23 | |
24 TEST_F(SessionModelAssociatorTest, SessionWindowHasNoTabsToSync) { | |
25 SessionWindow win; | |
26 ASSERT_TRUE(SessionModelAssociator::SessionWindowHasNoTabsToSync(win)); | |
27 scoped_ptr<SessionTab> tab(new SessionTab()); | |
28 win.tabs.push_back(tab.release()); | |
29 ASSERT_TRUE(SessionModelAssociator::SessionWindowHasNoTabsToSync(win)); | |
30 TabNavigation nav(0, GURL("about:bubba"), GURL("about:referrer"), | |
31 string16(ASCIIToUTF16("title")), | |
32 std::string("state"), 0U); | |
33 win.tabs[0]->navigations.push_back(nav); | |
34 ASSERT_FALSE(SessionModelAssociator::SessionWindowHasNoTabsToSync(win)); | |
35 } | |
36 | |
37 TEST_F(SessionModelAssociatorTest, IsValidSessionTab) { | |
38 SessionTab tab; | |
39 ASSERT_FALSE(SessionModelAssociator::IsValidSessionTab(tab)); | |
40 TabNavigation nav(0, GURL(chrome::kChromeUINewTabURL), | |
41 GURL("about:referrer"), | |
42 string16(ASCIIToUTF16("title")), | |
43 std::string("state"), 0U); | |
44 tab.navigations.push_back(nav); | |
45 // NewTab does not count as valid if it's the only navigation. | |
46 ASSERT_FALSE(SessionModelAssociator::IsValidSessionTab(tab)); | |
47 TabNavigation nav2(0, GURL("about:bubba"), | |
48 GURL("about:referrer"), | |
49 string16(ASCIIToUTF16("title")), | |
50 std::string("state"), 0U); | |
51 tab.navigations.push_back(nav2); | |
52 // Once there's another navigation, the tab is valid. | |
53 ASSERT_TRUE(SessionModelAssociator::IsValidSessionTab(tab)); | |
54 } | |
55 | |
56 TEST_F(SessionModelAssociatorTest, PopulateSessionWindow) { | |
57 sync_pb::SessionWindow window_s; | |
58 window_s.add_tab(0); | |
59 window_s.set_browser_type(sync_pb::SessionWindow_BrowserType_TYPE_NORMAL); | |
60 window_s.set_selected_tab_index(1); | |
61 | |
62 std::string tag = "tag"; | |
63 ForeignSessionTracker tracker; | |
64 ForeignSession* session = tracker.GetForeignSession(tag); | |
65 scoped_ptr<SessionWindow> win(new SessionWindow()); | |
tim (not reviewing)
2011/01/04 14:32:47
instead of the extra clause at the end, could we j
Nicolas Zea
2011/01/06 01:14:13
Done.
| |
66 SessionModelAssociator::PopulateSessionWindowFromSpecifics( | |
67 tag, window_s, 0, win.get(), &tracker); | |
68 ASSERT_EQ(1U, win->tabs.size()); | |
69 ASSERT_EQ(1, win->selected_tab_index); | |
70 ASSERT_EQ(1, win->type); | |
71 ASSERT_EQ(1U, tracker.num_foreign_sessions()); | |
72 ASSERT_EQ(1U, tracker.num_foreign_tabs(std::string("tag"))); | |
73 | |
74 // We do this so that when the destructor for the tracker is called, it will | |
75 // be able to delete the session, window, and tab. We can't delete these | |
76 // ourselves, otherwise we would run into double free errors when the | |
77 // destructor was invoked (the true argument tells the tracker the tab | |
78 // is now associated with a window). | |
79 ASSERT_TRUE(tracker.GetSessionTab(tag, 0, true)); | |
80 session->windows.push_back(win.release()); | |
81 } | |
82 | |
83 TEST_F(SessionModelAssociatorTest, PopulateSessionTab) { | |
84 sync_pb::SessionTab tab_s; | |
85 tab_s.set_tab_visual_index(13); | |
86 tab_s.set_current_navigation_index(3); | |
87 tab_s.set_pinned(true); | |
88 tab_s.set_extension_app_id("app_id"); | |
89 sync_pb::TabNavigation* navigation = tab_s.add_navigation(); | |
90 navigation->set_index(12); | |
91 navigation->set_virtual_url("http://foo/1"); | |
92 navigation->set_referrer("referrer"); | |
93 navigation->set_title("title"); | |
94 navigation->set_page_transition(sync_pb::TabNavigation_PageTransition_TYPED); | |
95 | |
96 SessionTab tab; | |
97 SessionModelAssociator::PopulateSessionTabFromSpecifics(tab_s, 0, &tab); | |
98 ASSERT_EQ(13, tab.tab_visual_index); | |
99 ASSERT_EQ(3, tab.current_navigation_index); | |
100 ASSERT_TRUE(tab.pinned); | |
101 ASSERT_EQ("app_id", tab.extension_app_id); | |
102 ASSERT_EQ(12, tab.navigations[0].index()); | |
103 ASSERT_EQ(GURL("referrer"), tab.navigations[0].referrer()); | |
104 ASSERT_EQ(string16(ASCIIToUTF16("title")), tab.navigations[0].title()); | |
105 ASSERT_EQ(PageTransition::TYPED, tab.navigations[0].transition()); | |
106 ASSERT_EQ(GURL("http://foo/1"), tab.navigations[0].virtual_url()); | |
107 } | |
108 | |
109 TEST_F(SessionModelAssociatorTest, ForeignSessionTracker) { | |
110 const std::string tag1 = "tag"; | |
111 const std::string tag2 = "tag2"; | |
112 const std::string tag3 = "tag3"; | |
113 ForeignSessionTracker tracker; | |
114 ASSERT_TRUE(tracker.empty()); | |
115 ASSERT_EQ(0U, tracker.num_foreign_sessions()); | |
116 ASSERT_EQ(0U, tracker.num_foreign_tabs(tag1)); | |
117 SessionTab* tab = tracker.GetSessionTab(tag1, 0, false); | |
118 ASSERT_EQ(1U, tracker.num_foreign_tabs(tag1)); | |
119 ASSERT_EQ(0U, tracker.num_foreign_sessions()); | |
120 SessionTab* tab2 = tracker.GetSessionTab(tag1, 0, false); | |
121 ASSERT_EQ(1U, tracker.num_foreign_tabs(tag1)); | |
122 ASSERT_EQ(0U, tracker.num_foreign_sessions()); | |
123 ASSERT_EQ(tab, tab2); | |
124 tab2 = tracker.GetSessionTab(tag2, 0, false); | |
125 ASSERT_EQ(1U, tracker.num_foreign_tabs(tag1)); | |
126 ASSERT_EQ(1U, tracker.num_foreign_tabs(tag2)); | |
127 ASSERT_EQ(0U, tracker.num_foreign_sessions()); | |
128 | |
129 ASSERT_FALSE(tracker.DeleteForeignSession(tag1)); | |
130 ASSERT_FALSE(tracker.DeleteForeignSession(tag3)); | |
131 | |
132 ForeignSession* session = tracker.GetForeignSession(tag1); | |
133 ForeignSession* session2 = tracker.GetForeignSession(tag2); | |
134 ForeignSession* session3 = tracker.GetForeignSession(tag3); | |
135 ASSERT_EQ(3U, tracker.num_foreign_sessions()); | |
136 | |
137 ASSERT_TRUE(session); | |
138 ASSERT_TRUE(session2); | |
139 ASSERT_TRUE(session3); | |
140 ASSERT_NE(session, session2); | |
141 ASSERT_NE(session2, session3); | |
142 ASSERT_TRUE(tracker.DeleteForeignSession(tag3)); | |
143 ASSERT_EQ(2U, tracker.num_foreign_sessions()); | |
144 | |
145 const SessionTab *tab_ptr; | |
146 ASSERT_TRUE(tracker.LookupSessionTab(tag1, 0, &tab_ptr)); | |
147 ASSERT_EQ(tab_ptr, tab); | |
148 | |
149 std::vector<SessionWindow*> windows; | |
150 ASSERT_TRUE(tracker.LookupSessionWindows(tag1, &windows)); | |
151 ASSERT_EQ(0U, windows.size()); | |
152 | |
153 // The sessions don't have valid windows, lookup should not succeed. | |
154 std::vector<const ForeignSession*> sessions; | |
155 ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions)); | |
156 | |
157 tracker.clear(); | |
158 ASSERT_EQ(0U, tracker.num_foreign_tabs(tag1)); | |
159 ASSERT_EQ(0U, tracker.num_foreign_tabs(tag2)); | |
160 ASSERT_EQ(0U, tracker.num_foreign_sessions()); | |
161 } | |
162 | |
163 } // namespace browser_sync | |
164 | |
OLD | NEW |