1 // Copyright 2014 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 "chrome/browser/sync/sessions/sessions_sync_manager.h" 6 7 #include "chrome/browser/chrome_notification_types.h" 8 #include "chrome/browser/profiles/profile.h" 9 #include "chrome/browser/sync/glue/synced_tab_delegate.h" 10 #include "chrome/browser/sync/glue/synced_window_delegate.h" 11 #include "chrome/browser/sync/sessions/sessions_util.h" 12 #include "chrome/browser/sync/sessions/synced_window_delegates_getter.h" 13 #include "chrome/common/url_constants.h" 14 #include "components/sync_driver/local_device_info_provider.h" 15 #include "content/public/browser/favicon_status.h" 16 #include "content/public/browser/navigation_entry.h" 17 #include "content/public/browser/notification_details.h" 18 #include "content/public/browser/notification_service.h" 19 #include "content/public/browser/notification_source.h" 20 #include "content/public/common/url_constants.h" 21 #include "sync/api/sync_error.h" 22 #include "sync/api/sync_error_factory.h" 23 #include "sync/api/sync_merge_result.h" 24 #include "sync/api/time.h" 25 26 using content::NavigationEntry; 27 using sessions::SerializedNavigationEntry; 28 using sync_driver::DeviceInfo; 29 using sync_driver::LocalDeviceInfoProvider; 30 using syncer::SyncChange; 31 using syncer::SyncData; 32 33 namespace browser_sync { 34 35 // Maximum number of favicons to sync. 36 // TODO(zea): pull this from the server. 37 static const int kMaxSyncFavicons = 200; 38 39 // The maximum number of navigations in each direction we care to sync. 40 static const int kMaxSyncNavigationCount = 6; 41 42 // The URL at which the set of synced tabs is displayed. We treat it differently 43 // from all other URL's as accessing it triggers a sync refresh of Sessions. 44 static const char kNTPOpenTabSyncURL[] = "chrome://newtab/#open_tabs"; 45 46 // Default number of days without activity after which a session is considered 47 // stale and becomes a candidate for garbage collection. 48 static const size_t kDefaultStaleSessionThresholdDays = 14; // 2 weeks. 49 50 // |local_device| is owned by ProfileSyncService, its lifetime exceeds 51 // lifetime of SessionSyncManager. 52 SessionsSyncManager::SessionsSyncManager( 53 Profile* profile, 54 LocalDeviceInfoProvider* local_device, 55 scoped_ptr<LocalSessionEventRouter> router) 56 : favicon_cache_(profile, kMaxSyncFavicons), 57 local_tab_pool_out_of_sync_(true), 58 sync_prefs_(profile->GetPrefs()), 59 profile_(profile), 60 local_device_(local_device), 61 local_session_header_node_id_(TabNodePool::kInvalidTabNodeID), 62 stale_session_threshold_days_(kDefaultStaleSessionThresholdDays), 63 local_event_router_(router.Pass()), 64 synced_window_getter_(new SyncedWindowDelegatesGetter()) { 65 } 66 67 LocalSessionEventRouter::~LocalSessionEventRouter() {} 68 69 SessionsSyncManager::~SessionsSyncManager() { 70 } 71 72 // Returns the GUID-based string that should be used for 73 // |SessionsSyncManager::current_machine_tag_|. 74 static std::string BuildMachineTag(const std::string& cache_guid) { 75 std::string machine_tag = "session_sync"; 76 machine_tag.append(cache_guid); 77 return machine_tag; 78 } 79 80 syncer::SyncMergeResult SessionsSyncManager::MergeDataAndStartSyncing( 81 syncer::ModelType type, 82 const syncer::SyncDataList& initial_sync_data, 83 scoped_ptr<syncer::SyncChangeProcessor> sync_processor, 84 scoped_ptr<syncer::SyncErrorFactory> error_handler) { 85 syncer::SyncMergeResult merge_result(type); 86 DCHECK(session_tracker_.Empty()); 87 DCHECK_EQ(0U, local_tab_pool_.Capacity()); 88 89 error_handler_ = error_handler.Pass(); 90 sync_processor_ = sync_processor.Pass(); 91 92 local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID; 93 94 // Make sure we have a machine tag. We do this now (versus earlier) as it's 95 // a conveniently safe time to assert sync is ready and the cache_guid is 96 // initialized. 97 if (current_machine_tag_.empty()) { 98 InitializeCurrentMachineTag(); 99 } 100 101 // SessionDataTypeController ensures that the local device info 102 // is available before activating this datatype. 103 DCHECK(local_device_); 104 const DeviceInfo* local_device_info = local_device_->GetLocalDeviceInfo(); 105 if (local_device_info) { 106 current_session_name_ = local_device_info->client_name(); 107 } else { 108 merge_result.set_error(error_handler_->CreateAndUploadError( 109 FROM_HERE, 110 "Failed to get local device info.")); 111 return merge_result; 112 } 113 114 session_tracker_.SetLocalSessionTag(current_machine_tag_); 115 116 syncer::SyncChangeList new_changes; 117 118 // First, we iterate over sync data to update our session_tracker_. 119 syncer::SyncDataList restored_tabs; 120 if (!InitFromSyncModel(initial_sync_data, &restored_tabs, &new_changes)) { 121 // The sync db didn't have a header node for us. Create one. 122 sync_pb::EntitySpecifics specifics; 123 sync_pb::SessionSpecifics* base_specifics = specifics.mutable_session(); 124 base_specifics->set_session_tag(current_machine_tag()); 125 sync_pb::SessionHeader* header_s = base_specifics->mutable_header(); 126 header_s->set_client_name(current_session_name_); 127 header_s->set_device_type(local_device_info->device_type()); 128 syncer::SyncData data = syncer::SyncData::CreateLocalData( 129 current_machine_tag(), current_session_name_, specifics); 130 new_changes.push_back(syncer::SyncChange( 131 FROM_HERE, syncer::SyncChange::ACTION_ADD, data)); 132 } 133 134 #if defined(OS_ANDROID) 135 std::string sync_machine_tag(BuildMachineTag( 136 local_device_->GetLocalSyncCacheGUID())); 137 if (current_machine_tag_.compare(sync_machine_tag) != 0) 138 DeleteForeignSessionInternal(sync_machine_tag, &new_changes); 139 #endif 140 141 // Check if anything has changed on the local client side. 142 AssociateWindows(RELOAD_TABS, restored_tabs, &new_changes); 143 local_tab_pool_out_of_sync_ = false; 144 145 merge_result.set_error( 146 sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes)); 147 148 local_event_router_->StartRoutingTo(this); 149 return merge_result; 150 } 151 152 void SessionsSyncManager::AssociateWindows( 153 ReloadTabsOption option, 154 const syncer::SyncDataList& restored_tabs, 155 syncer::SyncChangeList* change_output) { 156 const std::string local_tag = current_machine_tag(); 157 sync_pb::SessionSpecifics specifics; 158 specifics.set_session_tag(local_tag); 159 sync_pb::SessionHeader* header_s = specifics.mutable_header(); 160 SyncedSession* current_session = session_tracker_.GetSession(local_tag); 161 current_session->modified_time = base::Time::Now(); 162 header_s->set_client_name(current_session_name_); 163 // SessionDataTypeController ensures that the local device info 164 // is available before activating this datatype. 165 DCHECK(local_device_); 166 const DeviceInfo* local_device_info = local_device_->GetLocalDeviceInfo(); 167 header_s->set_device_type(local_device_info->device_type()); 168 169 session_tracker_.ResetSessionTracking(local_tag); 170 std::set<SyncedWindowDelegate*> windows = 171 synced_window_getter_->GetSyncedWindowDelegates(); 172 173 for (std::set<SyncedWindowDelegate*>::const_iterator i = 174 windows.begin(); i != windows.end(); ++i) { 175 // Make sure the window has tabs and a viewable window. The viewable window 176 // check is necessary because, for example, when a browser is closed the 177 // destructor is not necessarily run immediately. This means its possible 178 // for us to get a handle to a browser that is about to be removed. If 179 // the tab count is 0 or the window is NULL, the browser is about to be 180 // deleted, so we ignore it. 181 if (sessions_util::ShouldSyncWindow(*i) && 182 (*i)->GetTabCount() && (*i)->HasWindow()) { 183 sync_pb::SessionWindow window_s; 184 SessionID::id_type window_id = (*i)->GetSessionId(); 185 DVLOG(1) << "Associating window " << window_id << " with " 186 << (*i)->GetTabCount() << " tabs."; 187 window_s.set_window_id(window_id); 188 // Note: We don't bother to set selected tab index anymore. We still 189 // consume it when receiving foreign sessions, as reading it is free, but 190 // it triggers too many sync cycles with too little value to make setting 191 // it worthwhile. 192 if ((*i)->IsTypeTabbed()) { 193 window_s.set_browser_type( 194 sync_pb::SessionWindow_BrowserType_TYPE_TABBED); 195 } else { 196 window_s.set_browser_type( 197 sync_pb::SessionWindow_BrowserType_TYPE_POPUP); 198 } 199 200 bool found_tabs = false; 201 for (int j = 0; j < (*i)->GetTabCount(); ++j) { 202 SessionID::id_type tab_id = (*i)->GetTabIdAt(j); 203 SyncedTabDelegate* synced_tab = (*i)->GetTabAt(j); 204 205 // GetTabAt can return a null tab; in that case just skip it. 206 if (!synced_tab) 207 continue; 208 209 if (!synced_tab->HasWebContents()) { 210 // For tabs without WebContents update the |tab_id|, as it could have 211 // changed after a session restore. 212 // Note: We cannot check if a tab is valid if it has no WebContents. 213 // We assume any such tab is valid and leave the contents of 214 // corresponding sync node unchanged. 215 if (synced_tab->GetSyncId() > TabNodePool::kInvalidTabNodeID && 216 tab_id > TabNodePool::kInvalidTabID) { 217 AssociateRestoredPlaceholderTab(*synced_tab, tab_id, 218 restored_tabs, change_output); 219 found_tabs = true; 220 window_s.add_tab(tab_id); 221 } 222 continue; 223 } 224 225 if (RELOAD_TABS == option) 226 AssociateTab(synced_tab, change_output); 227 228 // If the tab is valid, it would have been added to the tracker either 229 // by the above AssociateTab call (at association time), or by the 230 // change processor calling AssociateTab for all modified tabs. 231 // Therefore, we can key whether this window has valid tabs based on 232 // the tab's presence in the tracker. 233 const SessionTab* tab = NULL; 234 if (session_tracker_.LookupSessionTab(local_tag, tab_id, &tab)) { 235 found_tabs = true; 236 window_s.add_tab(tab_id); 237 } 238 } 239 if (found_tabs) { 240 sync_pb::SessionWindow* header_window = header_s->add_window(); 241 *header_window = window_s; 242 243 // Update this window's representation in the synced session tracker. 244 session_tracker_.PutWindowInSession(local_tag, window_id); 245 BuildSyncedSessionFromSpecifics(local_tag, 246 window_s, 247 current_session->modified_time, 248 current_session->windows[window_id]); 249 } 250 } 251 } 252 local_tab_pool_.DeleteUnassociatedTabNodes(change_output); 253 session_tracker_.CleanupSession(local_tag); 254 255 // Always update the header. Sync takes care of dropping this update 256 // if the entity specifics are identical (i.e windows, client name did 257 // not change). 258 sync_pb::EntitySpecifics entity; 259 entity.mutable_session()->CopyFrom(specifics); 260 syncer::SyncData data = syncer::SyncData::CreateLocalData( 261 current_machine_tag(), current_session_name_, entity); 262 change_output->push_back(syncer::SyncChange( 263 FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data)); 264 } 265 266 void SessionsSyncManager::AssociateTab(SyncedTabDelegate* const tab, 267 syncer::SyncChangeList* change_output) { 268 DCHECK(tab->HasWebContents()); 269 SessionID::id_type tab_id = tab->GetSessionId(); 270 if (tab->profile() != profile_) 271 return; 272 273 if (tab->IsBeingDestroyed()) { 274 // This tab is closing. 275 TabLinksMap::iterator tab_iter = local_tab_map_.find(tab_id); 276 if (tab_iter == local_tab_map_.end()) { 277 // We aren't tracking this tab (for example, sync setting page). 278 return; 279 } 280 local_tab_pool_.FreeTabNode(tab_iter->second->tab_node_id(), 281 change_output); 282 local_tab_map_.erase(tab_iter); 283 return; 284 } 285 286 if (!sessions_util::ShouldSyncTab(*tab)) 287 return; 288 289 TabLinksMap::iterator local_tab_map_iter = local_tab_map_.find(tab_id); 290 TabLink* tab_link = NULL; 291 292 if (local_tab_map_iter == local_tab_map_.end()) { 293 int tab_node_id = tab->GetSyncId(); 294 // If there is an old sync node for the tab, reuse it. If this is a new 295 // tab, get a sync node for it. 296 if (!local_tab_pool_.IsUnassociatedTabNode(tab_node_id)) { 297 tab_node_id = local_tab_pool_.GetFreeTabNode(change_output); 298 tab->SetSyncId(tab_node_id); 299 } 300 local_tab_pool_.AssociateTabNode(tab_node_id, tab_id); 301 tab_link = new TabLink(tab_node_id, tab); 302 local_tab_map_[tab_id] = make_linked_ptr<TabLink>(tab_link); 303 } else { 304 // This tab is already associated with a sync node, reuse it. 305 // Note: on some platforms the tab object may have changed, so we ensure 306 // the tab link is up to date. 307 tab_link = local_tab_map_iter->second.get(); 308 local_tab_map_iter->second->set_tab(tab); 309 } 310 DCHECK(tab_link); 311 DCHECK_NE(tab_link->tab_node_id(), TabNodePool::kInvalidTabNodeID); 312 DVLOG(1) << "Reloading tab " << tab_id << " from window " 313 << tab->GetWindowId(); 314 315 // Write to sync model. 316 sync_pb::EntitySpecifics specifics; 317 LocalTabDelegateToSpecifics(*tab, specifics.mutable_session()); 318 syncer::SyncData data = syncer::SyncData::CreateLocalData( 319 TabNodePool::TabIdToTag(current_machine_tag_, 320 tab_link->tab_node_id()), 321 current_session_name_, 322 specifics); 323 change_output->push_back(syncer::SyncChange( 324 FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data)); 325 326 const GURL new_url = GetCurrentVirtualURL(*tab); 327 if (new_url != tab_link->url()) { 328 tab_link->set_url(new_url); 329 favicon_cache_.OnFaviconVisited(new_url, GetCurrentFaviconURL(*tab)); 330 } 331 332 session_tracker_.GetSession(current_machine_tag())->modified_time = 333 base::Time::Now(); 334 } 335 336 void SessionsSyncManager::RebuildAssociations() { 337 syncer::SyncDataList data( 338 sync_processor_->GetAllSyncData(syncer::SESSIONS)); 339 scoped_ptr<syncer::SyncErrorFactory> error_handler(error_handler_.Pass()); 340 scoped_ptr<syncer::SyncChangeProcessor> processor(sync_processor_.Pass()); 341 342 StopSyncing(syncer::SESSIONS); 343 MergeDataAndStartSyncing( 344 syncer::SESSIONS, data, processor.Pass(), error_handler.Pass()); 345 } 346 347 bool SessionsSyncManager::IsValidSessionHeader( 348 const sync_pb::SessionHeader& header) { 349 // Verify that tab IDs appear only once within a session. 350 // Intended to prevent http://crbug.com/360822. 351 std::set<int> session_tab_ids; 352 for (int i = 0; i < header.window_size(); ++i) { 353 const sync_pb::SessionWindow& window = header.window(i); 354 for (int j = 0; j < window.tab_size(); ++j) { 355 const int tab_id = window.tab(j); 356 bool success = session_tab_ids.insert(tab_id).second; 357 if (!success) 358 return false; 359 } 360 } 361 362 return true; 363 } 364 365 void SessionsSyncManager::OnLocalTabModified(SyncedTabDelegate* modified_tab) { 366 const content::NavigationEntry* entry = modified_tab->GetActiveEntry(); 367 if (!modified_tab->IsBeingDestroyed() && 368 entry && 369 entry->GetVirtualURL().is_valid() && 370 entry->GetVirtualURL().spec() == kNTPOpenTabSyncURL) { 371 DVLOG(1) << "Triggering sync refresh for sessions datatype."; 372 const syncer::ModelTypeSet types(syncer::SESSIONS); 373 content::NotificationService::current()->Notify( 374 chrome::NOTIFICATION_SYNC_REFRESH_LOCAL, 375 content::Source<Profile>(profile_), 376 content::Details<const syncer::ModelTypeSet>(&types)); 377 } 378 379 if (local_tab_pool_out_of_sync_) { 380 // If our tab pool is corrupt, pay the price of a full re-association to 381 // fix things up. This takes care of the new tab modification as well. 382 RebuildAssociations(); 383 DCHECK(!local_tab_pool_out_of_sync_); 384 return; 385 } 386 387 syncer::SyncChangeList changes; 388 // Associate tabs first so the synced session tracker is aware of them. 389 AssociateTab(modified_tab, &changes); 390 // Note, we always associate windows because it's possible a tab became 391 // "interesting" by going to a valid URL, in which case it needs to be added 392 // to the window's tab information. 393 AssociateWindows(DONT_RELOAD_TABS, syncer::SyncDataList(), &changes); 394 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); 395 } 396 397 void SessionsSyncManager::OnFaviconPageUrlsUpdated( 398 const std::set<GURL>& updated_favicon_page_urls) { 399 // TODO(zea): consider a separate container for tabs with outstanding favicon 400 // loads so we don't have to iterate through all tabs comparing urls. 401 for (std::set<GURL>::const_iterator i = updated_favicon_page_urls.begin(); 402 i != updated_favicon_page_urls.end(); ++i) { 403 for (TabLinksMap::iterator tab_iter = local_tab_map_.begin(); 404 tab_iter != local_tab_map_.end(); 405 ++tab_iter) { 406 if (tab_iter->second->url() == *i) 407 favicon_cache_.OnPageFaviconUpdated(*i); 408 } 409 } 410 } 411 412 void SessionsSyncManager::StopSyncing(syncer::ModelType type) { 413 local_event_router_->Stop(); 414 sync_processor_.reset(NULL); 415 error_handler_.reset(); 416 session_tracker_.Clear(); 417 local_tab_map_.clear(); 418 local_tab_pool_.Clear(); 419 current_machine_tag_.clear(); 420 current_session_name_.clear(); 421 local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID; 422 } 423 424 syncer::SyncDataList SessionsSyncManager::GetAllSyncData( 425 syncer::ModelType type) const { 426 syncer::SyncDataList list; 427 const SyncedSession* session = NULL; 428 if (!session_tracker_.LookupLocalSession(&session)) 429 return syncer::SyncDataList(); 430 431 // First construct the header node. 432 sync_pb::EntitySpecifics header_entity; 433 header_entity.mutable_session()->set_session_tag(current_machine_tag()); 434 sync_pb::SessionHeader* header_specifics = 435 header_entity.mutable_session()->mutable_header(); 436 header_specifics->MergeFrom(session->ToSessionHeader()); 437 syncer::SyncData data = syncer::SyncData::CreateLocalData( 438 current_machine_tag(), current_session_name_, header_entity); 439 list.push_back(data); 440 441 SyncedSession::SyncedWindowMap::const_iterator win_iter; 442 for (win_iter = session->windows.begin(); 443 win_iter != session->windows.end(); ++win_iter) { 444 std::vector<SessionTab*>::const_iterator tabs_iter; 445 for (tabs_iter = win_iter->second->tabs.begin(); 446 tabs_iter != win_iter->second->tabs.end(); ++tabs_iter) { 447 sync_pb::EntitySpecifics entity; 448 sync_pb::SessionSpecifics* specifics = entity.mutable_session(); 449 specifics->mutable_tab()->MergeFrom((*tabs_iter)->ToSyncData()); 450 specifics->set_session_tag(current_machine_tag_); 451 452 TabLinksMap::const_iterator tab_map_iter = local_tab_map_.find( 453 (*tabs_iter)->tab_id.id()); 454 DCHECK(tab_map_iter != local_tab_map_.end()); 455 specifics->set_tab_node_id(tab_map_iter->second->tab_node_id()); 456 syncer::SyncData data = syncer::SyncData::CreateLocalData( 457 TabNodePool::TabIdToTag(current_machine_tag_, 458 specifics->tab_node_id()), 459 current_session_name_, 460 entity); 461 list.push_back(data); 462 } 463 } 464 return list; 465 } 466 467 bool SessionsSyncManager::GetLocalSession( 468 const SyncedSession* * local_session) { 469 if (current_machine_tag_.empty()) 470 return false; 471 *local_session = session_tracker_.GetSession(current_machine_tag()); 472 return true; 473 } 474 475 syncer::SyncError SessionsSyncManager::ProcessSyncChanges( 476 const tracked_objects::Location& from_here, 477 const syncer::SyncChangeList& change_list) { 478 if (!sync_processor_.get()) { 479 syncer::SyncError error(FROM_HERE, 480 syncer::SyncError::DATATYPE_ERROR, 481 "Models not yet associated.", 482 syncer::SESSIONS); 483 return error; 484 } 485 486 for (syncer::SyncChangeList::const_iterator it = change_list.begin(); 487 it != change_list.end(); ++it) { 488 DCHECK(it->IsValid()); 489 DCHECK(it->sync_data().GetSpecifics().has_session()); 490 const sync_pb::SessionSpecifics& session = 491 it->sync_data().GetSpecifics().session(); 492 switch (it->change_type()) { 493 case syncer::SyncChange::ACTION_DELETE: 494 // Deletions are all or nothing (since we only ever delete entire 495 // sessions). Therefore we don't care if it's a tab node or meta node, 496 // and just ensure we've disassociated. 497 if (current_machine_tag() == session.session_tag()) { 498 // Another client has attempted to delete our local data (possibly by 499 // error or a clock is inaccurate). Just ignore the deletion for now 500 // to avoid any possible ping-pong delete/reassociate sequence, but 501 // remember that this happened as our TabNodePool is inconsistent. 502 local_tab_pool_out_of_sync_ = true; 503 LOG(WARNING) << "Local session data deleted. Ignoring until next " 504 << "local navigation event."; 505 } else if (session.has_header()) { 506 // Disassociate only when header node is deleted. For tab node 507 // deletions, the header node will be updated and foreign tab will 508 // get deleted. 509 DisassociateForeignSession(session.session_tag()); 510 } 511 continue; 512 case syncer::SyncChange::ACTION_ADD: 513 case syncer::SyncChange::ACTION_UPDATE: 514 if (current_machine_tag() == session.session_tag()) { 515 // We should only ever receive a change to our own machine's session 516 // info if encryption was turned on. In that case, the data is still 517 // the same, so we can ignore. 518 LOG(WARNING) << "Dropping modification to local session."; 519 return syncer::SyncError(); 520 } 521 UpdateTrackerWithForeignSession( 522 session, syncer::SyncDataRemote(it->sync_data()).GetModifiedTime()); 523 break; 524 default: 525 NOTREACHED() << "Processing sync changes failed, unknown change type."; 526 } 527 } 528 529 content::NotificationService::current()->Notify( 530 chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED, 531 content::Source<Profile>(profile_), 532 content::NotificationService::NoDetails()); 533 return syncer::SyncError(); 534 } 535 536 syncer::SyncChange SessionsSyncManager::TombstoneTab( 537 const sync_pb::SessionSpecifics& tab) { 538 if (!tab.has_tab_node_id()) { 539 LOG(WARNING) << "Old sessions node without tab node id; can't tombstone."; 540 return syncer::SyncChange(); 541 } else { 542 return syncer::SyncChange( 543 FROM_HERE, 544 SyncChange::ACTION_DELETE, 545 SyncData::CreateLocalDelete( 546 TabNodePool::TabIdToTag(current_machine_tag(), 547 tab.tab_node_id()), 548 syncer::SESSIONS)); 549 } 550 } 551 552 bool SessionsSyncManager::GetAllForeignSessions( 553 std::vector<const SyncedSession*>* sessions) { 554 return session_tracker_.LookupAllForeignSessions(sessions); 555 } 556 557 bool SessionsSyncManager::InitFromSyncModel( 558 const syncer::SyncDataList& sync_data, 559 syncer::SyncDataList* restored_tabs, 560 syncer::SyncChangeList* new_changes) { 561 bool found_current_header = false; 562 for (syncer::SyncDataList::const_iterator it = sync_data.begin(); 563 it != sync_data.end(); 564 ++it) { 565 const syncer::SyncData& data = *it; 566 DCHECK(data.GetSpecifics().has_session()); 567 const sync_pb::SessionSpecifics& specifics = data.GetSpecifics().session(); 568 if (specifics.session_tag().empty() || 569 (specifics.has_tab() && (!specifics.has_tab_node_id() || 570 !specifics.tab().has_tab_id()))) { 571 syncer::SyncChange tombstone(TombstoneTab(specifics)); 572 if (tombstone.IsValid()) 573 new_changes->push_back(tombstone); 574 } else if (specifics.session_tag() != current_machine_tag()) { 575 UpdateTrackerWithForeignSession( 576 specifics, syncer::SyncDataRemote(data).GetModifiedTime()); 577 } else { 578 // This is previously stored local session information. 579 if (specifics.has_header() && !found_current_header) { 580 // This is our previous header node, reuse it. 581 found_current_header = true; 582 if (specifics.header().has_client_name()) 583 current_session_name_ = specifics.header().client_name(); 584 } else { 585 if (specifics.has_header() || !specifics.has_tab()) { 586 LOG(WARNING) << "Found more than one session header node with local " 587 << "tag."; 588 syncer::SyncChange tombstone(TombstoneTab(specifics)); 589 if (tombstone.IsValid()) 590 new_changes->push_back(tombstone); 591 } else { 592 // This is a valid old tab node, add it to the pool so it can be 593 // reused for reassociation. 594 local_tab_pool_.AddTabNode(specifics.tab_node_id()); 595 restored_tabs->push_back(*it); 596 } 597 } 598 } 599 } 600 return found_current_header; 601 } 602 603 void SessionsSyncManager::UpdateTrackerWithForeignSession( 604 const sync_pb::SessionSpecifics& specifics, 605 const base::Time& modification_time) { 606 std::string foreign_session_tag = specifics.session_tag(); 607 DCHECK_NE(foreign_session_tag, current_machine_tag()); 608 609 SyncedSession* foreign_session = 610 session_tracker_.GetSession(foreign_session_tag); 611 if (specifics.has_header()) { 612 // Read in the header data for this foreign session. 613 // Header data contains window information and ordered tab id's for each 614 // window. 615 616 if (!IsValidSessionHeader(specifics.header())) { 617 LOG(WARNING) << "Ignoring foreign session node with invalid header " 618 << "and tag " << foreign_session_tag << "."; 619 return; 620 } 621 622 // Load (or create) the SyncedSession object for this client. 623 const sync_pb::SessionHeader& header = specifics.header(); 624 PopulateSessionHeaderFromSpecifics(header, 625 modification_time, 626 foreign_session); 627 628 // Reset the tab/window tracking for this session (must do this before 629 // we start calling PutWindowInSession and PutTabInWindow so that all 630 // unused tabs/windows get cleared by the CleanupSession(...) call). 631 session_tracker_.ResetSessionTracking(foreign_session_tag); 632 633 // Process all the windows and their tab information. 634 int num_windows = header.window_size(); 635 DVLOG(1) << "Associating " << foreign_session_tag << " with " 636 << num_windows << " windows."; 637 638 for (int i = 0; i < num_windows; ++i) { 639 const sync_pb::SessionWindow& window_s = header.window(i); 640 SessionID::id_type window_id = window_s.window_id(); 641 session_tracker_.PutWindowInSession(foreign_session_tag, 642 window_id); 643 BuildSyncedSessionFromSpecifics(foreign_session_tag, 644 window_s, 645 modification_time, 646 foreign_session->windows[window_id]); 647 } 648 // Delete any closed windows and unused tabs as necessary. 649 session_tracker_.CleanupSession(foreign_session_tag); 650 } else if (specifics.has_tab()) { 651 const sync_pb::SessionTab& tab_s = specifics.tab(); 652 SessionID::id_type tab_id = tab_s.tab_id(); 653 SessionTab* tab = 654 session_tracker_.GetTab(foreign_session_tag, 655 tab_id, 656 specifics.tab_node_id()); 657 658 // Update SessionTab based on protobuf. 659 tab->SetFromSyncData(tab_s, modification_time); 660 661 // If a favicon or favicon urls are present, load the URLs and visit 662 // times into the in-memory favicon cache. 663 RefreshFaviconVisitTimesFromForeignTab(tab_s, modification_time); 664 665 // Update the last modified time. 666 if (foreign_session->modified_time < modification_time) 667 foreign_session->modified_time = modification_time; 668 } else { 669 LOG(WARNING) << "Ignoring foreign session node with missing header/tab " 670 << "fields and tag " << foreign_session_tag << "."; 671 } 672 } 673 674 void SessionsSyncManager::InitializeCurrentMachineTag() { 675 DCHECK(current_machine_tag_.empty()); 676 std::string persisted_guid; 677 persisted_guid = sync_prefs_.GetSyncSessionsGUID(); 678 if (!persisted_guid.empty()) { 679 current_machine_tag_ = persisted_guid; 680 DVLOG(1) << "Restoring persisted session sync guid: " << persisted_guid; 681 } else { 682 DCHECK(local_device_); 683 std::string cache_guid = local_device_->GetLocalSyncCacheGUID(); 684 DCHECK(!cache_guid.empty()); 685 current_machine_tag_ = BuildMachineTag(cache_guid); 686 DVLOG(1) << "Creating session sync guid: " << current_machine_tag_; 687 sync_prefs_.SetSyncSessionsGUID(current_machine_tag_); 688 } 689 690 local_tab_pool_.SetMachineTag(current_machine_tag_); 691 } 692 693 // static 694 void SessionsSyncManager::PopulateSessionHeaderFromSpecifics( 695 const sync_pb::SessionHeader& header_specifics, 696 base::Time mtime, 697 SyncedSession* session_header) { 698 if (header_specifics.has_client_name()) 699 session_header->session_name = header_specifics.client_name(); 700 if (header_specifics.has_device_type()) { 701 switch (header_specifics.device_type()) { 702 case sync_pb::SyncEnums_DeviceType_TYPE_WIN: 703 session_header->device_type = SyncedSession::TYPE_WIN; 704 break; 705 case sync_pb::SyncEnums_DeviceType_TYPE_MAC: 706 session_header->device_type = SyncedSession::TYPE_MACOSX; 707 break; 708 case sync_pb::SyncEnums_DeviceType_TYPE_LINUX: 709 session_header->device_type = SyncedSession::TYPE_LINUX; 710 break; 711 case sync_pb::SyncEnums_DeviceType_TYPE_CROS: 712 session_header->device_type = SyncedSession::TYPE_CHROMEOS; 713 break; 714 case sync_pb::SyncEnums_DeviceType_TYPE_PHONE: 715 session_header->device_type = SyncedSession::TYPE_PHONE; 716 break; 717 case sync_pb::SyncEnums_DeviceType_TYPE_TABLET: 718 session_header->device_type = SyncedSession::TYPE_TABLET; 719 break; 720 case sync_pb::SyncEnums_DeviceType_TYPE_OTHER: 721 // Intentionally fall-through 722 default: 723 session_header->device_type = SyncedSession::TYPE_OTHER; 724 break; 725 } 726 } 727 session_header->modified_time = mtime; 728 } 729 730 // static 731 void SessionsSyncManager::BuildSyncedSessionFromSpecifics( 732 const std::string& session_tag, 733 const sync_pb::SessionWindow& specifics, 734 base::Time mtime, 735 SessionWindow* session_window) { 736 if (specifics.has_window_id()) 737 session_window->window_id.set_id(specifics.window_id()); 738 if (specifics.has_selected_tab_index()) 739 session_window->selected_tab_index = specifics.selected_tab_index(); 740 if (specifics.has_browser_type()) { 741 if (specifics.browser_type() == 742 sync_pb::SessionWindow_BrowserType_TYPE_TABBED) { 743 session_window->type = 1; 744 } else { 745 session_window->type = 2; 746 } 747 } 748 session_window->timestamp = mtime; 749 session_window->tabs.resize(specifics.tab_size(), NULL); 750 for (int i = 0; i < specifics.tab_size(); i++) { 751 SessionID::id_type tab_id = specifics.tab(i); 752 session_tracker_.PutTabInWindow(session_tag, 753 session_window->window_id.id(), 754 tab_id, 755 i); 756 } 757 } 758 759 void SessionsSyncManager::RefreshFaviconVisitTimesFromForeignTab( 760 const sync_pb::SessionTab& tab, const base::Time& modification_time) { 761 // First go through and iterate over all the navigations, checking if any 762 // have valid favicon urls. 763 for (int i = 0; i < tab.navigation_size(); ++i) { 764 if (!tab.navigation(i).favicon_url().empty()) { 765 const std::string& page_url = tab.navigation(i).virtual_url(); 766 const std::string& favicon_url = tab.navigation(i).favicon_url(); 767 favicon_cache_.OnReceivedSyncFavicon(GURL(page_url), 768 GURL(favicon_url), 769 std::string(), 770 syncer::TimeToProtoTime( 771 modification_time)); 772 } 773 } 774 } 775 776 bool SessionsSyncManager::GetSyncedFaviconForPageURL( 777 const std::string& page_url, 778 scoped_refptr<base::RefCountedMemory>* favicon_png) const { 779 return favicon_cache_.GetSyncedFaviconForPageURL(GURL(page_url), favicon_png); 780 } 781 782 void SessionsSyncManager::DeleteForeignSession(const std::string& tag) { 783 syncer::SyncChangeList changes; 784 DeleteForeignSessionInternal(tag, &changes); 785 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); 786 } 787 788 void SessionsSyncManager::DeleteForeignSessionInternal( 789 const std::string& tag, syncer::SyncChangeList* change_output) { 790 if (tag == current_machine_tag()) { 791 LOG(ERROR) << "Attempting to delete local session. This is not currently " 792 << "supported."; 793 return; 794 } 795 796 std::set<int> tab_node_ids_to_delete; 797 session_tracker_.LookupTabNodeIds(tag, &tab_node_ids_to_delete); 798 if (!DisassociateForeignSession(tag)) { 799 // We don't have any data for this session, our work here is done! 800 return; 801 } 802 803 // Prepare deletes for the meta-node as well as individual tab nodes. 804 change_output->push_back(syncer::SyncChange( 805 FROM_HERE, 806 SyncChange::ACTION_DELETE, 807 SyncData::CreateLocalDelete(tag, syncer::SESSIONS))); 808 809 for (std::set<int>::const_iterator it = tab_node_ids_to_delete.begin(); 810 it != tab_node_ids_to_delete.end(); 811 ++it) { 812 change_output->push_back(syncer::SyncChange( 813 FROM_HERE, 814 SyncChange::ACTION_DELETE, 815 SyncData::CreateLocalDelete(TabNodePool::TabIdToTag(tag, *it), 816 syncer::SESSIONS))); 817 } 818 content::NotificationService::current()->Notify( 819 chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED, 820 content::Source<Profile>(profile_), 821 content::NotificationService::NoDetails()); 822 } 823 824 bool SessionsSyncManager::DisassociateForeignSession( 825 const std::string& foreign_session_tag) { 826 if (foreign_session_tag == current_machine_tag()) { 827 DVLOG(1) << "Local session deleted! Doing nothing until a navigation is " 828 << "triggered."; 829 return false; 830 } 831 DVLOG(1) << "Disassociating session " << foreign_session_tag; 832 return session_tracker_.DeleteSession(foreign_session_tag); 833 } 834 835 // static 836 GURL SessionsSyncManager::GetCurrentVirtualURL( 837 const SyncedTabDelegate& tab_delegate) { 838 const int current_index = tab_delegate.GetCurrentEntryIndex(); 839 const int pending_index = tab_delegate.GetPendingEntryIndex(); 840 const NavigationEntry* current_entry = 841 (current_index == pending_index) ? 842 tab_delegate.GetPendingEntry() : 843 tab_delegate.GetEntryAtIndex(current_index); 844 return current_entry->GetVirtualURL(); 845 } 846 847 // static 848 GURL SessionsSyncManager::GetCurrentFaviconURL( 849 const SyncedTabDelegate& tab_delegate) { 850 const int current_index = tab_delegate.GetCurrentEntryIndex(); 851 const int pending_index = tab_delegate.GetPendingEntryIndex(); 852 const NavigationEntry* current_entry = 853 (current_index == pending_index) ? 854 tab_delegate.GetPendingEntry() : 855 tab_delegate.GetEntryAtIndex(current_index); 856 return (current_entry->GetFavicon().valid ? 857 current_entry->GetFavicon().url : 858 GURL()); 859 } 860 861 bool SessionsSyncManager::GetForeignSession( 862 const std::string& tag, 863 std::vector<const SessionWindow*>* windows) { 864 return session_tracker_.LookupSessionWindows(tag, windows); 865 } 866 867 bool SessionsSyncManager::GetForeignTab( 868 const std::string& tag, 869 const SessionID::id_type tab_id, 870 const SessionTab** tab) { 871 const SessionTab* synced_tab = NULL; 872 bool success = session_tracker_.LookupSessionTab(tag, 873 tab_id, 874 &synced_tab); 875 if (success) 876 *tab = synced_tab; 877 return success; 878 } 879 880 void SessionsSyncManager::LocalTabDelegateToSpecifics( 881 const SyncedTabDelegate& tab_delegate, 882 sync_pb::SessionSpecifics* specifics) { 883 SessionTab* session_tab = NULL; 884 session_tab = 885 session_tracker_.GetTab(current_machine_tag(), 886 tab_delegate.GetSessionId(), 887 tab_delegate.GetSyncId()); 888 SetSessionTabFromDelegate(tab_delegate, base::Time::Now(), session_tab); 889 sync_pb::SessionTab tab_s = session_tab->ToSyncData(); 890 specifics->set_session_tag(current_machine_tag_); 891 specifics->set_tab_node_id(tab_delegate.GetSyncId()); 892 specifics->mutable_tab()->CopyFrom(tab_s); 893 } 894 895 void SessionsSyncManager::AssociateRestoredPlaceholderTab( 896 const SyncedTabDelegate& tab_delegate, 897 SessionID::id_type new_tab_id, 898 const syncer::SyncDataList& restored_tabs, 899 syncer::SyncChangeList* change_output) { 900 DCHECK_NE(tab_delegate.GetSyncId(), TabNodePool::kInvalidTabNodeID); 901 // Rewrite the tab using |restored_tabs| to retrieve the specifics. 902 if (restored_tabs.empty()) { 903 DLOG(WARNING) << "Can't Update tab ID."; 904 return; 905 } 906 907 for (syncer::SyncDataList::const_iterator it = restored_tabs.begin(); 908 it != restored_tabs.end(); 909 ++it) { 910 if (it->GetSpecifics().session().tab_node_id() != 911 tab_delegate.GetSyncId()) { 912 continue; 913 } 914 915 sync_pb::EntitySpecifics entity; 916 sync_pb::SessionSpecifics* specifics = entity.mutable_session(); 917 specifics->CopyFrom(it->GetSpecifics().session()); 918 DCHECK(specifics->has_tab()); 919 920 // Update tab node pool with the new association. 921 local_tab_pool_.ReassociateTabNode(tab_delegate.GetSyncId(), 922 new_tab_id); 923 TabLink* tab_link = new TabLink(tab_delegate.GetSyncId(), 924 &tab_delegate); 925 local_tab_map_[new_tab_id] = make_linked_ptr<TabLink>(tab_link); 926 927 if (specifics->tab().tab_id() == new_tab_id) 928 return; 929 930 // The tab_id changed (e.g due to session restore), so update sync. 931 specifics->mutable_tab()->set_tab_id(new_tab_id); 932 syncer::SyncData data = syncer::SyncData::CreateLocalData( 933 TabNodePool::TabIdToTag(current_machine_tag_, 934 specifics->tab_node_id()), 935 current_session_name_, 936 entity); 937 change_output->push_back(syncer::SyncChange( 938 FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data)); 939 return; 940 } 941 } 942 943 // static. 944 void SessionsSyncManager::SetSessionTabFromDelegate( 945 const SyncedTabDelegate& tab_delegate, 946 base::Time mtime, 947 SessionTab* session_tab) { 948 DCHECK(session_tab); 949 session_tab->window_id.set_id(tab_delegate.GetWindowId()); 950 session_tab->tab_id.set_id(tab_delegate.GetSessionId()); 951 session_tab->tab_visual_index = 0; 952 // Use -1 to indicate that the index hasn't been set properly yet. 953 session_tab->current_navigation_index = -1; 954 session_tab->pinned = tab_delegate.IsPinned(); 955 session_tab->extension_app_id = tab_delegate.GetExtensionAppId(); 956 session_tab->user_agent_override.clear(); 957 session_tab->timestamp = mtime; 958 const int current_index = tab_delegate.GetCurrentEntryIndex(); 959 const int pending_index = tab_delegate.GetPendingEntryIndex(); 960 const int min_index = std::max(0, current_index - kMaxSyncNavigationCount); 961 const int max_index = std::min(current_index + kMaxSyncNavigationCount, 962 tab_delegate.GetEntryCount()); 963 bool is_supervised = tab_delegate.ProfileIsSupervised(); 964 session_tab->navigations.clear(); 965 966 for (int i = min_index; i < max_index; ++i) { 967 const NavigationEntry* entry = (i == pending_index) ? 968 tab_delegate.GetPendingEntry() : tab_delegate.GetEntryAtIndex(i); 969 DCHECK(entry); 970 if (!entry->GetVirtualURL().is_valid()) 971 continue; 972 973 // Set current_navigation_index to the index in navigations. 974 if (i == current_index) 975 session_tab->current_navigation_index = session_tab->navigations.size(); 976 977 session_tab->navigations.push_back( 978 SerializedNavigationEntry::FromNavigationEntry(i, *entry)); 979 if (is_supervised) { 980 session_tab->navigations.back().set_blocked_state( 981 SerializedNavigationEntry::STATE_ALLOWED); 982 } 983 } 984 985 // If the current navigation is invalid, set the index to the end of the 986 // navigation array. 987 if (session_tab->current_navigation_index < 0) { 988 session_tab->current_navigation_index = 989 session_tab->navigations.size() - 1; 990 } 991 992 if (is_supervised) { 993 const std::vector<const NavigationEntry*>& blocked_navigations = 994 *tab_delegate.GetBlockedNavigations(); 995 int offset = session_tab->navigations.size(); 996 for (size_t i = 0; i < blocked_navigations.size(); ++i) { 997 session_tab->navigations.push_back( 998 SerializedNavigationEntry::FromNavigationEntry( 999 i + offset, *blocked_navigations[i])); 1000 session_tab->navigations.back().set_blocked_state( 1001 SerializedNavigationEntry::STATE_BLOCKED); 1002 // TODO(bauerb): Add categories 1003 } 1004 } 1005 session_tab->session_storage_persistent_id.clear(); 1006 } 1007 1008 FaviconCache* SessionsSyncManager::GetFaviconCache() { 1009 return &favicon_cache_; 1010 } 1011 1012 SyncedWindowDelegatesGetter* 1013 SessionsSyncManager::GetSyncedWindowDelegatesGetter() const { 1014 return synced_window_getter_.get(); 1015 } 1016 1017 void SessionsSyncManager::DoGarbageCollection() { 1018 std::vector<const SyncedSession*> sessions; 1019 if (!GetAllForeignSessions(&sessions)) 1020 return; // No foreign sessions. 1021 1022 // Iterate through all the sessions and delete any with age older than 1023 // |stale_session_threshold_days_|. 1024 syncer::SyncChangeList changes; 1025 for (std::vector<const SyncedSession*>::const_iterator iter = 1026 sessions.begin(); iter != sessions.end(); ++iter) { 1027 const SyncedSession* session = *iter; 1028 int session_age_in_days = 1029 (base::Time::Now() - session->modified_time).InDays(); 1030 std::string session_tag = session->session_tag; 1031 if (session_age_in_days > 0 && // If false, local clock is not trustworty. 1032 static_cast<size_t>(session_age_in_days) > 1033 stale_session_threshold_days_) { 1034 DVLOG(1) << "Found stale session " << session_tag 1035 << " with age " << session_age_in_days << ", deleting."; 1036 DeleteForeignSessionInternal(session_tag, &changes); 1037 } 1038 } 1039 1040 if (!changes.empty()) 1041 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); 1042 } 1043 1044 }; // namespace browser_sync 1045
