Home | History | Annotate | Download | only in sessions 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync/sessions/tab_node_pool.h"
      6 
      7 #include "base/format_macros.h"
      8 #include "base/logging.h"
      9 #include "base/strings/stringprintf.h"
     10 #include "sync/api/sync_change.h"
     11 #include "sync/api/sync_data.h"
     12 #include "sync/internal_api/public/base/model_type.h"
     13 #include "sync/protocol/session_specifics.pb.h"
     14 #include "sync/protocol/sync.pb.h"
     15 
     16 namespace browser_sync {
     17 
     18 const size_t TabNodePool::kFreeNodesLowWatermark = 25;
     19 const size_t TabNodePool::kFreeNodesHighWatermark = 100;
     20 
     21 TabNodePool::TabNodePool()
     22     : max_used_tab_node_id_(kInvalidTabNodeID) {}
     23 
     24 // static
     25 // We start vending tab node IDs at 0.
     26 const int TabNodePool::kInvalidTabNodeID = -1;
     27 
     28 TabNodePool::~TabNodePool() {}
     29 
     30 // Static
     31 std::string TabNodePool::TabIdToTag(
     32     const std::string machine_tag, int tab_node_id) {
     33   return base::StringPrintf("%s %d", machine_tag.c_str(), tab_node_id);
     34 }
     35 
     36 void TabNodePool::AddTabNode(int tab_node_id) {
     37   DCHECK_GT(tab_node_id, kInvalidTabNodeID);
     38   DCHECK(nodeid_tabid_map_.find(tab_node_id) == nodeid_tabid_map_.end());
     39   unassociated_nodes_.insert(tab_node_id);
     40   if (max_used_tab_node_id_ < tab_node_id)
     41     max_used_tab_node_id_ = tab_node_id;
     42 }
     43 
     44 void TabNodePool::AssociateTabNode(int tab_node_id,
     45                                     SessionID::id_type tab_id) {
     46   DCHECK_GT(tab_node_id, kInvalidTabNodeID);
     47   // Remove sync node if it is in unassociated nodes pool.
     48   std::set<int>::iterator u_it = unassociated_nodes_.find(tab_node_id);
     49   if (u_it != unassociated_nodes_.end()) {
     50     unassociated_nodes_.erase(u_it);
     51   } else {
     52     // This is a new node association, the sync node should be free.
     53     // Remove node from free node pool and then associate it with the tab.
     54     std::set<int>::iterator it = free_nodes_pool_.find(tab_node_id);
     55     DCHECK(it != free_nodes_pool_.end());
     56     free_nodes_pool_.erase(it);
     57   }
     58   DCHECK(nodeid_tabid_map_.find(tab_node_id) == nodeid_tabid_map_.end());
     59   nodeid_tabid_map_[tab_node_id] = tab_id;
     60 }
     61 
     62 int TabNodePool::GetFreeTabNode(syncer::SyncChangeList* append_changes) {
     63   DCHECK_GT(machine_tag_.length(), 0U);
     64   DCHECK(append_changes);
     65   if (free_nodes_pool_.empty()) {
     66     // Tab pool has no free nodes, allocate new one.
     67     int tab_node_id = ++max_used_tab_node_id_;
     68     std::string tab_node_tag = TabIdToTag(machine_tag_, tab_node_id);
     69 
     70     // We fill the new node with just enough data so that in case of a crash/bug
     71     // we can identify the node as our own on re-association and reuse it.
     72     sync_pb::EntitySpecifics entity;
     73     sync_pb::SessionSpecifics* specifics = entity.mutable_session();
     74     specifics->set_session_tag(machine_tag_);
     75     specifics->set_tab_node_id(tab_node_id);
     76     append_changes->push_back(syncer::SyncChange(
     77         FROM_HERE,
     78         syncer::SyncChange::ACTION_ADD,
     79         syncer::SyncData::CreateLocalData(tab_node_tag,
     80                                           tab_node_tag,
     81                                           entity)));
     82 
     83     // Grow the pool by 1 since we created a new node.
     84     DVLOG(1) << "Adding sync node " << tab_node_id
     85              << " to tab node id pool";
     86     free_nodes_pool_.insert(tab_node_id);
     87     return tab_node_id;
     88   } else {
     89     // Return the next free node.
     90     return *free_nodes_pool_.begin();
     91   }
     92 }
     93 
     94 void TabNodePool::FreeTabNode(int tab_node_id,
     95                                syncer::SyncChangeList* append_changes) {
     96   DCHECK(append_changes);
     97   TabNodeIDToTabIDMap::iterator it = nodeid_tabid_map_.find(tab_node_id);
     98   DCHECK(it != nodeid_tabid_map_.end());
     99   nodeid_tabid_map_.erase(it);
    100   FreeTabNodeInternal(tab_node_id, append_changes);
    101 }
    102 
    103 void TabNodePool::FreeTabNodeInternal(
    104     int tab_node_id,
    105     syncer::SyncChangeList* append_changes) {
    106   DCHECK(free_nodes_pool_.find(tab_node_id) == free_nodes_pool_.end());
    107   DCHECK(append_changes);
    108   free_nodes_pool_.insert(tab_node_id);
    109 
    110   // If number of free nodes exceed kFreeNodesHighWatermark,
    111   // delete sync nodes till number reaches kFreeNodesLowWatermark.
    112   // Note: This logic is to mitigate temporary disassociation issues with old
    113   // clients: http://crbug.com/259918. Newer versions do not need this.
    114   if (free_nodes_pool_.size() > kFreeNodesHighWatermark) {
    115     for (std::set<int>::iterator free_it = free_nodes_pool_.begin();
    116          free_it != free_nodes_pool_.end();) {
    117       const std::string tab_node_tag = TabIdToTag(machine_tag_, *free_it);
    118       append_changes->push_back(syncer::SyncChange(
    119           FROM_HERE,
    120           syncer::SyncChange::ACTION_DELETE,
    121           syncer::SyncData::CreateLocalDelete(tab_node_tag,
    122                                               syncer::SESSIONS)));
    123       free_nodes_pool_.erase(free_it++);
    124       if (free_nodes_pool_.size() <= kFreeNodesLowWatermark) {
    125         return;
    126       }
    127     }
    128   }
    129 }
    130 
    131 bool TabNodePool::IsUnassociatedTabNode(int tab_node_id) {
    132   return unassociated_nodes_.find(tab_node_id) != unassociated_nodes_.end();
    133 }
    134 
    135 void TabNodePool::ReassociateTabNode(int tab_node_id,
    136                                       SessionID::id_type tab_id) {
    137   // Remove from list of unassociated sync_nodes if present.
    138   std::set<int>::iterator it = unassociated_nodes_.find(tab_node_id);
    139   if (it != unassociated_nodes_.end()) {
    140     unassociated_nodes_.erase(it);
    141   } else {
    142     // tab_node_id must be an already associated node.
    143     DCHECK(nodeid_tabid_map_.find(tab_node_id) != nodeid_tabid_map_.end());
    144   }
    145   nodeid_tabid_map_[tab_node_id] = tab_id;
    146 }
    147 
    148 SessionID::id_type TabNodePool::GetTabIdFromTabNodeId(
    149     int tab_node_id) const {
    150   TabNodeIDToTabIDMap::const_iterator it = nodeid_tabid_map_.find(tab_node_id);
    151   if (it != nodeid_tabid_map_.end()) {
    152     return it->second;
    153   }
    154   return kInvalidTabID;
    155 }
    156 
    157 void TabNodePool::DeleteUnassociatedTabNodes(
    158     syncer::SyncChangeList* append_changes) {
    159   for (std::set<int>::iterator it = unassociated_nodes_.begin();
    160        it != unassociated_nodes_.end();) {
    161     FreeTabNodeInternal(*it, append_changes);
    162     unassociated_nodes_.erase(it++);
    163   }
    164   DCHECK(unassociated_nodes_.empty());
    165 }
    166 
    167 // Clear tab pool.
    168 void TabNodePool::Clear() {
    169   unassociated_nodes_.clear();
    170   free_nodes_pool_.clear();
    171   nodeid_tabid_map_.clear();
    172   max_used_tab_node_id_ = kInvalidTabNodeID;
    173 }
    174 
    175 size_t TabNodePool::Capacity() const {
    176   return nodeid_tabid_map_.size() + unassociated_nodes_.size() +
    177          free_nodes_pool_.size();
    178 }
    179 
    180 bool TabNodePool::Empty() const { return free_nodes_pool_.empty(); }
    181 
    182 bool TabNodePool::Full() { return nodeid_tabid_map_.empty(); }
    183 
    184 void TabNodePool::SetMachineTag(const std::string& machine_tag) {
    185   machine_tag_ = machine_tag;
    186 }
    187 
    188 }  // namespace browser_sync
    189