[Sync] Add logic to reassociate tab nodes after restart.

chrome/browser/sync/glue/tab_node_pool_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
+typedef testing::Test SyncTabNodePoolTest;
+
+TEST_F(SyncTabNodePoolTest, TabNodeIdIncreases) {
+  // max_used_tab_node_ always increases.
+  TabNodePool pool(NULL);
+  pool.set_machine_tag("tag");
+  pool.AddOldTabNode(4, 10);
+  EXPECT_EQ(10u, pool.max_used_tab_node_id_);
+  pool.AddOldTabNode(5, 1);
+  EXPECT_EQ(10u, pool.max_used_tab_node_id_);
+  pool.AddOldTabNode(6, 1000);
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  // Freeing a tab node does not change max_used_tab_node_id_.
+  pool.FreeTabNode(5);
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  pool.FreeUnusedOldSyncNodes(std::set<int64>());
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  for (int i = 0; i < 3; ++i) {
+    pool.GetFreeTabNode();
+    EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  }
+
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+
+}
 namespace {
 
-typedef testing::Test SyncTabNodePoolTest;
+TEST_F(SyncTabNodePoolTest, OldTabNodesAddAndRemove) {
+  // VerifyOldTabNodes are added.
+  TabNodePool pool(NULL);
+  pool.set_machine_tag("tag");
+  // sync_id =4, tab_node_id = 1
+  pool.AddOldTabNode(4, 1);
+  // sync_id = 5, tab_node_id = 5
+  pool.AddOldTabNode(5, 2);
+  EXPECT_EQ(2u, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  // max_used_tab_node_ should be 2. The next tab node should be 3.
+  // old tab node pool should contain old sync nodes.
+  EXPECT_TRUE(pool.RemoveIfOldSyncNodeExists(4));
+  EXPECT_TRUE(pool.RemoveIfOldSyncNodeExists(5));
+  EXPECT_TRUE(pool.empty());
+
+  // Returning old tab nodes to pool should
+  pool.FreeTabNode(4);
+  pool.FreeTabNode(5);
+  EXPECT_EQ(2u, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(5, pool.GetFreeTabNode());
+  EXPECT_EQ(4, pool.GetFreeTabNode());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_FALSE(pool.full());
+}
+
+TEST_F(SyncTabNodePoolTest, OldTabNodesRemove) {
+  // VerifyOldTabNodes are removed correctly and added back to free node pool.
+  TabNodePool pool(NULL);
+  pool.set_machine_tag("tag");
+  // sync_id =4, tab_node_id = 1
+  pool.AddOldTabNode(4, 1);
+  // sync_id = 5, tab_node_id = 2
+  pool.AddOldTabNode(5, 2);
+  // sync_id = 5, tab_node_id = 3
+  pool.AddOldTabNode(6, 3);
+  EXPECT_EQ(3u, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  std::set<int64> used_sync_ids;
+  used_sync_ids.insert(4);
+  used_sync_ids.insert(5);
+  used_sync_ids.insert(6);
+  pool.FreeUnusedOldSyncNodes(used_sync_ids);
+  // All tab nodes are in use, they should not be removed.
+  EXPECT_EQ(3u, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_TRUE(pool.RemoveIfOldSyncNodeExists(4));
+  // Should no longer be in old tab nodes pool.
+  EXPECT_FALSE(pool.RemoveIfOldSyncNodeExists(4));
+  used_sync_ids.clear();
+  // 4 is used, 5 and 6 should be returned to the free node pool.
+  pool.FreeUnusedOldSyncNodes(used_sync_ids);
+  // 5 and 6 should not be in the old nodes pool.
+  EXPECT_FALSE(pool.RemoveIfOldSyncNodeExists(5));
+  EXPECT_FALSE(pool.RemoveIfOldSyncNodeExists(6));
+  EXPECT_FALSE(pool.empty());
+  EXPECT_EQ(3u, pool.capacity());
+
+  // Free 4 as well, pool should have all free nodes now.
+  pool.FreeTabNode(4);
+  EXPECT_TRUE(pool.full());
+
+  std::set<int64> free_sync_ids;
+  for (int i = 0; i < 3; ++i) {
+    free_sync_ids.insert(pool.GetFreeTabNode());
+  }
+
+  EXPECT_TRUE(pool.empty());
+  EXPECT_EQ(3u, free_sync_ids.size());
+  EXPECT_EQ(1u, free_sync_ids.count(4));
+  EXPECT_EQ(1u, free_sync_ids.count(5));
+  EXPECT_EQ(1u, free_sync_ids.count(6));
+}
 
 TEST_F(SyncTabNodePoolTest, Init) {
   TabNodePool pool(NULL);
   pool.set_machine_tag("tag");
-  ASSERT_TRUE(pool.empty());
-  ASSERT_TRUE(pool.full());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_TRUE(pool.full());
 }
 
 TEST_F(SyncTabNodePoolTest, AddGet) {
   TabNodePool pool(NULL);
   pool.set_machine_tag("tag");
 
-  pool.AddTabNode(5);
-  pool.AddTabNode(10);
-  ASSERT_FALSE(pool.empty());
-  ASSERT_TRUE(pool.full());
+  pool.AddOldTabNode(5, 1);
+  pool.AddOldTabNode(10, 2);
+  pool.FreeUnusedOldSyncNodes(std::set<int64>());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
 
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
-  ASSERT_FALSE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_FALSE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
 }
 
 TEST_F(SyncTabNodePoolTest, All) {
   TabNodePool pool(NULL);
   pool.set_machine_tag("tag");
-  ASSERT_TRUE(pool.empty());
-  ASSERT_TRUE(pool.full());
-  ASSERT_EQ(0U, pool.capacity());
-  pool.AddTabNode(5);
-  pool.AddTabNode(10);
-  ASSERT_FALSE(pool.empty());
-  ASSERT_TRUE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
-  ASSERT_FALSE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
-  ASSERT_TRUE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(0U, pool.capacity());
+  pool.AddOldTabNode(5, 1);
+  pool.AddOldTabNode(10, 2);
+  pool.FreeUnusedOldSyncNodes(std::set<int64>());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_FALSE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_TRUE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
   // Release them in reverse order.
   pool.FreeTabNode(10);
   pool.FreeTabNode(5);
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_FALSE(pool.empty());
-  ASSERT_TRUE(pool.full());
-  ASSERT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
-  ASSERT_FALSE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_FALSE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
-  ASSERT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
-  ASSERT_TRUE(pool.empty());
-  ASSERT_FALSE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(5, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_FALSE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(10, pool.GetFreeTabNode());  // Returns last free tab.
+  EXPECT_TRUE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
   // Release them again.
   pool.FreeTabNode(10);
   pool.FreeTabNode(5);
-  ASSERT_FALSE(pool.empty());
-  ASSERT_TRUE(pool.full());
-  ASSERT_EQ(2U, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
   pool.clear();
-  ASSERT_TRUE(pool.empty());
-  ASSERT_TRUE(pool.full());
-  ASSERT_EQ(0U, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(0U, pool.capacity());
 }
 
 }  // namespace
 
 }  // namespace browser_sync