[Sync] Introduce SyncedSessionWindow type.

components/sync_sessions/synced_session_tracker.cc

 // Copyright (c) 2012 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/synced_session_tracker.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 17 matching lines @@
     }
   }
   return false;
 }
 
 // Presentable means |foreign_session| must have syncable content.
 bool IsPresentable(SyncSessionsClient* sessions_client,
                    SyncedSession* foreign_session) {
   for (auto iter = foreign_session->windows.begin();
        iter != foreign_session->windows.end(); ++iter) {
-    if (ShouldSyncSessionWindow(sessions_client, *(iter->second))) {
+    if (ShouldSyncSessionWindow(sessions_client,
+                                iter->second->wrapped_window)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
 SyncedSessionTracker::SyncedSessionTracker(SyncSessionsClient* sessions_client)
     : sessions_client_(sessions_client) {}
@@ skipping 27 matching lines @@
 bool SyncedSessionTracker::LookupSessionWindows(
     const std::string& session_tag,
     std::vector<const sessions::SessionWindow*>* windows) const {
   DCHECK(windows);
   windows->clear();
 
   auto iter = synced_session_map_.find(session_tag);
   if (iter == synced_session_map_.end())
     return false;
   for (const auto& window_pair : iter->second->windows)
-    windows->push_back(window_pair.second.get());
+    windows->push_back(&window_pair.second->wrapped_window);
 
   return true;
 }
 
 bool SyncedSessionTracker::LookupSessionTab(
     const std::string& tag,
     SessionID::id_type tab_id,
     const sessions::SessionTab** tab) const {
   if (tab_id == kInvalidTabID)
     return false;
@@ skipping 77 matching lines @@
 
   return header_existed;
 }
 
 void SyncedSessionTracker::ResetSessionTracking(
     const std::string& session_tag) {
   SyncedSession* session = GetSession(session_tag);
 
   for (auto& window_pair : session->windows) {
     // First unmap the tabs in the window.
-    for (auto& tab : window_pair.second->tabs) {
+    for (auto& tab : window_pair.second->wrapped_window.tabs) {
       SessionID::id_type tab_id = tab->tab_id.id();
       unmapped_tabs_[session_tag][tab_id] = std::move(tab);
     }
-    window_pair.second->tabs.clear();
+    window_pair.second->wrapped_window.tabs.clear();
 
     // Then unmap the window itself.
     unmapped_windows_[session_tag][window_pair.first] =
         std::move(window_pair.second);
   }
   session->windows.clear();
 }
 
 void SyncedSessionTracker::DeleteForeignTab(const std::string& session_tag,
                                             int tab_node_id) {
@@ skipping 14 matching lines @@
   unmapped_tabs_[session_tag].clear();
 }
 
 bool SyncedSessionTracker::IsTabUnmappedForTesting(SessionID::id_type tab_id) {
   auto it = unmapped_tabs_[local_session_tag_].find(tab_id);
   return it != unmapped_tabs_[local_session_tag_].end();
 }
 
 void SyncedSessionTracker::PutWindowInSession(const std::string& session_tag,
                                               SessionID::id_type window_id) {
-  std::unique_ptr<sessions::SessionWindow> window;
+  std::unique_ptr<SyncedSessionWindow> window;
 
   auto iter = unmapped_windows_[session_tag].find(window_id);
   if (iter != unmapped_windows_[session_tag].end()) {
     DCHECK_EQ(synced_window_map_[session_tag][window_id], iter->second.get());
     window = std::move(iter->second);
     unmapped_windows_[session_tag].erase(iter);
     DVLOG(1) << "Putting seen window " << window_id << " at " << window.get()
              << "in " << (session_tag == local_session_tag_ ? "local session"
                                                             : session_tag);
   } else {
     // Create the window.
-    window = base::MakeUnique<sessions::SessionWindow>();
-    window->window_id.set_id(window_id);
+    window = base::MakeUnique<SyncedSessionWindow>();
+    window->wrapped_window.window_id.set_id(window_id);
     synced_window_map_[session_tag][window_id] = window.get();
     DVLOG(1) << "Putting new window " << window_id << " at " << window.get()
              << "in " << (session_tag == local_session_tag_ ? "local session"
                                                             : session_tag);
   }
-  DCHECK_EQ(window->window_id.id(), window_id);
+  DCHECK_EQ(window->wrapped_window.window_id.id(), window_id);
   DCHECK(GetSession(session_tag)->windows.end() ==
          GetSession(session_tag)->windows.find(window_id));
   GetSession(session_tag)->windows[window_id] = std::move(window);
 }
 
 void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
                                           SessionID::id_type window_id,
                                           SessionID::id_type tab_id) {
   // We're called here for two reasons. 1) We've received an update to the
   // SessionWindow information of a SessionHeader node for a session,
@@ skipping 13 matching lines @@
   auto it = unmapped_tabs_[session_tag].find(tab_id);
   if (it != unmapped_tabs_[session_tag].end()) {
     tab = std::move(it->second);
     unmapped_tabs_[session_tag].erase(it);
   } else {
     // The tab has already been mapped, possibly because of the tab node id
     // being reused across tabs. Find the existing tab and move it to the right
     // window.
     for (auto& window_iter_pair : GetSession(session_tag)->windows) {
       auto tab_iter = std::find_if(
-          window_iter_pair.second->tabs.begin(),
-          window_iter_pair.second->tabs.end(),
+          window_iter_pair.second->wrapped_window.tabs.begin(),
+          window_iter_pair.second->wrapped_window.tabs.end(),
           [&tab_ptr](const std::unique_ptr<sessions::SessionTab>& tab) {
             return tab.get() == tab_ptr;
           });
-      if (tab_iter != window_iter_pair.second->tabs.end()) {
+      if (tab_iter != window_iter_pair.second->wrapped_window.tabs.end()) {
         tab = std::move(*tab_iter);
-        window_iter_pair.second->tabs.erase(tab_iter);
+        window_iter_pair.second->wrapped_window.tabs.erase(tab_iter);
 
         DVLOG(1) << "Moving tab " << tab_id << " from window "
                  << window_iter_pair.first << " to " << window_id;
         break;
       }
     }
     // TODO(zea): remove this once PutTabInWindow isn't crashing anymore.
     CHECK(tab) << " Unable to find tab " << tab_id
                << " within unmapped tabs or previously mapped windows."
                << " crbug.com/639009";
   }
 
   tab->window_id.set_id(window_id);
   DVLOG(1) << "  - tab " << tab_id << " added to window " << window_id;
   DCHECK(GetSession(session_tag)->windows.find(window_id) !=
          GetSession(session_tag)->windows.end());
-  auto& window_tabs = GetSession(session_tag)->windows[window_id]->tabs;
-  window_tabs.push_back(std::move(tab));
+  GetSession(session_tag)
+      ->windows[window_id]
+      ->wrapped_window.tabs.push_back(std::move(tab));
 }
 
 void SyncedSessionTracker::OnTabNodeSeen(const std::string& session_tag,
                                          int tab_node_id) {
   GetSession(session_tag)->tab_node_ids.insert(tab_node_id);
 }
 
 sessions::SessionTab* SyncedSessionTracker::GetTab(
     const std::string& session_tag,
     SessionID::id_type tab_id) {
@@ skipping 134 matching lines @@
   // Get rid of our convenience maps (does not delete the actual Window/Tabs
   // themselves; they should have all been deleted above).
   synced_window_map_.clear();
   synced_tab_map_.clear();
 
   local_tab_pool_.Clear();
   local_session_tag_.clear();
 }
 
 }  // namespace sync_sessions