[Sync] Restore previous session if no tabbed windows present

components/sync_sessions/sessions_sync_manager_unittest.cc

 // Copyright 2014 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/sessions_sync_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 225 matching lines @@
 
   void reset() {
     current_entry_index_ = 0;
     sync_id_ = TabNodePool::kInvalidTabNodeID;
     entries_.clear();
   }
 
  private:
   int current_entry_index_ = -1;
   bool is_supervised_ = false;
-  int sync_id_ = -1;
+  int sync_id_ = kInvalidTabID;
   SessionID tab_id_;
   SessionID window_id_;
   std::vector<std::unique_ptr<const sessions::SerializedNavigationEntry>>
       blocked_navigations_;
   std::vector<std::unique_ptr<const sessions::SerializedNavigationEntry>>
       entries_;
 };
 
 // A placeholder delegate. These delegates have no WebContents, simulating a tab
 // that has been restored without bringing its state fully into memory (for
@@ skipping 64 matching lines @@
   }
   bool ShouldSync(SyncSessionsClient* sessions_client) override {
     NOTREACHED();
     return false;
   }
 
   SessionID::id_type GetSourceTabID() const override { return kInvalidTabID; }
 
  private:
   SessionID::id_type session_id_;
-  int sync_id_;
+  int sync_id_ = kInvalidTabID;
 };
 
 class TestSyncedWindowDelegate : public SyncedWindowDelegate {
  public:
   TestSyncedWindowDelegate() {}
   ~TestSyncedWindowDelegate() override {}
 
   bool HasWindow() const override { return true; }
 
   SessionID::id_type GetSessionId() const override { return window_id_.id(); }
 
   int GetTabCount() const override { return tab_delegates_.size(); }
 
   int GetActiveIndex() const override { return 0; }
 
   bool IsApp() const override { return false; }
 
   bool IsTypeTabbed() const override {
     return window_type_ == sync_pb::SessionWindow_BrowserType_TYPE_TABBED;
   }
 
   bool IsTypePopup() const override {
     return window_type_ == sync_pb::SessionWindow_BrowserType_TYPE_POPUP;
   }
 
   bool IsTabPinned(const SyncedTabDelegate* tab) const override {
     return false;
   }
 
+  void OverrideWindowTypeToCustomTab() {
+    window_type_ = sync_pb::SessionWindow_BrowserType_TYPE_CUSTOM_TAB;
+  }
+
   SyncedTabDelegate* GetTabAt(int index) const override {
     if (tab_delegates_.find(index) != tab_delegates_.end())
       return tab_delegates_.find(index)->second;
 
     return nullptr;
   }
 
   void OverrideWindowId(SessionID::id_type id) { window_id_.set_id(id); }
 
   void OverrideTabAt(int index, SyncedTabDelegate* delegate) {
     tab_delegates_[index] = delegate;
   }
 
   SessionID::id_type GetTabIdAt(int index) const override {
     SyncedTabDelegate* delegate = GetTabAt(index);
     if (!delegate)
       return kInvalidTabID;
     return delegate->GetSessionId();
   }
 
   bool IsSessionRestoreInProgress() const override { return false; }
 
   bool ShouldSync() const override { return true; }
 
  private:
   std::map<int, SyncedTabDelegate*> tab_delegates_;
   SessionID window_id_;
   sync_pb::SessionWindow_BrowserType window_type_ =
       sync_pb::SessionWindow_BrowserType_TYPE_TABBED;
+  std::map<int, SyncedTabDelegate*> tab_overrides_;
+  std::map<int, SessionID::id_type> tab_id_overrides_;
 };
 
 class TestSyncedWindowDelegatesGetter : public SyncedWindowDelegatesGetter {
  public:
   TestSyncedWindowDelegatesGetter() {}
   ~TestSyncedWindowDelegatesGetter() override {}
 
   SyncedWindowDelegateMap GetSyncedWindowDelegates() override {
     return delegates_;
   }
 
   const SyncedWindowDelegate* FindById(SessionID::id_type id) override {
     for (auto window_iter_pair : delegates_) {
       if (window_iter_pair.second->GetSessionId() == id)
         return window_iter_pair.second;
     }
     return nullptr;
   }
 
   void AddSyncedWindowDelegate(const SyncedWindowDelegate* delegate) {
     delegates_[delegate->GetSessionId()] = delegate;
   }
 
+  void ClearSyncedWindowDelegates() { delegates_.clear(); }
+
  private:
   SyncedWindowDelegateMap delegates_;
 };
 
 class TestSyncChangeProcessor : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncChangeProcessor(SyncChangeList* output) : output_(output) {}
   SyncError ProcessSyncChanges(const tracked_objects::Location& from_here,
                                const SyncChangeList& change_list) override {
     if (error_.IsSet()) {
@@ skipping 39 matching lines @@
   SyncDataList sync_data_to_return_;
   base::ObserverList<syncer::LocalChangeObserver> local_change_observers_;
 };
 
 class DummyRouter : public LocalSessionEventRouter {
  public:
   ~DummyRouter() override {}
   void StartRoutingTo(LocalSessionEventHandler* handler) override {
     handler_ = handler;
   }
-  void Stop() override {}
+  void Stop() override { handler_ = nullptr; }
 
   void NotifyNav(SyncedTabDelegate* tab) {
     if (handler_)
       handler_->OnLocalTabModified(tab);
   }
 
  private:
   LocalSessionEventHandler* handler_ = nullptr;
 };
 
@@ skipping 226 matching lines @@
         SerializedNavigationEntryTestHelper::CreateNavigation(url, kTitle));
     SerializedNavigationEntryTestHelper::SetTimestamp(time, entry.get());
     delegate->AppendEntry(std::move(entry));
     delegate->set_current_entry_index(delegate->GetCurrentEntryIndex() + 1);
     router_->NotifyNav(delegate);
   }
   void NavigateTab(TestSyncedTabDelegate* delegate, const std::string& url) {
     NavigateTab(delegate, url, base::Time());
   }
 
