Track task ids for navigations cross multiple tabs.

components/sync_sessions/task_tracker.cc

 // Copyright 2017 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/task_tracker.h"
 
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
 
 namespace sync_sessions {
 
 namespace {
 // The maximum number of tasks we track in a tab.
 int kMaxNumTasksPerTab = 100;
 }
 
 TabTasks::TabTasks() {}
 
+TabTasks::TabTasks(const TabTasks* source_tab) {
+  if (source_tab->current_navigation_index_ >= 0) {
+    source_tab_task_ids_ = source_tab->GetTaskIdsForNavigation(
+        source_tab->current_navigation_index_);
+  }
+}
+
 TabTasks::~TabTasks() {}
 
 std::vector<int64_t> TabTasks::GetTaskIdsForNavigation(
     int navigation_index) const {
   CHECK_LE(0, navigation_index);
   CHECK_LT(navigation_index, GetNavigationsCount());
 
   std::vector<int64_t> root_to_self_task_ids;
   // Position of the navigation in task_ids_ vector.
   int navigation_position = navigation_index - excluded_navigation_num_;
 
   // If navigation_index is an excluded ancestor task, returns empty.
   if (navigation_position < 0)
     return root_to_self_task_ids;
 
   TaskIdAndRoot task_id_and_root = task_ids_[navigation_position];
 
   // If navigation_index is an invalid task, returns empty.
   if (task_id_and_root.root_navigation_index < 0)
     return root_to_self_task_ids;
 
   // The root task can be excluded. If so, consider the oldest ancestor
   // available as root.
   int root_navigation_index =
       task_id_and_root.root_navigation_index > excluded_navigation_num_
           ? task_id_and_root.root_navigation_index - excluded_navigation_num_
           : 0;
+  // Only consider tasks from source tab when no tasks in current tab is
+  // excluded because max number per tab limit.
+  if (excluded_navigation_num_ == 0) {
+    int first_task_of_tab_position = 0;
+    // skipping invalid heading tasks
+    for (; first_task_of_tab_position < navigation_position &&
+           task_ids_[first_task_of_tab_position].root_navigation_index < 0;
+         first_task_of_tab_position++) {
+    }
+    // If task of current navigation can track back to the first task of the
+    // tab, then consider the source tab.
+    if (task_id_and_root.root_navigation_index == first_task_of_tab_position)
+      root_to_self_task_ids = source_tab_task_ids_;
+  }
   for (int i = root_navigation_index; i <= navigation_position; i++) {
     // Fills the vector with valid tasks.
     if (task_ids_[i].root_navigation_index >= 0)
       root_to_self_task_ids.push_back(task_ids_[i].task_id);
   }
   return root_to_self_task_ids;
 }
 
 int TabTasks::GetNavigationsCount() const {
   return excluded_navigation_num_ + task_ids_.size();
@@ skipping 99 matching lines @@
 
 TaskTracker::~TaskTracker() {}
 
 TabTasks* TaskTracker::GetTabTasks(SessionID::id_type tab_id) {
   if (local_tab_tasks_map_.find(tab_id) == local_tab_tasks_map_.end()) {
     local_tab_tasks_map_[tab_id] = base::MakeUnique<TabTasks>();
   }
   return local_tab_tasks_map_[tab_id].get();
 }
 
+TabTasks* TaskTracker::GetTabTasks(SessionID::id_type tab_id,
+                                   SessionID::id_type source_tab_id) {
+  if (local_tab_tasks_map_.find(tab_id) == local_tab_tasks_map_.end()) {
+    auto iter = local_tab_tasks_map_.find(source_tab_id);
+    if (iter != local_tab_tasks_map_.end()) {
+      local_tab_tasks_map_[tab_id] =
+          base::MakeUnique<TabTasks>(iter->second.get());
+    } else {
+      local_tab_tasks_map_[tab_id] = base::MakeUnique<TabTasks>();
+    }
+  }
+  return local_tab_tasks_map_[tab_id].get();
+}
+
 void TaskTracker::CleanTabTasks(SessionID::id_type tab_id) {
   auto iter = local_tab_tasks_map_.find(tab_id);
   if (iter != local_tab_tasks_map_.end()) {
     local_tab_tasks_map_.erase(iter);
   }
 }
 
 }  // namespace sync_sessions