[Sync] Introduce SyncedSessionWindow type.

components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_sessions/revisit/sessions_page_revisit_observer.h"
 
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 69 matching lines @@
 };
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoSessions) {
   std::vector<const SyncedSession*> sessions;
   SessionsPageRevisitObserver observer(
       base::MakeUnique<TestForeignSessionsProvider>(sessions, true));
   CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) {
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto session = base::MakeUnique<SyncedSession>();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoTabs) {
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
-  session->windows[0] = base::MakeUnique<SessionWindow>();
+  auto session = base::MakeUnique<SyncedSession>();
+  session->windows[0] = base::MakeUnique<SyncedSessionWindow>();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoEntries) {
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(base::MakeUnique<SessionTab>());
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(base::MakeUnique<SessionTab>());
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersSingle) {
-  std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
+  auto tab = base::MakeUnique<SessionTab>();
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 0;
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(std::move(tab));
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
   CheckAndExpect(session.get(), GURL(kExampleUrl), true, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
-  std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
+  auto tab = base::MakeUnique<SessionTab>();
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 1;
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(std::move(tab));
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
 
   // The provider returns false when asked for foreign sessions, even though
   // it has has a valid tab.
   std::vector<const SyncedSession*> sessions;
   sessions.push_back(session.get());
   SessionsPageRevisitObserver observer(
       base::MakeUnique<TestForeignSessionsProvider>(sessions, false));
   CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
-  std::unique_ptr<SessionTab> tab1 = base::MakeUnique<SessionTab>();
+  auto tab1 = base::MakeUnique<SessionTab>();
   tab1->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab1->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab2 = base::MakeUnique<SessionTab>();
+  auto tab2 = base::MakeUnique<SessionTab>();
   tab2->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab2->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab3 = base::MakeUnique<SessionTab>();
+  auto tab3 = base::MakeUnique<SessionTab>();
   tab3->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab3->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab4 = base::MakeUnique<SessionTab>();
+  auto tab4 = base::MakeUnique<SessionTab>();
   tab4->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab4->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab4->current_navigation_index = 1;
 
-  std::unique_ptr<SessionWindow> window1 = base::MakeUnique<SessionWindow>();
-  window1->tabs.push_back(std::move(tab1));
-  std::unique_ptr<SessionWindow> window2 = base::MakeUnique<SessionWindow>();
-  window2->tabs.push_back(std::move(tab2));
-  std::unique_ptr<SessionWindow> window3 = base::MakeUnique<SessionWindow>();
-  window3->tabs.push_back(std::move(tab3));
-  window3->tabs.push_back(std::move(tab4));
+  auto window1 = base::MakeUnique<SyncedSessionWindow>();
+  window1->wrapped_window.tabs.push_back(std::move(tab1));
+  auto window2 = base::MakeUnique<SyncedSessionWindow>();
+  window2->wrapped_window.tabs.push_back(std::move(tab2));
+  auto window3 = base::MakeUnique<SyncedSessionWindow>();
+  window3->wrapped_window.tabs.push_back(std::move(tab3));
+  window3->wrapped_window.tabs.push_back(std::move(tab4));
 
-  std::unique_ptr<SyncedSession> session1 = base::MakeUnique<SyncedSession>();
+  auto session1 = base::MakeUnique<SyncedSession>();
   session1->windows[1] = std::move(window1);
-  std::unique_ptr<SyncedSession> session2 = base::MakeUnique<SyncedSession>();
+  auto session2 = base::MakeUnique<SyncedSession>();
   session2->windows[2] = std::move(window2);
   session2->windows[3] = std::move(window3);
 
   std::vector<const SyncedSession*> sessions;
   sessions.push_back(session1.get());
   sessions.push_back(session2.get());
   SessionsPageRevisitObserver observer(
       base::MakeUnique<TestForeignSessionsProvider>(sessions, true));
 
   base::HistogramTester histogram_tester;
   CheckAndExpect(&observer, GURL(kExampleUrl), true, true);
 }
 
 }  // namespace sync_sessions