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 103 matching lines @@
 }  // namespace
 
 // |local_device| is owned by ProfileSyncService, its lifetime exceeds
 // lifetime of SessionSyncManager.
 SessionsSyncManager::SessionsSyncManager(
     sync_sessions::SyncSessionsClient* sessions_client,
     syncer::SyncPrefs* sync_prefs,
     LocalDeviceInfoProvider* local_device,
     std::unique_ptr<LocalSessionEventRouter> router,
     const base::Closure& sessions_updated_callback,
-    const base::Closure& datatype_refresh_callback)
+    const base::Closure& datatype_refresh_callback,
+    std::unique_ptr<base::Clock> clock)
     : sessions_client_(sessions_client),
       session_tracker_(sessions_client),
       favicon_cache_(sessions_client->GetFaviconService(),
                      sessions_client->GetHistoryService(),
                      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>(std::move(clock))) {}
 
 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 232 matching lines @@
   tab_delegate->SetSyncId(tab_node_id);
   sessions::SessionTab* session_tab =
       session_tracker_.GetTab(current_machine_tag(), tab_id);
 
   // Get the previously synced url.
   int old_index = session_tab->normalized_navigation_index();
   GURL old_url;
   if (session_tab->navigations.size() > static_cast<size_t>(old_index))
     old_url = session_tab->navigations[old_index].virtual_url();
 
+  TabTasks* tab_tasks = task_tracker_->GetTabTasks(tab_id);
   // Update the tracker's session representation.
-  SetSessionTabFromDelegate(*tab_delegate, base::Time::Now(), session_tab);
+  SetSessionTabFromDelegate(*tab_delegate, base::Time::Now(), session_tab,
+                            tab_tasks);
   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));
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       TabNodeIdToTag(current_machine_tag(), tab_node_id), current_session_name_,
@@ skipping 623 matching lines @@
       TabNodeIdToTag(current_machine_tag(), tab_delegate.GetSyncId()),
       current_session_name_, entity);
   change_output->push_back(
       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data));
 }
 
 // static
 void SessionsSyncManager::SetSessionTabFromDelegate(
     const SyncedTabDelegate& tab_delegate,
     base::Time mtime,
-    sessions::SessionTab* session_tab) {
+    sessions::SessionTab* session_tab,
+    TabTasks* tab_tasks) {
   DCHECK(session_tab);
   session_tab->window_id.set_id(tab_delegate.GetWindowId());
   session_tab->tab_id.set_id(tab_delegate.GetSessionId());
   session_tab->tab_visual_index = 0;
   // Use -1 to indicate that the index hasn't been set properly yet.
   session_tab->current_navigation_index = -1;
   const SyncedWindowDelegate* window_delegate =
       synced_window_delegates_getter()->FindById(tab_delegate.GetWindowId());
   session_tab->pinned =
       window_delegate ? window_delegate->IsTabPinned(&tab_delegate) : false;
   session_tab->extension_app_id = tab_delegate.GetExtensionAppId();
   session_tab->user_agent_override.clear();
   session_tab->timestamp = mtime;
   const int current_index = tab_delegate.GetCurrentEntryIndex();
   const int min_index = std::max(0, current_index - kMaxSyncNavigationCount);
   const int max_index = std::min(current_index + kMaxSyncNavigationCount,
                                  tab_delegate.GetEntryCount());
   bool is_supervised = tab_delegate.ProfileIsSupervised();
   session_tab->navigations.clear();
 
+  if (tab_tasks != nullptr)
+    tab_tasks->UpdateTask(current_index,

[Nicolas Zea, 2017/03/27 20:43:52]

nit: curly braces around multi-line if

[shenchao, 2017/04/06 00:54:55]

Done.

+                          tab_delegate.GetTransitionAtIndex(current_index));
+
+  DVLOG(0) << "current_index: " << current_index << " of "

[Nicolas Zea, 2017/03/27 20:43:52]

Did you mean to leave this?

[shenchao, 2017/04/06 00:54:55]

Done.

+           << tab_delegate.GetEntryCount();
+
   for (int i = min_index; i < max_index; ++i) {
     if (!tab_delegate.GetVirtualURLAtIndex(i).is_valid())
       continue;
     sessions::SerializedNavigationEntry serialized_entry;
     tab_delegate.GetSerializedNavigationAtIndex(i, &serialized_entry);
 
     // Set current_navigation_index to the index in navigations.
     if (i == current_index)
       session_tab->current_navigation_index = session_tab->navigations.size();
 
+    if (tab_tasks != nullptr && i < tab_tasks->GetNavigationsCount())
+      serialized_entry.set_task_id(tab_tasks->GetTaskIdAtNavIndex(i));
+
     session_tab->navigations.push_back(serialized_entry);
     if (is_supervised) {
       session_tab->navigations.back().set_blocked_state(
           SerializedNavigationEntry::STATE_ALLOWED);
     }
   }
 
   // If the current navigation is invalid, set the index to the end of the
   // navigation array.
   if (session_tab->current_navigation_index < 0) {
@@ skipping 61 matching lines @@
 }
 
 // static
 std::string SessionsSyncManager::TagHashFromSpecifics(
     const sync_pb::SessionSpecifics& specifics) {
   return syncer::GenerateSyncableHash(syncer::SESSIONS,
                                       TagFromSpecifics(specifics));
 }
 
 };  // namespace sync_sessions