[go: nahoru, domu]

blob: 09b7cd94c61a8d9a7f81b8fe9f356bf114ed1760 [file] [log] [blame]
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/sync_sessions/tab_node_pool.h"
#include <algorithm>
#include <limits>
#include <utility>
#include "base/logging.h"
#include "components/sync/base/model_type.h"
#include "components/sync/protocol/session_specifics.pb.h"
#include "components/sync_sessions/synced_tab_delegate.h"
namespace sync_sessions {
TabNodePool::TabNodePool() : max_used_tab_node_id_(kInvalidTabNodeID) {}
// static
// We start vending tab node IDs at 0.
const int TabNodePool::kInvalidTabNodeID = -1;
TabNodePool::~TabNodePool() = default;
void TabNodePool::AddTabNode(int tab_node_id) {
DCHECK_GT(tab_node_id, kInvalidTabNodeID);
DCHECK_LE(tab_node_id, max_used_tab_node_id_);
DCHECK(nodeid_tabid_map_.find(tab_node_id) == nodeid_tabid_map_.end());
DVLOG(1) << "Adding tab node " << tab_node_id << " to pool.";
free_nodes_pool_.insert(tab_node_id);
missing_nodes_pool_.erase(tab_node_id);
}
void TabNodePool::AssociateTabNode(int tab_node_id, SessionID tab_id) {
DCHECK_GT(tab_node_id, kInvalidTabNodeID);
DCHECK(tab_id.is_valid());
// This is a new node association, the sync node should be free.
// Remove node from free node pool and then associate it with the tab.
auto it = free_nodes_pool_.find(tab_node_id);
DCHECK(it != free_nodes_pool_.end());
free_nodes_pool_.erase(it);
DCHECK(nodeid_tabid_map_.find(tab_node_id) == nodeid_tabid_map_.end());
DVLOG(1) << "Associating tab node " << tab_node_id << " with tab "
<< tab_id.id();
nodeid_tabid_map_.emplace(tab_node_id, tab_id);
tabid_nodeid_map_[tab_id] = tab_node_id;
}
int TabNodePool::GetTabNodeIdFromTabId(SessionID tab_id) const {
auto it = tabid_nodeid_map_.find(tab_id);
if (it != tabid_nodeid_map_.end()) {
return it->second;
}
return kInvalidTabNodeID;
}
void TabNodePool::FreeTab(SessionID tab_id) {
DCHECK(tab_id.is_valid());
auto it = tabid_nodeid_map_.find(tab_id);
if (it == tabid_nodeid_map_.end()) {
return; // Already freed.
}
int tab_node_id = it->second;
DVLOG(1) << "Freeing tab " << tab_id.id() << " at node " << tab_node_id;
nodeid_tabid_map_.erase(nodeid_tabid_map_.find(tab_node_id));
tabid_nodeid_map_.erase(it);
free_nodes_pool_.insert(tab_node_id);
}
int TabNodePool::AssociateWithFreeTabNode(SessionID tab_id) {
DCHECK_EQ(0U, tabid_nodeid_map_.count(tab_id));
int tab_node_id;
if (free_nodes_pool_.empty() && missing_nodes_pool_.empty()) {
// Tab pool has neither free nodes nor "holes" within the ID range, so
// allocate a new one by extending the range.
tab_node_id = ++max_used_tab_node_id_;
AddTabNode(tab_node_id);
} else {
tab_node_id = std::numeric_limits<int>::max();
// Take the smallest available, either from the freed pool or from IDs that
// were never associated before (but are within 0..max_used_tab_node_id_).
if (!free_nodes_pool_.empty()) {
tab_node_id = *free_nodes_pool_.begin();
DCHECK_LE(tab_node_id, max_used_tab_node_id_);
}
if (!missing_nodes_pool_.empty() &&
*missing_nodes_pool_.begin() < tab_node_id) {
tab_node_id = *missing_nodes_pool_.begin();
DCHECK_LE(tab_node_id, max_used_tab_node_id_);
AddTabNode(tab_node_id);
}
}
AssociateTabNode(tab_node_id, tab_id);
return tab_node_id;
}
void TabNodePool::ReassociateTabNode(int tab_node_id, SessionID tab_id) {
DCHECK_GT(tab_node_id, kInvalidTabNodeID);
DCHECK(tab_id.is_valid());
auto tabid_it = tabid_nodeid_map_.find(tab_id);
if (tabid_it != tabid_nodeid_map_.end()) {
if (tabid_it->second == tab_node_id) {
return; // Already associated properly.
} else {
// Another node is already associated with this tab. Free it.
FreeTab(tab_id);
}
}
auto nodeid_it = nodeid_tabid_map_.find(tab_node_id);
if (nodeid_it != nodeid_tabid_map_.end()) {
// This node was already associated with another tab. Free it.
FreeTab(nodeid_it->second);
} else {
// This is a new tab node. Add it before association. We also need to
// remember the "holes".
for (int missing_tab_node_id = max_used_tab_node_id_ + 1;
missing_tab_node_id < tab_node_id; ++missing_tab_node_id) {
missing_nodes_pool_.insert(missing_tab_node_id);
}
max_used_tab_node_id_ = std::max(max_used_tab_node_id_, tab_node_id);
AddTabNode(tab_node_id);
}
AssociateTabNode(tab_node_id, tab_id);
}
SessionID TabNodePool::GetTabIdFromTabNodeId(int tab_node_id) const {
auto it = nodeid_tabid_map_.find(tab_node_id);
if (it != nodeid_tabid_map_.end()) {
return it->second;
}
return SessionID::InvalidValue();
}
std::set<int> TabNodePool::CleanupFreeTabNodes() {
// Convert all free nodes into missing nodes, each representing a deletion.
missing_nodes_pool_.insert(free_nodes_pool_.begin(), free_nodes_pool_.end());
std::set<int> deleted_node_ids = std::move(free_nodes_pool_);
free_nodes_pool_.clear();
// As an optimization to save memory, update |max_used_tab_node_id_| and
// shrink |missing_nodes_pool_| appropriately.
if (nodeid_tabid_map_.empty()) {
max_used_tab_node_id_ = kInvalidTabNodeID;
} else {
max_used_tab_node_id_ = nodeid_tabid_map_.rbegin()->first;
}
missing_nodes_pool_.erase(
missing_nodes_pool_.upper_bound(max_used_tab_node_id_),
missing_nodes_pool_.end());
return deleted_node_ids;
}
void TabNodePool::DeleteTabNode(int tab_node_id) {
auto it = nodeid_tabid_map_.find(tab_node_id);
if (it == nodeid_tabid_map_.end()) {
free_nodes_pool_.erase(tab_node_id);
return;
}
DCHECK_EQ(0U, free_nodes_pool_.count(tab_node_id));
SessionID tab_id = it->second;
DVLOG(1) << "Deleting node " << tab_node_id << " with tab ID " << tab_id;
tabid_nodeid_map_.erase(tab_id);
nodeid_tabid_map_.erase(it);
}
std::set<int> TabNodePool::GetAllTabNodeIds() const {
std::set<int> tab_node_ids = free_nodes_pool_;
for (const auto& [tab_node_id, tab_id] : nodeid_tabid_map_) {
tab_node_ids.insert(tab_node_id);
}
return tab_node_ids;
}
int TabNodePool::GetMaxUsedTabNodeIdForTest() const {
return max_used_tab_node_id_;
}
} // namespace sync_sessions