Revert of Reland v4 of Session refactor

components/sync_sessions/tab_node_pool.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_SYNC_SESSIONS_TAB_NODE_POOL_H_
 #define COMPONENTS_SYNC_SESSIONS_TAB_NODE_POOL_H_
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/macros.h"
 #include "components/sessions/core/session_id.h"
+#include "components/sync/model/sync_change_processor.h"
+
+namespace syncer {
+class SyncChangeProcessor;
+}  // namespace syncer
 
 namespace sync_sessions {
 
 // A pool for managing free/used tab sync nodes for the *local* session.
 // Performs lazy creation of sync nodes when necessary.
 // Note: We make use of the following "id's"
 // - a tab_id: created by session service, unique to this client
 // - a tab_node_id: the id for a particular sync tab node. This is used
 //   to generate the sync tab node tag through:
-//       tab_tag = StringPrintf("%s %d", local_session_tag, tab_node_id);
+//       tab_tag = StringPrintf("%s_%ui", local_session_tag, tab_node_id);
 //
-// A sync node can be in one of the two states:
+// A sync node can be in one of the three states:
 // 1. Associated   : Sync node is used and associated with a tab.
-// 2. Free         : Sync node is unused.
+// 2. Unassociated : Sync node is used but currently unassociated with any tab.
+//                   This is true for old nodes that remain from a session
+//                   restart. Nodes are only unassociated temporarily while the
+//                   model associator figures out which tabs belong to which
+//                   nodes. Eventually any remaining unassociated nodes are
+//                   freed.
+// 3. Free         : Sync node is unused.
 
 class TabNodePool {
  public:
   TabNodePool();
   ~TabNodePool();
   enum InvalidTab { kInvalidTabID = -1 };
 
   // If free nodes > kFreeNodesHighWatermark, delete all free nodes until
   // free nodes <= kFreeNodesLowWatermark.
   static const size_t kFreeNodesLowWatermark;
 
   // Maximum limit of FreeNodes allowed on the client.
   static const size_t kFreeNodesHighWatermark;
 
   static const int kInvalidTabNodeID;
 
-  // Fills |tab_node_id| with a tab node associated with |tab_id|.
-  // If tab_id is already associated with a tab_node_id, reuses the existing
-  // association. Otherwise attempts to get the next free tab node and
-  // associate it with |tab_id|. If none are available, will create a new tab
-  // node.
-  // Returns true if a pre-existing tab node could be reused, false if a new one
-  // had to be created.
-  bool GetTabNodeForTab(SessionID::id_type tab_id, int* tab_node_id);
+  // Build a sync tag from tab_node_id.
+  static std::string TabIdToTag(const std::string& machine_tag,
+                                int tab_node_id);
+
+  // Returns the tab_node_id for the next free tab node. If none are available,
+  // creates a new tab node and adds it to free nodes pool. The free node can
+  // then be used to associate with a tab by calling AssociateTabNode.
+  // Note: The node is considered free until it has been associated. Repeated
+  // calls to GetFreeTabNode will return the same id until node has been
+  // associated.
+  // |change_output| *must* be provided. It is the TabNodePool's link to
+  // the SyncChange pipeline that exists in the caller context. If the need
+  // to create nodes arises in the implementation, associated SyncChanges will
+  // be appended to this list for later application by the caller via the
+  // SyncChangeProcessor.
+  int GetFreeTabNode(syncer::SyncChangeList* change_output);
+
+  // Removes association for |tab_node_id| and returns it to the free node pool.
+  // |change_output| *must* be provided. It is the TabNodePool's link to
+  // the SyncChange pipeline that exists in the caller's context. If the need
+  // to delete sync nodes arises in the implementation, associated SyncChanges
+  // will be appended to this list for later application by the caller via the
+  // SyncChangeProcessor.
+  void FreeTabNode(int tab_node_id, syncer::SyncChangeList* change_output);
+
+  // Associates |tab_node_id| with |tab_id|. |tab_node_id| should either be
+  // unassociated or free. If |tab_node_id| is free, |tab_node_id| is removed
+  // from the free node pool In order to associate a non free sync node,
+  // use ReassociateTabNode.
+  void AssociateTabNode(int tab_node_id, SessionID::id_type tab_id);
+
+  // Adds |tab_node_id| as an unassociated sync node.
+  // Note: this should only be called when we discover tab sync nodes from
+  // previous sessions, not for freeing tab nodes we created through
+  // GetFreeTabNode (use FreeTabNode below for that).
+  void AddTabNode(int tab_node_id);
 
   // Returns the tab_id for |tab_node_id| if it is associated else returns
   // kInvalidTabID.
   SessionID::id_type GetTabIdFromTabNodeId(int tab_node_id) const;
 
-  // Reassociates |tab_node_id| with |tab_id|. If |tab_node_id| is not already
-  // known, it is added to the tab node pool before being associated.
+  // Reassociates |tab_node_id| with |tab_id|. |tab_node_id| must be either
+  // associated with a tab or in the set of unassociated nodes.
   void ReassociateTabNode(int tab_node_id, SessionID::id_type tab_id);
 
-  // Removes association for |tab_id| and returns its tab node to the free node
-  // pool.
-  void FreeTab(int tab_id);
+  // Returns true if |tab_node_id| is an unassociated tab node.
+  bool IsUnassociatedTabNode(int tab_node_id);
 
-  // Fills |deleted_node_ids| with any free nodes to be deleted as proscribed
-  // by the free node low/high watermarks, in order to ensure the free node pool
-  // does not grow too large.
-  void CleanupTabNodes(std::set<int>* deleted_node_ids);
+  // Returns any unassociated nodes to the free node pool.
+  // |change_output| *must* be provided. It is the TabNodePool's link to
+  // the SyncChange pipeline that exists in the caller's context.
+  // See FreeTabNode for more detail.
+  void DeleteUnassociatedTabNodes(syncer::SyncChangeList* change_output);
 
   // Clear tab pool.
   void Clear();
 
   // Return the number of tab nodes this client currently has allocated
-  // (including both free and associated nodes).
+  // (including both free, unassociated and associated nodes)
   size_t Capacity() const;
 
   // Return empty status (all tab nodes are in use).
   bool Empty() const;
 
   // Return full status (no tab nodes are in use).
   bool Full();
 
+  void SetMachineTag(const std::string& machine_tag);
+
  private:
   friend class SyncTabNodePoolTest;
   typedef std::map<int, SessionID::id_type> TabNodeIDToTabIDMap;
-  typedef std::map<SessionID::id_type, int> TabIDToTabNodeIDMap;
 
-  // Adds |tab_node_id| to the tab node pool.
-  // Note: this should only be called when we discover tab sync nodes from
-  // previous sessions, not for freeing tab nodes we created through
-  // GetTabNodeForTab (use FreeTab for that).
-  void AddTabNode(int tab_node_id);
-
-  // Associates |tab_node_id| with |tab_id|. |tab_node_id| must be free. In
-  // order to associated a non-free tab node, ReassociateTabNode must be
-  // used.
-  void AssociateTabNode(int tab_node_id, SessionID::id_type tab_id);
+  // Adds |tab_node_id| to free node pool.
+  // |change_output| *must* be provided. It is the TabNodePool's link to
+  // the SyncChange pipeline that exists in the caller's context.
+  // See FreeTabNode for more detail.
+  void FreeTabNodeInternal(int tab_node_id,
+                           syncer::SyncChangeList* change_output);
 
   // Stores mapping of node ids associated with tab_ids, these are the used
   // nodes of tab node pool.
   // The nodes in the map can be returned to free tab node pool by calling
-  // FreeTab(..).
+  // FreeTabNode(tab_node_id).
   TabNodeIDToTabIDMap nodeid_tabid_map_;
-  TabIDToTabNodeIDMap tabid_nodeid_map_;
 
   // The node ids for the set of free sync nodes.
   std::set<int> free_nodes_pool_;
 
+  // The node ids that are added to pool using AddTabNode and are currently
+  // not associated with any tab. They can be reassociated using
+  // ReassociateTabNode.
+  std::set<int> unassociated_nodes_;
+
   // The maximum used tab_node id for a sync node. A new sync node will always
   // be created with max_used_tab_node_id_ + 1.
   int max_used_tab_node_id_;
 
+  // The machine tag associated with this tab pool. Used in the title of new
+  // sync nodes.
+  std::string machine_tag_;
+
   DISALLOW_COPY_AND_ASSIGN(TabNodePool);
 };
 
 }  // namespace sync_sessions
 
 #endif  // COMPONENTS_SYNC_SESSIONS_TAB_NODE_POOL_H_