1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/logging.h" 6 #include "base/stl_util.h" 7 #include "base/strings/utf_string_conversions.h" 8 #include "chrome/browser/sync/glue/synced_session_tracker.h" 9 10 namespace browser_sync { 11 12 SyncedSessionTracker::SyncedSessionTracker() { 13 } 14 15 SyncedSessionTracker::~SyncedSessionTracker() { 16 Clear(); 17 } 18 19 void SyncedSessionTracker::SetLocalSessionTag( 20 const std::string& local_session_tag) { 21 local_session_tag_ = local_session_tag; 22 } 23 24 bool SyncedSessionTracker::LookupAllForeignSessions( 25 std::vector<const SyncedSession*>* sessions) const { 26 DCHECK(sessions); 27 sessions->clear(); 28 // Fill vector of sessions from our synced session map. 29 for (SyncedSessionMap::const_iterator i = 30 synced_session_map_.begin(); i != synced_session_map_.end(); ++i) { 31 // Only include foreign sessions with open tabs. 32 SyncedSession* foreign_session = i->second; 33 if (i->first != local_session_tag_ && !foreign_session->windows.empty()) { 34 bool found_tabs = false; 35 for (SyncedSession::SyncedWindowMap::const_iterator iter = 36 foreign_session->windows.begin(); 37 iter != foreign_session->windows.end(); ++iter) { 38 if (!SessionWindowHasNoTabsToSync(*(iter->second))) { 39 found_tabs = true; 40 break; 41 } 42 } 43 if (found_tabs) 44 sessions->push_back(foreign_session); 45 } 46 } 47 48 return !sessions->empty(); 49 } 50 51 bool SyncedSessionTracker::LookupSessionWindows( 52 const std::string& session_tag, 53 std::vector<const SessionWindow*>* windows) const { 54 DCHECK(windows); 55 windows->clear(); 56 SyncedSessionMap::const_iterator iter = synced_session_map_.find(session_tag); 57 if (iter == synced_session_map_.end()) 58 return false; 59 windows->clear(); 60 for (SyncedSession::SyncedWindowMap::const_iterator window_iter = 61 iter->second->windows.begin(); 62 window_iter != iter->second->windows.end(); window_iter++) { 63 windows->push_back(window_iter->second); 64 } 65 return true; 66 } 67 68 bool SyncedSessionTracker::LookupSessionTab( 69 const std::string& tag, 70 SessionID::id_type tab_id, 71 const SessionTab** tab) const { 72 DCHECK(tab); 73 SyncedTabMap::const_iterator tab_map_iter = synced_tab_map_.find(tag); 74 if (tab_map_iter == synced_tab_map_.end()) { 75 // We have no record of this session. 76 *tab = NULL; 77 return false; 78 } 79 IDToSessionTabMap::const_iterator tab_iter = 80 tab_map_iter->second.find(tab_id); 81 if (tab_iter == tab_map_iter->second.end()) { 82 // We have no record of this tab. 83 *tab = NULL; 84 return false; 85 } 86 *tab = tab_iter->second.tab_ptr; 87 return true; 88 } 89 90 bool SyncedSessionTracker::LookupTabNodeIds( 91 const std::string& session_tag, std::set<int>* tab_node_ids) { 92 tab_node_ids->clear(); 93 SyncedTabMap::const_iterator tab_map_iter = 94 synced_tab_map_.find(session_tag); 95 if (tab_map_iter == synced_tab_map_.end()) 96 return false; 97 98 IDToSessionTabMap::const_iterator tab_iter = tab_map_iter->second.begin(); 99 while (tab_iter != tab_map_iter->second.end()) { 100 if (tab_iter->second.tab_node_id != TabNodePool::kInvalidTabNodeID) 101 tab_node_ids->insert(tab_iter->second.tab_node_id); 102 ++tab_iter; 103 } 104 return true; 105 } 106 107 SyncedSession* SyncedSessionTracker::GetSession( 108 const std::string& session_tag) { 109 SyncedSession* synced_session = NULL; 110 if (synced_session_map_.find(session_tag) != 111 synced_session_map_.end()) { 112 synced_session = synced_session_map_[session_tag]; 113 } else { 114 synced_session = new SyncedSession; 115 DVLOG(1) << "Creating new session with tag " << session_tag << " at " 116 << synced_session; 117 synced_session->session_tag = session_tag; 118 synced_session_map_[session_tag] = synced_session; 119 } 120 DCHECK(synced_session); 121 return synced_session; 122 } 123 124 bool SyncedSessionTracker::DeleteSession(const std::string& session_tag) { 125 bool found_session = false; 126 SyncedSessionMap::iterator iter = synced_session_map_.find(session_tag); 127 if (iter != synced_session_map_.end()) { 128 SyncedSession* session = iter->second; 129 synced_session_map_.erase(iter); 130 delete session; // Delete the SyncedSession object. 131 found_session = true; 132 } 133 synced_window_map_.erase(session_tag); 134 // It's possible there was no header node but there were tab nodes. 135 if (synced_tab_map_.erase(session_tag) > 0) { 136 found_session = true; 137 } 138 return found_session; 139 } 140 141 void SyncedSessionTracker::ResetSessionTracking( 142 const std::string& session_tag) { 143 // Reset window tracking. 144 GetSession(session_tag)->windows.clear(); 145 SyncedWindowMap::iterator window_iter = synced_window_map_.find(session_tag); 146 if (window_iter != synced_window_map_.end()) { 147 for (IDToSessionWindowMap::iterator window_map_iter = 148 window_iter->second.begin(); 149 window_map_iter != window_iter->second.end(); ++window_map_iter) { 150 window_map_iter->second.owned = false; 151 // We clear out the tabs to prevent double referencing of the same tab. 152 // All tabs that are in use will be added back as needed. 153 window_map_iter->second.window_ptr->tabs.clear(); 154 } 155 } 156 157 // Reset tab tracking. 158 SyncedTabMap::iterator tab_iter = synced_tab_map_.find(session_tag); 159 if (tab_iter != synced_tab_map_.end()) { 160 for (IDToSessionTabMap::iterator tab_map_iter = 161 tab_iter->second.begin(); 162 tab_map_iter != tab_iter->second.end(); ++tab_map_iter) { 163 tab_map_iter->second.owned = false; 164 } 165 } 166 } 167 168 bool SyncedSessionTracker::DeleteOldSessionWindowIfNecessary( 169 SessionWindowWrapper window_wrapper) { 170 // Clear the tabs first, since we don't want the destructor to destroy 171 // them. Their deletion will be handled by DeleteOldSessionTab below. 172 if (!window_wrapper.owned) { 173 DVLOG(1) << "Deleting closed window " 174 << window_wrapper.window_ptr->window_id.id(); 175 window_wrapper.window_ptr->tabs.clear(); 176 delete window_wrapper.window_ptr; 177 return true; 178 } 179 return false; 180 } 181 182 bool SyncedSessionTracker::DeleteOldSessionTabIfNecessary( 183 SessionTabWrapper tab_wrapper) { 184 if (!tab_wrapper.owned) { 185 if (VLOG_IS_ON(1)) { 186 SessionTab* tab_ptr = tab_wrapper.tab_ptr; 187 std::string title; 188 if (tab_ptr->navigations.size() > 0) { 189 title = " (" + UTF16ToUTF8( 190 tab_ptr->navigations[tab_ptr->navigations.size()-1].title()) + ")"; 191 } 192 DVLOG(1) << "Deleting closed tab " << tab_ptr->tab_id.id() << title 193 << " from window " << tab_ptr->window_id.id(); 194 } 195 unmapped_tabs_.erase(tab_wrapper.tab_ptr); 196 delete tab_wrapper.tab_ptr; 197 return true; 198 } 199 return false; 200 } 201 202 void SyncedSessionTracker::CleanupSession(const std::string& session_tag) { 203 // Go through and delete any windows or tabs without owners. 204 SyncedWindowMap::iterator window_iter = synced_window_map_.find(session_tag); 205 if (window_iter != synced_window_map_.end()) { 206 for (IDToSessionWindowMap::iterator iter = window_iter->second.begin(); 207 iter != window_iter->second.end();) { 208 SessionWindowWrapper window_wrapper = iter->second; 209 if (DeleteOldSessionWindowIfNecessary(window_wrapper)) 210 window_iter->second.erase(iter++); 211 else 212 ++iter; 213 } 214 } 215 216 SyncedTabMap::iterator tab_iter = synced_tab_map_.find(session_tag); 217 if (tab_iter != synced_tab_map_.end()) { 218 for (IDToSessionTabMap::iterator iter = tab_iter->second.begin(); 219 iter != tab_iter->second.end();) { 220 SessionTabWrapper tab_wrapper = iter->second; 221 if (DeleteOldSessionTabIfNecessary(tab_wrapper)) 222 tab_iter->second.erase(iter++); 223 else 224 ++iter; 225 } 226 } 227 } 228 229 void SyncedSessionTracker::PutWindowInSession(const std::string& session_tag, 230 SessionID::id_type window_id) { 231 SessionWindow* window_ptr = NULL; 232 IDToSessionWindowMap::iterator iter = 233 synced_window_map_[session_tag].find(window_id); 234 if (iter != synced_window_map_[session_tag].end()) { 235 iter->second.owned = true; 236 window_ptr = iter->second.window_ptr; 237 DVLOG(1) << "Putting seen window " << window_id << " at " << window_ptr 238 << "in " << (session_tag == local_session_tag_ ? 239 "local session" : session_tag); 240 } else { 241 // Create the window. 242 window_ptr = new SessionWindow(); 243 window_ptr->window_id.set_id(window_id); 244 synced_window_map_[session_tag][window_id] = 245 SessionWindowWrapper(window_ptr, IS_OWNED); 246 DVLOG(1) << "Putting new window " << window_id << " at " << window_ptr 247 << "in " << (session_tag == local_session_tag_ ? 248 "local session" : session_tag); 249 } 250 DCHECK(window_ptr); 251 DCHECK_EQ(window_ptr->window_id.id(), window_id); 252 DCHECK_EQ(reinterpret_cast<SessionWindow*>(NULL), 253 GetSession(session_tag)->windows[window_id]); 254 GetSession(session_tag)->windows[window_id] = window_ptr; 255 } 256 257 void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag, 258 SessionID::id_type window_id, 259 SessionID::id_type tab_id, 260 size_t tab_index) { 261 // We're called here for two reasons. 1) We've received an update to the 262 // SessionWindow information of a SessionHeader node for a foreign session, 263 // and 2) The SessionHeader node for our local session changed. In both cases 264 // we need to update our tracking state to reflect the change. 265 // 266 // Because the SessionHeader nodes are separate from the individual tab nodes 267 // and we don't store tab_node_ids in the header / SessionWindow specifics, 268 // the tab_node_ids are not always available when processing headers. 269 // We know that we will eventually process (via GetTab) every single tab node 270 // in the system, so we permit ourselves to use kInvalidTabNodeID here and 271 // rely on the later update to build the mapping (or a restart). 272 // TODO(tim): Bug 98892. Update comment when Sync API conversion finishes to 273 // mention that in the meantime, the only ill effect is that we may not be 274 // able to fully clean up a stale foreign session, but it will get garbage 275 // collected eventually. 276 SessionTab* tab_ptr = GetTabImpl( 277 session_tag, tab_id, TabNodePool::kInvalidTabNodeID); 278 unmapped_tabs_.erase(tab_ptr); 279 synced_tab_map_[session_tag][tab_id].owned = true; 280 tab_ptr->window_id.set_id(window_id); 281 DVLOG(1) << " - tab " << tab_id << " added to window "<< window_id; 282 DCHECK(GetSession(session_tag)->windows.find(window_id) != 283 GetSession(session_tag)->windows.end()); 284 std::vector<SessionTab*>& window_tabs = 285 GetSession(session_tag)->windows[window_id]->tabs; 286 if (window_tabs.size() <= tab_index) { 287 window_tabs.resize(tab_index+1, NULL); 288 } 289 DCHECK(!window_tabs[tab_index]); 290 window_tabs[tab_index] = tab_ptr; 291 } 292 293 SessionTab* SyncedSessionTracker::GetTab( 294 const std::string& session_tag, 295 SessionID::id_type tab_id, 296 int tab_node_id) { 297 DCHECK_NE(TabNodePool::kInvalidTabNodeID, tab_node_id); 298 return GetTabImpl(session_tag, tab_id, tab_node_id); 299 } 300 301 SessionTab* SyncedSessionTracker::GetTabImpl( 302 const std::string& session_tag, 303 SessionID::id_type tab_id, 304 int tab_node_id) { 305 SessionTab* tab_ptr = NULL; 306 IDToSessionTabMap::iterator iter = 307 synced_tab_map_[session_tag].find(tab_id); 308 if (iter != synced_tab_map_[session_tag].end()) { 309 tab_ptr = iter->second.tab_ptr; 310 if (tab_node_id != TabNodePool::kInvalidTabNodeID && 311 tab_id != TabNodePool::kInvalidTabID) { 312 // We likely created this tab as an out-of-order update to the header 313 // node for this session before actually associating the tab itself, so 314 // the tab node id wasn't available at the time. Update it. 315 316 if (iter->second.tab_node_id != tab_node_id && 317 iter->second.tab_node_id != TabNodePool::kInvalidTabNodeID) { 318 // We are updating tab_node_id for a valid tab_id, ideally this should 319 // never happen, but there are a few existing foreign sessions that 320 // may violate this constraint. 321 // TODO(shashishekhar): Introduce a DCHECK here to enforce this 322 // constraint in future. 323 DLOG(ERROR) 324 << "Updating tab_node_id for " << session_tag << " tab: " << tab_id 325 << " from: " << iter->second.tab_node_id << " to: " << tab_node_id; 326 } 327 iter->second.tab_node_id = tab_node_id; 328 } 329 330 if (VLOG_IS_ON(1)) { 331 std::string title; 332 if (tab_ptr->navigations.size() > 0) { 333 title = " (" + UTF16ToUTF8( 334 tab_ptr->navigations[tab_ptr->navigations.size()-1].title()) + ")"; 335 } 336 DVLOG(1) << "Getting " 337 << (session_tag == local_session_tag_ ? 338 "local session" : session_tag) 339 << "'s seen tab " << tab_id << " at " << tab_ptr << title; 340 } 341 } else { 342 tab_ptr = new SessionTab(); 343 tab_ptr->tab_id.set_id(tab_id); 344 synced_tab_map_[session_tag][tab_id] = SessionTabWrapper(tab_ptr, 345 NOT_OWNED, 346 tab_node_id); 347 unmapped_tabs_.insert(tab_ptr); 348 DVLOG(1) << "Getting " 349 << (session_tag == local_session_tag_ ? 350 "local session" : session_tag) 351 << "'s new tab " << tab_id << " at " << tab_ptr; 352 } 353 DCHECK(tab_ptr); 354 DCHECK_EQ(tab_ptr->tab_id.id(), tab_id); 355 return tab_ptr; 356 } 357 358 void SyncedSessionTracker::Clear() { 359 // Delete SyncedSession objects (which also deletes all their windows/tabs). 360 STLDeleteValues(&synced_session_map_); 361 362 // Go through and delete any tabs we had allocated but had not yet placed into 363 // a SyncedSessionobject. 364 STLDeleteElements(&unmapped_tabs_); 365 366 // Get rid of our Window/Tab maps (does not delete the actual Window/Tabs 367 // themselves; they should have all been deleted above). 368 synced_window_map_.clear(); 369 synced_tab_map_.clear(); 370 371 local_session_tag_.clear(); 372 } 373 374 } // namespace browser_sync 375
