[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;

[Nicolas Zea, 2013/06/19 21:35:33]

Given what I mentioned about friending a test class, this should probably an
actual class inheriting from testing::Test that exposes the max used tab node
id. That also means you can leave the tests themselves within an anon namespace

[shashi, 2013/06/20 00:49:32]

Done.
On 2013/06/19 21:35:33, Nicolas Zea wrote:

+
+TEST_F(SyncTabNodePoolTest, TabNodeIdIncreases) {
+  // max_used_tab_node_ always increases.
+  TabNodePool pool(NULL);
+  pool.set_machine_tag("tag");
+  SessionID session_id;
+  session_id.set_id(1);
+  pool.AddTabNode(4, session_id, 10);
+  EXPECT_EQ(10u, pool.max_used_tab_node_id_);
+  session_id.set_id(2);
+  pool.AddTabNode(5, session_id, 1);
+  EXPECT_EQ(10u, pool.max_used_tab_node_id_);
+  session_id.set_id(3);
+  pool.AddTabNode(6, session_id, 1000);
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  pool.ReassociateTabNode(6, 500);
+  // Freeing a tab node does not change max_used_tab_node_id_.
+  pool.FreeTabNode(4);
+  pool.FreeUnusedTabNodes(std::set<int64>());
+  EXPECT_EQ(1000u, pool.max_used_tab_node_id_);
+  for (int i = 0; i < 3; ++i) {
+    pool.AssociateTabNode(pool.GetFreeTabNode(), i + 1);
+    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, tab_id = 1
+  SessionID session_id;
+  session_id.set_id(1);
+  pool.AddTabNode(4, session_id, 1);
+  // sync_id = 5, tab_node_id = 5, tab_id = 2
+  session_id.set_id(2);
+  pool.AddTabNode(5, session_id, 2);
+  EXPECT_EQ(2u, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  EXPECT_TRUE(pool.ReassociateTabNode(4, 2));
+  EXPECT_TRUE(pool.ReassociateTabNode(5, 1));
+  EXPECT_TRUE(pool.empty());
+  // Check free unused tab nodes returns the node to free node pool.
+  std::set<int64> used_sync_ids;
+  used_sync_ids.insert(5);
+  pool.FreeUnusedTabNodes(used_sync_ids);
+  // 4 should be returned to free node pool.
+  EXPECT_EQ(2u, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  // 5 should still be in the associated nodes.
+  EXPECT_FALSE(pool.full());
+  pool.FreeTabNode(5);
+  // 5 should be returned to free nodes pool and pool should be full.
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(4, pool.GetFreeTabNode());
+  pool.AssociateTabNode(4, 1);
+  EXPECT_EQ(5, pool.GetFreeTabNode());
+  pool.AssociateTabNode(5, 1);
+  EXPECT_TRUE(pool.empty());
+  EXPECT_FALSE(pool.full());
+}
+
+TEST_F(SyncTabNodePoolTest, OldTabNodesReassociation) {
+  // VerifyOldTabNodes are reassociated correctly.
+  TabNodePool pool(NULL);
+  pool.set_machine_tag("tag");
+  // sync_id =4, tab_node_id = 1, tab_id = 1
+  SessionID session_id;
+  session_id.set_id(1);
+  pool.AddTabNode(4, session_id, 1);
+  // sync_id = 5, tab_node_id = 2, tab_id = 2
+  session_id.set_id(2);
+  pool.AddTabNode(5, session_id, 2);
+  // sync_id = 5, tab_node_id = 3, tab_id =3
+  session_id.set_id(3);
+  pool.AddTabNode(6, session_id, 3);
+  EXPECT_EQ(3u, pool.capacity());
+  EXPECT_TRUE(pool.empty());
+  // Free 5 and 6.
+  pool.FreeTabNode(5);
+  pool.FreeTabNode(6);
+  // 5 and 6 nodes should not get reassociated.
+  EXPECT_TRUE(pool.ReassociateTabNode(4, 5));
+  EXPECT_FALSE(pool.ReassociateTabNode(5, 6));
+  EXPECT_FALSE(pool.ReassociateTabNode(6, 7));
+  // Free node pool should have 5 and 6.
+  EXPECT_FALSE(pool.empty());
+  EXPECT_EQ(3u, pool.capacity());
+
+  // Free all nodes
+  pool.FreeUnusedTabNodes(std::set<int64>());
+  EXPECT_TRUE(pool.full());
+  std::set<int64> free_sync_ids;
+  for (int i = 0; i < 3; ++i) {
+    free_sync_ids.insert(pool.GetFreeTabNode());
+    // GetFreeTabNode will return the same value till the node is
+    // reassociated.
+    pool.AssociateTabNode(pool.GetFreeTabNode(), i + 1);
+  }
+
+  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());
-
-  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.
+  SessionID session_id;
+  session_id.set_id(1);
+  pool.AddTabNode(5, session_id, 1);
+  session_id.set_id(2);
+  pool.AddTabNode(10, session_id, 2);
+  pool.FreeUnusedTabNodes(std::set<int64>());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(5, pool.GetFreeTabNode());
+  pool.AssociateTabNode(5, 1);
+  EXPECT_FALSE(pool.empty());
+  EXPECT_FALSE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  // 5 is now used, should return 10.
+  EXPECT_EQ(10, pool.GetFreeTabNode());
 }
 
 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());
+  SessionID session_id;
+  session_id.set_id(1);
+  pool.AddTabNode(5, session_id, 1);
+  session_id.set_id(2);
+  pool.AddTabNode(10, session_id, 2);
+  // Free added nodes.
+  pool.FreeUnusedTabNodes(std::set<int64>());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  // GetFreeTabNode returns the lowest numbered free node.
+  EXPECT_EQ(5, pool.GetFreeTabNode());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  // Associate 5, next free node should be 10.
+  pool.AssociateTabNode(5, 1);
+  EXPECT_EQ(10, pool.GetFreeTabNode());
+  pool.AssociateTabNode(10, 2);
+  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());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_FALSE(pool.empty());
+  EXPECT_TRUE(pool.full());
+  pool.AssociateTabNode(5, 1);
+  EXPECT_EQ(2U, pool.capacity());
+  EXPECT_EQ(10, pool.GetFreeTabNode());
+  pool.AssociateTabNode(10, 2);
+  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