Add taskid for navigation, created in session sync

components/sync_sessions/sessions_sync_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_sessions/sessions_sync_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
@@ skipping 118 matching lines @@
                      kMaxSyncFavicons),
       local_tab_pool_out_of_sync_(true),
       sync_prefs_(sync_prefs),
       local_device_(local_device),
       current_device_type_(sync_pb::SyncEnums_DeviceType_TYPE_OTHER),
       local_session_header_node_id_(TabNodePool::kInvalidTabNodeID),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       local_event_router_(std::move(router)),
       page_revisit_broadcaster_(this, sessions_client),
       sessions_updated_callback_(sessions_updated_callback),
-      datatype_refresh_callback_(datatype_refresh_callback) {}
+      datatype_refresh_callback_(datatype_refresh_callback),
+      task_tracker_(base::MakeUnique<TaskTracker>()) {}
 
 SessionsSyncManager::~SessionsSyncManager() {}
 
 // Returns the GUID-based string that should be used for
 // |SessionsSyncManager::current_machine_tag_|.
 static std::string BuildMachineTag(const std::string& cache_guid) {
   std::string machine_tag = "session_sync";
   machine_tag.append(cache_guid);
   return machine_tag;
 }
@@ skipping 206 matching lines @@
       current_machine_tag(), current_session_name_, entity);
   change_output->push_back(
       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data));
 }
 
 void SessionsSyncManager::AssociateTab(SyncedTabDelegate* const tab_delegate,
                                        syncer::SyncChangeList* change_output) {
   DCHECK(!tab_delegate->IsPlaceholderTab());
 
   if (tab_delegate->IsBeingDestroyed()) {
-    // Do nothing. By not proactively adding the tab to the session, it will be
-    // removed if necessary during subsequent cleanup.
+    task_tracker_->CleanTabTasks(tab_delegate->GetSessionId());
+    // Do nothing else. By not proactively adding the tab to the session, it
+    // will be removed if necessary during subsequent cleanup.
     return;
   }
 
   if (!tab_delegate->ShouldSync(sessions_client_))
     return;
 
   SessionID::id_type tab_id = tab_delegate->GetSessionId();
   DVLOG(1) << "Syncing tab " << tab_id << " from window "
            << tab_delegate->GetWindowId();
 
@@ skipping 14 matching lines @@
   // Update the tracker's session representation.
   SetSessionTabFromDelegate(*tab_delegate, base::Time::Now(), session_tab);
   SetVariationIds(session_tab);
   session_tracker_.GetSession(current_machine_tag())->modified_time =
       base::Time::Now();
 
   // Write to the sync model itself.
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_session()->CopyFrom(
       SessionTabToSpecifics(*session_tab, current_machine_tag(), tab_node_id));
+  // Intercept the sync model here to update task tracker and fill navigations
+  // with their ancestor navigations.
+  TrackTasks(tab_delegate, specifics.mutable_session());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       TabNodeIdToTag(current_machine_tag(), tab_node_id), current_session_name_,
       specifics);
   change_output->push_back(
       syncer::SyncChange(FROM_HERE,
                          existing_tab_node ? syncer::SyncChange::ACTION_UPDATE
                                            : syncer::SyncChange::ACTION_ADD,
                          data));
 
   int current_index = tab_delegate->GetCurrentEntryIndex();
   const GURL new_url = tab_delegate->GetVirtualURLAtIndex(current_index);
   if (new_url != old_url) {
     favicon_cache_.OnFaviconVisited(
         new_url, tab_delegate->GetFaviconURLAtIndex(current_index));
     page_revisit_broadcaster_.OnPageVisit(
         new_url, tab_delegate->GetTransitionAtIndex(current_index));
   }
 }
 
+void SessionsSyncManager::TrackTasks(
+    SyncedTabDelegate* const tab_delegate,
+    sync_pb::SessionSpecifics* session_specifics) {
+  sync_pb::SessionTab* tab_specifics = session_specifics->mutable_tab();
+  // Index in the whole navigations of the tab.
+  int current_navigation_index = tab_delegate->GetCurrentEntryIndex();
+  // Index in the tab_specifics, where the navigations is a -6/+6 window
+  int current_index_in_tab_specifics =
+      tab_specifics->current_navigation_index();
+  int64_t current_navigation_global_id =
+      tab_specifics->navigation(current_index_in_tab_specifics).global_id();
+
+  TabTasks* tab_tasks =
+      task_tracker_->GetTabTasks(tab_delegate->GetSessionId());
+  tab_tasks->UpdateWithNavigation(
+      current_navigation_index,
+      tab_delegate->GetTransitionAtIndex(current_navigation_index),
+      current_navigation_global_id);
+
+  for (int i = 0; i < tab_specifics->navigation_size(); i++) {
+    // Excluding blocked navigations, which are appended at tail.
+    if (tab_specifics->navigation(i).blocked_state() ==
+        sync_pb::TabNavigation::STATE_BLOCKED) {
+      break;
+    }
+
+    int navigation_index =
+        current_navigation_index - current_index_in_tab_specifics + i;
+    // Skipping navigations not been tracked by task_tracker.
+    if (navigation_index < 0 ||
+        navigation_index >= tab_tasks->GetNavigationsCount()) {
+      continue;
+    }
+    std::vector<int64_t> task_ids =
+        tab_tasks->GetTaskIdsForNavigation(navigation_index);
+    if (task_ids.empty())
+      continue;
+
+    tab_specifics->mutable_navigation(i)->set_task_id(task_ids.back());
+    // Pop the task id of navigation self.
+    task_ids.pop_back();
+    for (auto ancestor_task_id : task_ids) {
+      tab_specifics->mutable_navigation(i)->add_ancestor_task_id(
+          ancestor_task_id);
+    }
+  }
+}
+
 bool SessionsSyncManager::RebuildAssociations() {
   syncer::SyncDataList data(sync_processor_->GetAllSyncData(syncer::SESSIONS));
   std::unique_ptr<syncer::SyncErrorFactory> error_handler(
       std::move(error_handler_));
   std::unique_ptr<syncer::SyncChangeProcessor> processor(
       std::move(sync_processor_));
 
   StopSyncing(syncer::SESSIONS);
   syncer::SyncMergeResult merge_result = MergeDataAndStartSyncing(
       syncer::SESSIONS, data, std::move(processor), std::move(error_handler));
@@ skipping 708 matching lines @@
 }
 
 // static
 std::string SessionsSyncManager::TagHashFromSpecifics(
     const sync_pb::SessionSpecifics& specifics) {
   return syncer::GenerateSyncableHash(syncer::SESSIONS,
                                       TagFromSpecifics(specifics));
 }
 
 };  // namespace sync_sessions