chrome/browser/sync/glue/tab_node_pool.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 "chrome/browser/sync/glue/tab_node_pool.h"

#include "base/format_macros.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/browser/sync/profile_sync_service.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/read_node.h"
#include "sync/internal_api/public/write_node.h"
#include "sync/internal_api/public/write_transaction.h"

namespace browser_sync {

static const char kNoSessionsFolderError[] =
    "Server did not create the top-level sessions node. We "
    "might be running against an out-of-date server.";

const size_t TabNodePool::kFreeNodesLowWatermark = 25;
const size_t TabNodePool::kFreeNodesHighWatermark = 100;

TabNodePool::TabNodePool(ProfileSyncService* sync_service)
    : max_used_tab_node_id_(kInvalidTabNodeID),
      sync_service_(sync_service) {}

// static
// We start vending tab node IDs at 0.
const int TabNodePool::kInvalidTabNodeID = -1;

TabNodePool::~TabNodePool() {}

// Static
std::string TabNodePool::TabIdToTag(
    const std::string machine_tag, int tab_node_id) {
  return base::StringPrintf("%s %d", machine_tag.c_str(), tab_node_id);
}

void TabNodePool::AddTabNode(int tab_node_id) {
  DCHECK_GT(tab_node_id, kInvalidTabNodeID);
  DCHECK(nodeid_tabid_map_.find(tab_node_id) == nodeid_tabid_map_.end());
  unassociated_nodes_.insert(tab_node_id);
  if (max_used_tab_node_id_ < tab_node_id)
    max_used_tab_node_id_ = tab_node_id;
}

void TabNodePool::AssociateTabNode(int tab_node_id,
                                   SessionID::id_type tab_id) {
  DCHECK_GT(tab_node_id, kInvalidTabNodeID);
  // Remove sync node if it is in unassociated nodes pool.
  std::set<int>::iterator u_it = unassociated_nodes_.find(tab_node_id);
  if (u_it != unassociated_nodes_.end()) {
    unassociated_nodes_.erase(u_it);
  } else {
    // 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.
    std::set<int>::iterator 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());
  nodeid_tabid_map_[tab_node_id] = tab_id;
}

int TabNodePool::GetFreeTabNode() {
  DCHECK_GT(machine_tag_.length(), 0U);
  if (free_nodes_pool_.empty()) {
    // Tab pool has no free nodes, allocate new one.
    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
    syncer::ReadNode root(&trans);
    if (root.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::SESSIONS)) !=
                             syncer::BaseNode::INIT_OK) {
      LOG(ERROR) << kNoSessionsFolderError;
      return kInvalidTabNodeID;
    }
    int tab_node_id = ++max_used_tab_node_id_;
    std::string tab_node_tag = TabIdToTag(machine_tag_, tab_node_id);
    syncer::WriteNode tab_node(&trans);
    syncer::WriteNode::InitUniqueByCreationResult result =
        tab_node.InitUniqueByCreation(syncer::SESSIONS, root, tab_node_tag);
    if (result != syncer::WriteNode::INIT_SUCCESS) {
      LOG(ERROR) << "Could not create new node with tag "
                 << tab_node_tag << "!";
      return kInvalidTabNodeID;
    }
    // We fill the new node with just enough data so that in case of a crash/bug
    // we can identify the node as our own on re-association and reuse it.
    tab_node.SetTitle(UTF8ToWide(tab_node_tag));
    sync_pb::SessionSpecifics specifics;
    specifics.set_session_tag(machine_tag_);
    specifics.set_tab_node_id(tab_node_id);
    tab_node.SetSessionSpecifics(specifics);

    // Grow the pool by 1 since we created a new node.
    DVLOG(1) << "Adding sync node " << tab_node_id
             << " to tab node id pool";
    free_nodes_pool_.insert(tab_node_id);
    return tab_node_id;
  } else {
    // Return the next free node.
    return *free_nodes_pool_.begin();
  }
}

