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