+  void ResetWindows() {
+    window_getter_.ClearSyncedWindowDelegates();
+    windows_.clear();
+  }
+
   TestSyncedWindowDelegate* AddWindow() {
     windows_.push_back(base::MakeUnique<TestSyncedWindowDelegate>());
     window_getter_.AddSyncedWindowDelegate(windows_.back().get());
     return windows_.back().get();
   }
 
+  syncer::SyncDataList GetDataFromChanges(
+      const syncer::SyncChangeList& changes) {
+    syncer::SyncDataList data_list;
+    for (auto& change : changes) {
+      syncer::SyncDataLocal change_data(change.sync_data());
+      bool found = false;
+      for (auto&& data : data_list) {
+        syncer::SyncDataLocal local_data(data);
+        if (local_data.GetTag() == change_data.GetTag()) {
+          data = change.sync_data();
+          found = true;
+          break;
+        }
+      }
+      if (!found)
+        data_list.push_back(change_data);
+    }
+    return data_list;
+  }
+
+  syncer::SyncDataList ConvertToRemote(const syncer::SyncDataList& in) {
+    syncer::SyncDataList out;
+    for (auto& data : in) {
+      out.push_back(CreateRemoteData(data.GetSpecifics()));
+    }
+    return out;
+  }
+
  private:
   std::unique_ptr<syncer::FakeSyncClient> sync_client_;
   std::unique_ptr<SyncSessionsClientShim> sessions_client_shim_;
   std::unique_ptr<syncer::SyncPrefs> sync_prefs_;
   SessionNotificationObserver observer_;
   std::unique_ptr<DummyRouter> router_;
   std::unique_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncChangeProcessor* test_processor_ = nullptr;
   TestSyncedWindowDelegatesGetter window_getter_;
   std::vector<std::unique_ptr<TestSyncedWindowDelegate>> windows_;
   std::vector<std::unique_ptr<TestSyncedTabDelegate>> tabs_;
   std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
 };
 