void TabNodePool::FreeTabNode(int tab_node_id) {
  TabNodeIDToTabIDMap::iterator it = nodeid_tabid_map_.find(tab_node_id);
  DCHECK(it != nodeid_tabid_map_.end());
  nodeid_tabid_map_.erase(it);
  FreeTabNodeInternal(tab_node_id);
}

void TabNodePool::FreeTabNodeInternal(int tab_node_id) {
  DCHECK(free_nodes_pool_.find(tab_node_id) == free_nodes_pool_.end());
  free_nodes_pool_.insert(tab_node_id);

  // If number of free nodes exceed kFreeNodesHighWatermark,
  // delete sync nodes till number reaches kFreeNodesLowWatermark.
  // Note: This logic is to mitigate temporary disassociation issues with old
  // clients: http://crbug.com/259918. Newer versions do not need this.
  if (free_nodes_pool_.size() > kFreeNodesHighWatermark) {
    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
    for (std::set<int>::iterator free_it = free_nodes_pool_.begin();
         free_it != free_nodes_pool_.end();) {
      syncer::WriteNode tab_node(&trans);
      const std::string tab_node_tag = TabIdToTag(machine_tag_, *free_it);
      if (tab_node.InitByClientTagLookup(syncer::SESSIONS, tab_node_tag) !=
          syncer::BaseNode::INIT_OK) {
        LOG(ERROR) << "Could not find sync node with tag: " << tab_node_tag;
        return;
      }
      free_nodes_pool_.erase(free_it++);
      tab_node.Tombstone();
      if (free_nodes_pool_.size() <= kFreeNodesLowWatermark) {
        return;
      }
    }
  }
}

bool TabNodePool::IsUnassociatedTabNode(int tab_node_id) {
  return unassociated_nodes_.find(tab_node_id) != unassociated_nodes_.end();
}

void TabNodePool::ReassociateTabNode(int tab_node_id,
                                     SessionID::id_type tab_id) {
  // Remove from list of unassociated sync_nodes if present.
  std::set<int>::iterator it = unassociated_nodes_.find(tab_node_id);
  if (it != unassociated_nodes_.end()) {
    unassociated_nodes_.erase(it);
  } else {
    // tab_node_id must be an already associated node.
    DCHECK(nodeid_tabid_map_.find(tab_node_id) != nodeid_tabid_map_.end());
  }
  nodeid_tabid_map_[tab_node_id] = tab_id;
}

SessionID::id_type TabNodePool::GetTabIdFromTabNodeId(
    int tab_node_id) const {
  TabNodeIDToTabIDMap::const_iterator it = nodeid_tabid_map_.find(tab_node_id);
  if (it != nodeid_tabid_map_.end()) {
    return it->second;
  }
  return kInvalidTabID;
}

void TabNodePool::DeleteUnassociatedTabNodes() {
  syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
  for (std::set<int>::iterator it = unassociated_nodes_.begin();
       it != unassociated_nodes_.end();) {
    syncer::WriteNode tab_node(&trans);
    const std::string tab_node_tag = TabIdToTag(machine_tag_, *it);
    if (tab_node.InitByClientTagLookup(syncer::SESSIONS, tab_node_tag) !=
        syncer::BaseNode::INIT_OK) {
      LOG(ERROR) << "Could not find sync node with tag: " << tab_node_tag;
    } else {
      tab_node.Tombstone();
    }
    unassociated_nodes_.erase(it++);
  }
  DCHECK(unassociated_nodes_.empty());
}

// Clear tab pool.
void TabNodePool::Clear() {
  unassociated_nodes_.clear();
  free_nodes_pool_.clear();
  nodeid_tabid_map_.clear();
  max_used_tab_node_id_ = kInvalidTabNodeID;
}

size_t TabNodePool::Capacity() const {
  return nodeid_tabid_map_.size() + unassociated_nodes_.size() +
         free_nodes_pool_.size();
}

bool TabNodePool::Empty() const { return free_nodes_pool_.empty(); }

bool TabNodePool::Full() { return nodeid_tabid_map_.empty(); }

void TabNodePool::SetMachineTag(const std::string& machine_tag) {
  machine_tag_ = machine_tag;
}

}  // namespace browser_sync