[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 75 matching lines @@
   CheckAndExpect(&observer, GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) {
   std::unique_ptr<SyncedSession> 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>();
+  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<SyncedSessionWindow> window =

[skym, 2017/03/28 04:48:55]

What do you think of using auto here? The right hand side of this assignment has
the type anyways. (This applies to a few below as well)

[Nicolas Zea, 2017/03/29 19:01:33]

Done.

+      base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(base::MakeUnique<SessionTab>());
   std::unique_ptr<SyncedSession> 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>();
   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<SyncedSessionWindow> window =
+      base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
   std::unique_ptr<SyncedSession> 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>();
   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<SyncedSessionWindow> window =
+      base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
   std::unique_ptr<SyncedSession> 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);
@@ skipping 20 matching lines @@
 
   std::unique_ptr<SessionTab> 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));
+  std::unique_ptr<SyncedSessionWindow> window1 =
+      base::MakeUnique<SyncedSessionWindow>();
+  window1->wrapped_window.tabs.push_back(std::move(tab1));
+  std::unique_ptr<SyncedSessionWindow> window2 =
+      base::MakeUnique<SyncedSessionWindow>();
+  window2->wrapped_window.tabs.push_back(std::move(tab2));
+  std::unique_ptr<SyncedSessionWindow> 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>();
   session1->windows[1] = std::move(window1);
   std::unique_ptr<SyncedSession> 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