-// Test that the SyncSessionManager can properly fill in a SessionHeader.
-TEST_F(SessionsSyncManagerTest, PopulateSessionHeader) {
-  sync_pb::SessionHeader header_s;
-  header_s.set_client_name("Client 1");
-  header_s.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_WIN);
-
-  SyncedSession session;
-  base::Time time = base::Time::Now();
-  SessionsSyncManager::PopulateSessionHeaderFromSpecifics(header_s, time,
-                                                          &session);
-  ASSERT_EQ("Client 1", session.session_name);
-  ASSERT_EQ(SyncedSession::TYPE_WIN, session.device_type);
-  ASSERT_EQ(time, session.modified_time);
-}
-
-// Test translation between protobuf types and chrome session types.
-TEST_F(SessionsSyncManagerTest, PopulateSessionWindow) {
-  sync_pb::SessionWindow window_s;
-  window_s.add_tab(0);
-  window_s.set_browser_type(sync_pb::SessionWindow_BrowserType_TYPE_TABBED);
-  window_s.set_selected_tab_index(1);
-
-  SyncedSession* session = manager()->session_tracker_.GetSession(kTag1);
-  manager()->session_tracker_.PutWindowInSession(kTag1, 0);
-  manager()->BuildSyncedSessionFromSpecifics(kTag1, window_s, base::Time(),
-                                             session->windows[0].get());
-  ASSERT_EQ(1U, session->windows[0]->wrapped_window.tabs.size());
-  ASSERT_EQ(1, session->windows[0]->wrapped_window.selected_tab_index);
-  ASSERT_EQ(sessions::SessionWindow::TYPE_TABBED,
-            session->windows[0]->wrapped_window.type);
-  ASSERT_EQ(1U, manager()->session_tracker_.num_synced_sessions());
-  ASSERT_EQ(1U, manager()->session_tracker_.num_synced_tabs(kTag1));
-}
-
-// Populate the fake tab delegate with some data and navigation
 // entries and make sure that setting a SessionTab from it preserves
 // those entries (and clobbers any existing data).
 TEST_F(SessionsSyncManagerTest, SetSessionTabFromDelegate) {
   // Create a tab with three valid entries.
   TestSyncedTabDelegate* tab =
       AddTab(AddWindow()->GetSessionId(), kFoo1, kTime1);
   NavigateTab(tab, kBar1, kTime2);
   NavigateTab(tab, kBaz1, kTime3);
 
   sessions::SessionTab session_tab;
@@ skipping 160 matching lines @@
   SyncData d = CreateRemoteData(out[1].sync_data().GetSpecifics());
   SyncDataList in = {d};
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
   InitWithSyncDataTakeOutput(in, &out);
 
   ASSERT_TRUE(ChangeTypeMatches(out, {SyncChange::ACTION_UPDATE}));
   EXPECT_TRUE(out[0].sync_data().GetSpecifics().session().has_header());
 }
 
