Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(596)

Side by Side Diff: components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc

Issue 2499023004: [Sync] Introduce SyncedSessionWindow type. (Closed)
Patch Set: Fix compile Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 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/revisit/sessions_page_revisit_observer.h" 5 #include "components/sync_sessions/revisit/sessions_page_revisit_observer.h"
6 6
7 #include <string> 7 #include <string>
8 #include <utility> 8 #include <utility>
9 9
10 #include "base/memory/ptr_util.h" 10 #include "base/memory/ptr_util.h"
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
86 CheckAndExpect(&observer, GURL(kExampleUrl), false, false); 86 CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
87 } 87 }
88 88
89 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) { 89 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) {
90 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>(); 90 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
91 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false); 91 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
92 } 92 }
93 93
94 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoTabs) { 94 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoTabs) {
95 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>(); 95 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
96 session->windows[0] = base::MakeUnique<SessionWindow>(); 96 session->windows[0] = base::MakeUnique<SyncedSessionWindow>();
97 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false); 97 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
98 } 98 }
99 99
100 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoEntries) { 100 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoEntries) {
101 std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>(); 101 std::unique_ptr<SyncedSessionWindow> window =
skym 2017/03/28 04:48:55 What do you think of using auto here? The right ha
Nicolas Zea 2017/03/29 19:01:33 Done.
102 window->tabs.push_back(base::MakeUnique<SessionTab>()); 102 base::MakeUnique<SyncedSessionWindow>();
103 window->wrapped_window.tabs.push_back(base::MakeUnique<SessionTab>());
103 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>(); 104 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
104 session->windows[0] = std::move(window); 105 session->windows[0] = std::move(window);
105 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false); 106 CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
106 } 107 }
107 108
108 TEST_F(SessionsPageRevisitObserverTest, RunMatchersSingle) { 109 TEST_F(SessionsPageRevisitObserverTest, RunMatchersSingle) {
109 std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>(); 110 std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
110 tab->navigations.push_back( 111 tab->navigations.push_back(
111 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( 112 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
112 kExampleUrl, "")); 113 kExampleUrl, ""));
113 tab->current_navigation_index = 0; 114 tab->current_navigation_index = 0;
114 std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>(); 115 std::unique_ptr<SyncedSessionWindow> window =
115 window->tabs.push_back(std::move(tab)); 116 base::MakeUnique<SyncedSessionWindow>();
117 window->wrapped_window.tabs.push_back(std::move(tab));
116 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>(); 118 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
117 session->windows[0] = std::move(window); 119 session->windows[0] = std::move(window);
118 CheckAndExpect(session.get(), GURL(kExampleUrl), true, false); 120 CheckAndExpect(session.get(), GURL(kExampleUrl), true, false);
119 } 121 }
120 122
121 TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) { 123 TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
122 std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>(); 124 std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
123 tab->navigations.push_back( 125 tab->navigations.push_back(
124 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( 126 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
125 kExampleUrl, "")); 127 kExampleUrl, ""));
126 tab->navigations.push_back( 128 tab->navigations.push_back(
127 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( 129 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
128 kExampleUrl, "")); 130 kExampleUrl, ""));
129 tab->current_navigation_index = 1; 131 tab->current_navigation_index = 1;
130 std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>(); 132 std::unique_ptr<SyncedSessionWindow> window =
131 window->tabs.push_back(std::move(tab)); 133 base::MakeUnique<SyncedSessionWindow>();
134 window->wrapped_window.tabs.push_back(std::move(tab));
132 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>(); 135 std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
133 session->windows[0] = std::move(window); 136 session->windows[0] = std::move(window);
134 137
135 // The provider returns false when asked for foreign sessions, even though 138 // The provider returns false when asked for foreign sessions, even though
136 // it has has a valid tab. 139 // it has has a valid tab.
137 std::vector<const SyncedSession*> sessions; 140 std::vector<const SyncedSession*> sessions;
138 sessions.push_back(session.get()); 141 sessions.push_back(session.get());
139 SessionsPageRevisitObserver observer( 142 SessionsPageRevisitObserver observer(
140 base::MakeUnique<TestForeignSessionsProvider>(sessions, false)); 143 base::MakeUnique<TestForeignSessionsProvider>(sessions, false));
141 CheckAndExpect(&observer, GURL(kExampleUrl), false, false); 144 CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
(...skipping 20 matching lines...) Expand all
162 165
163 std::unique_ptr<SessionTab> tab4 = base::MakeUnique<SessionTab>(); 166 std::unique_ptr<SessionTab> tab4 = base::MakeUnique<SessionTab>();
164 tab4->navigations.push_back( 167 tab4->navigations.push_back(
165 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( 168 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
166 kExampleUrl, "")); 169 kExampleUrl, ""));
167 tab4->navigations.push_back( 170 tab4->navigations.push_back(
168 sessions::SerializedNavigationEntryTestHelper::CreateNavigation( 171 sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
169 kDifferentUrl, "")); 172 kDifferentUrl, ""));
170 tab4->current_navigation_index = 1; 173 tab4->current_navigation_index = 1;
171 174
172 std::unique_ptr<SessionWindow> window1 = base::MakeUnique<SessionWindow>(); 175 std::unique_ptr<SyncedSessionWindow> window1 =
173 window1->tabs.push_back(std::move(tab1)); 176 base::MakeUnique<SyncedSessionWindow>();
174 std::unique_ptr<SessionWindow> window2 = base::MakeUnique<SessionWindow>(); 177 window1->wrapped_window.tabs.push_back(std::move(tab1));
175 window2->tabs.push_back(std::move(tab2)); 178 std::unique_ptr<SyncedSessionWindow> window2 =
176 std::unique_ptr<SessionWindow> window3 = base::MakeUnique<SessionWindow>(); 179 base::MakeUnique<SyncedSessionWindow>();
177 window3->tabs.push_back(std::move(tab3)); 180 window2->wrapped_window.tabs.push_back(std::move(tab2));
178 window3->tabs.push_back(std::move(tab4)); 181 std::unique_ptr<SyncedSessionWindow> window3 =
182 base::MakeUnique<SyncedSessionWindow>();
183 window3->wrapped_window.tabs.push_back(std::move(tab3));
184 window3->wrapped_window.tabs.push_back(std::move(tab4));
179 185
180 std::unique_ptr<SyncedSession> session1 = base::MakeUnique<SyncedSession>(); 186 std::unique_ptr<SyncedSession> session1 = base::MakeUnique<SyncedSession>();
181 session1->windows[1] = std::move(window1); 187 session1->windows[1] = std::move(window1);
182 std::unique_ptr<SyncedSession> session2 = base::MakeUnique<SyncedSession>(); 188 std::unique_ptr<SyncedSession> session2 = base::MakeUnique<SyncedSession>();
183 session2->windows[2] = std::move(window2); 189 session2->windows[2] = std::move(window2);
184 session2->windows[3] = std::move(window3); 190 session2->windows[3] = std::move(window3);
185 191
186 std::vector<const SyncedSession*> sessions; 192 std::vector<const SyncedSession*> sessions;
187 sessions.push_back(session1.get()); 193 sessions.push_back(session1.get());
188 sessions.push_back(session2.get()); 194 sessions.push_back(session2.get());
189 SessionsPageRevisitObserver observer( 195 SessionsPageRevisitObserver observer(
190 base::MakeUnique<TestForeignSessionsProvider>(sessions, true)); 196 base::MakeUnique<TestForeignSessionsProvider>(sessions, true));
191 197
192 base::HistogramTester histogram_tester; 198 base::HistogramTester histogram_tester;
193 CheckAndExpect(&observer, GURL(kExampleUrl), true, true); 199 CheckAndExpect(&observer, GURL(kExampleUrl), true, true);
194 } 200 }
195 201
196 } // namespace sync_sessions 202 } // namespace sync_sessions
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698