[sync] WebContentsObserver based sessions notifications

components/sync_sessions/synced_session_tracker.cc

 // Copyright (c) 2012 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/synced_session_tracker.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sync_sessions/sync_sessions_client.h"
-
+#include "components/sync_sessions/synced_tab_delegate.h"
 namespace sync_sessions {
 
 namespace {
 
 // Helper for iterating through all tabs within a window, and all navigations
 // within a tab, to find if there's a valid syncable url.
 bool ShouldSyncSessionWindow(SyncSessionsClient* sessions_client,
                              const sessions::SessionWindow& window) {
   for (const auto& tab : window.tabs) {
     for (const sessions::SerializedNavigationEntry& navigation :
@@ skipping 61 matching lines @@
   for (const auto& window_pair : iter->second->windows)
     windows->push_back(window_pair.second.get());
 
   return true;
 }
 
 bool SyncedSessionTracker::LookupSessionTab(
     const std::string& tag,
     SessionID::id_type tab_id,
     const sessions::SessionTab** tab) const {
-  if (tab_id == TabNodePool::kInvalidTabID)
+  if (tab_id == kInvalidTabID)
     return false;
 
   DCHECK(tab);
   auto tab_map_iter = synced_tab_map_.find(tag);
   if (tab_map_iter == synced_tab_map_.end()) {
     // We have no record of this session.
     *tab = nullptr;
     return false;
   }
   auto tab_iter = tab_map_iter->second.find(tab_id);
@@ skipping 269 matching lines @@
   bool reused_existing_tab =
       local_tab_pool_.GetTabNodeForTab(tab_id, tab_node_id);
   DCHECK_NE(TabNodePool::kInvalidTabNodeID, *tab_node_id);
   GetSession(local_session_tag_)->tab_node_ids.insert(*tab_node_id);
   return reused_existing_tab;
 }
 
 bool SyncedSessionTracker::IsLocalTabNodeAssociated(int tab_node_id) {
   if (tab_node_id == TabNodePool::kInvalidTabNodeID)
     return false;
-  return local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id) !=
-         TabNodePool::kInvalidTabID;
+  return local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id) != kInvalidTabID;
 }
 
 void SyncedSessionTracker::ReassociateLocalTab(int tab_node_id,
                                                SessionID::id_type new_tab_id) {
   DCHECK(!local_session_tag_.empty());
   DCHECK_NE(TabNodePool::kInvalidTabNodeID, tab_node_id);
-  DCHECK_NE(TabNodePool::kInvalidTabID, new_tab_id);
+  DCHECK_NE(kInvalidTabID, new_tab_id);
 
   SessionID::id_type old_tab_id =
       local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id);
   local_tab_pool_.ReassociateTabNode(tab_node_id, new_tab_id);
 
   sessions::SessionTab* tab_ptr = nullptr;
 
   auto old_tab_iter = synced_tab_map_[local_session_tag_].find(old_tab_id);
-  if (old_tab_id != TabNodePool::kInvalidTabID &&
+  if (old_tab_id != kInvalidTabID &&
       old_tab_iter != synced_tab_map_[local_session_tag_].end()) {
     tab_ptr = old_tab_iter->second;
     // Remove the tab from the synced tab map under the old id.
     synced_tab_map_[local_session_tag_].erase(old_tab_iter);
   } else {
     // It's possible a placeholder is already in place for the new tab. If so,
     // reuse it, otherwise create a new one (which will default to unmapped).
     tab_ptr = GetTab(local_session_tag_, new_tab_id);
   }
 
   // If the old tab is unmapped, update the tab id under which it is indexed.
   auto unmapped_tabs_iter = unmapped_tabs_[local_session_tag_].find(old_tab_id);
-  if (old_tab_id != TabNodePool::kInvalidTabID &&
+  if (old_tab_id != kInvalidTabID &&
       unmapped_tabs_iter != unmapped_tabs_[local_session_tag_].end()) {
     std::unique_ptr<sessions::SessionTab> tab =
         std::move(unmapped_tabs_iter->second);
     DCHECK_EQ(tab_ptr, tab.get());
     unmapped_tabs_[local_session_tag_].erase(unmapped_tabs_iter);
     unmapped_tabs_[local_session_tag_][new_tab_id] = std::move(tab);
   }
 
   // Update the tab id.
-  if (old_tab_id != TabNodePool::kInvalidTabID) {
+  if (old_tab_id != kInvalidTabID) {
     DVLOG(1) << "Remapped tab " << old_tab_id << " with node " << tab_node_id
              << " to tab " << new_tab_id;
   } else {
     DVLOG(1) << "Mapped new tab node " << tab_node_id << " to tab "
              << new_tab_id;
   }
   tab_ptr->tab_id.set_id(new_tab_id);
 
   // Add the tab back into the tab map with the new id.
   synced_tab_map_[local_session_tag_][new_tab_id] = tab_ptr;
@@ skipping 11 matching lines @@
   // Get rid of our convenience maps (does not delete the actual Window/Tabs
   // themselves; they should have all been deleted above).
   synced_window_map_.clear();
   synced_tab_map_.clear();
 
   local_tab_pool_.Clear();
   local_session_tag_.clear();
 }
 
 }  // namespace sync_sessions