+// Ensure that tabbed windows from a previous session are preserved if no
+// windows are present on startup.
+TEST_F(SessionsSyncManagerTest, PreserveTabbedDataNoWindows) {
+  syncer::SyncDataList in;
+  syncer::SyncChangeList out;
+
+  // Set up one tab and start sync with it.
+  TestSyncedTabDelegate* tab = AddTab(AddWindow()->GetSessionId(), kFoo1);
+  NavigateTab(tab, kFoo2);
+  InitWithSyncDataTakeOutput(in, &out);
+
+  // There should be two entities, a header and a tab.
+  in = GetDataFromChanges(out);
+  out.clear();
+  ASSERT_EQ(2U, in.size());
+
+  // Resync, using the previous sync data, but with no windows open now.
+  manager()->StopSyncing(syncer::SESSIONS);
+  ResetWindows();
+  InitWithSyncDataTakeOutput(ConvertToRemote(in), &out);
+
+  // There should be two changes: the rewritten tab (to update the tab id), and
+  // the rewritten header.
+  ASSERT_TRUE(ChangeTypeMatches(
+      out, {SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE}));
+  VerifyLocalTabChange(out[0], 2, kFoo2);
+  VerifyLocalHeaderChange(out[1], 1, 1);
+
+  // Verify the tab id of the restored tab is updated and consistent.
+  int restored_tab_id =
+      out[0].sync_data().GetSpecifics().session().tab().tab_id();
+  // SessionId should be rewritten on restore.
+  ASSERT_NE(tab->GetSessionId(), restored_tab_id);
+  ASSERT_EQ(
+      restored_tab_id,
+      out[1].sync_data().GetSpecifics().session().header().window(0).tab(0));
+}
+
+// Ensure that tabbed windows from a previous session are preserved if only
+// transient windows are present at startup.
+TEST_F(SessionsSyncManagerTest, PreserveTabbedDataCustomTab) {
+  syncer::SyncDataList in;
+  syncer::SyncChangeList out;
+
+  // Set up one tab and start sync with it.
+  TestSyncedWindowDelegate* window = AddWindow();
+  TestSyncedTabDelegate* tab = AddTab(window->GetSessionId(), kFoo1);
+  NavigateTab(tab, kFoo2);
+  InitWithSyncDataTakeOutput(in, &out);
+
+  // There should be two entities, a header and a tab.
+  in = GetDataFromChanges(out);
+  out.clear();
+  ASSERT_EQ(2U, in.size());
+
+  // Resync, using the previous sync data, but with only a custom tab open.
+  manager()->StopSyncing(syncer::SESSIONS);
+  window->OverrideWindowTypeToCustomTab();
+  SessionID new_window_id;
+  window->OverrideWindowId(new_window_id.id());
+  std::unique_ptr<TestSyncedTabDelegate> custom_tab =
+      base::MakeUnique<TestSyncedTabDelegate>();
+  NavigateTab(custom_tab.get(), kBar1);
+  window->OverrideTabAt(0, custom_tab.get());
+  InitWithSyncDataTakeOutput(ConvertToRemote(in), &out);
+
+  // The previous session should be preserved, and the transient window should
+  // be synced as a new transient window. This means that the original tab
+  // node will be updated with its new tab id, a new tab node will be created,
+  // and the header will be updated to reflect the two windows and two tabs.
+  ASSERT_TRUE(
+      ChangeTypeMatches(out, {SyncChange::ACTION_UPDATE, SyncChange::ACTION_ADD,
+                              SyncChange::ACTION_UPDATE}));
+  VerifyLocalTabChange(out[0], 2, kFoo2);
+  VerifyLocalTabChange(out[1], 1, kBar1);
+  VerifyLocalHeaderChange(out[2], 2, 2);
+
+  // The two windows should have different window types.
+  ASSERT_EQ(sync_pb::SessionWindow::TYPE_CUSTOM_TAB, out[2]
+                                                         .sync_data()
+                                                         .GetSpecifics()
+                                                         .session()
+                                                         .header()
+                                                         .window(0)
+                                                         .browser_type());
+  ASSERT_EQ(sync_pb::SessionWindow::TYPE_TABBED, out[2]
+                                                     .sync_data()
+                                                     .GetSpecifics()
+                                                     .session()
+                                                     .header()
+                                                     .window(1)
+                                                     .browser_type());
+
+  // Verify the tab id of the restored tab is updated and consistent.
+  int restored_tab_id =
+      out[0].sync_data().GetSpecifics().session().tab().tab_id();
+  // SessionId should be rewritten on restore.
+  ASSERT_NE(tab->GetSessionId(), restored_tab_id);
+  ASSERT_EQ(
+      restored_tab_id,
+      out[2].sync_data().GetSpecifics().session().header().window(1).tab(0));
+
+  // Verify the tab id of the custom tab is consistent.
+  int custom_tab_id =
+      out[1].sync_data().GetSpecifics().session().tab().tab_id();
+  ASSERT_EQ(custom_tab->GetSessionId(), custom_tab_id);
+  ASSERT_EQ(
+      custom_tab_id,
+      out[2].sync_data().GetSpecifics().session().header().window(0).tab(0));
+}
+
 // Tests MergeDataAndStartSyncing with sync data but no local data.
 TEST_F(SessionsSyncManagerTest, MergeWithInitialForeignSession) {
   std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
                                             std::end(kTabIds1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(kTag1, tab_list1, &tabs1));
   // Add a second window.
   std::vector<SessionID::id_type> tab_list2(std::begin(kTabIds2),
                                             std::end(kTabIds2));
@@ skipping 610 matching lines @@
       changes[1].sync_data().GetSpecifics().session().tab_node_id();
 
   // Pass back the previous tab and header nodes at association, along with a
   // second tab node (with a rewritten tab node id).
   SyncDataList in;
   in.push_back(
       CreateRemoteData(changes[2].sync_data().GetSpecifics()));  // Header node.
   sync_pb::SessionSpecifics new_tab(
       changes[1].sync_data().GetSpecifics().session());
   new_tab.set_tab_node_id(tab_node_id + 1);
-  in.push_back(CreateRemoteData(new_tab));  // New tab node.
   in.push_back(CreateRemoteData(
       changes[1].sync_data().GetSpecifics()));  // Old tab node.
+  in.push_back(CreateRemoteData(new_tab));      // New tab node.
   changes.clear();
 
   // Reassociate (with the same single tab/window open).
   manager()->StopSyncing(syncer::SESSIONS);
   InitWithSyncDataTakeOutput(in, &changes);
 
   // No tab entities should be deleted. The original (lower) tab node id should
   // be reused for association.
   FilterOutLocalHeaderChanges(&changes);
   ASSERT_TRUE(ChangeTypeMatches(changes, {SyncChange::ACTION_UPDATE}));
@@ skipping 791 matching lines @@
   window2->OverrideTabAt(0, &tab2);
 
   // Resync, reusing the old sync data.
   in.push_back(CreateRemoteData(out[0].sync_data().GetSpecifics()));
   in.push_back(CreateRemoteData(out[1].sync_data().GetSpecifics()));
   out.clear();
   InitWithSyncDataTakeOutput(in, &out);
 
   // The tab entity will be overwritten twice. Once with the information for
   // tab 1 and then again with the information for tab 2. This will be followed
-  // by a header change reflecting both tabs.
+  // by a header change reflecting only the final tab.
   ASSERT_TRUE(
       ChangeTypeMatches(out,
                         {SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE,
                          SyncChange::ACTION_UPDATE}));
-  VerifyLocalHeaderChange(out[2], 2, 2);
+  VerifyLocalHeaderChange(out[2], 2, 1);
   VerifyLocalTabChange(out[0], 1, kFoo1);
   EXPECT_EQ(sync_id, out[0].sync_data().GetSpecifics().session().tab_node_id());
   EXPECT_EQ(tab1->GetSessionId(),
             out[0].sync_data().GetSpecifics().session().tab().tab_id());
   // Because tab 2 is a placeholder, tab 1's URL will be preserved.
   VerifyLocalTabChange(out[1], 1, kFoo1);
   EXPECT_EQ(sync_id, out[1].sync_data().GetSpecifics().session().tab_node_id());
   EXPECT_EQ(tab2.GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().tab_id());
   EXPECT_EQ(window2->GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().window_id());
 }
 
 }  // namespace sync_sessions