[Sync] Fix Session's handling of windows.

chrome/browser/sync/glue/synced_session_tracker.h

 // Copyright (c) 2011 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 CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sync/glue/synced_session.h"
 
 namespace browser_sync {
 
@@ skipping 26 matching lines @@
 
   // Attempts to look up the tab associated with the given tag and tab id.
   // If lookup succeeds:
   // - Sets tab to point to the SessionTab, and returns true.
   // Else
   // - Returns false, tab is set to NULL.
   bool LookupSessionTab(const std::string& session_tag,
                         SessionID::id_type tab_id,
                         const SessionTab** tab);
 
-  // Returns a pointer to the SyncedSession object associated with session_tag.
-  // If none exists, creates one and returns its pointer.
+  // Returns a pointer to the SyncedSession object associated with
+  // |session_tag|.  If none exists, creates one.
   SyncedSession* GetSession(const std::string& session_tag);
 
   // Deletes the session associated with |session_tag| if it exists.
   // Returns true if the session existed and was deleted, false otherwise.
   bool DeleteSession(const std::string& session_tag);
 
+  // Resets the tracking information for the session specified by |session_tag|.
+  // Once reset, all calls to GetWindow and GetTabForWindow will denote
+  // that the requested windows and tabs are in use (by setting the boolean
+  // in their SessionWindowWrapper/SessionTabWrapper to true). The next call to
+  // CleanupSession(...) will delete those windows and tabs not in use.
+  void ResetSessionTracking(const std::string& session_tag);
+
+  // Deletes those windows and tabs associated with |session_tag| that are no
+  // longer in use from memory (and removes unused windows from their
+  // SyncedSession object).
+  // See ResetSessionTracking(...).
+  void CleanupSession(const std::string& session_tag);
+
+  // Returns a pointer to the SessionWindow object associated with |window_id|
+  // for the session specified with |session_tag|. If none exists, creates one.
+  SessionWindow* GetWindow(const std::string& session_tag,
+                           SessionID::id_type window_id);
+
+  // Same as GetTab, but internally notes that window |window_id| is now
+  // holding tab |tab_id|. As a result, when CleanupSession(...) is called,
+  // the tab will not be destroyed.
+  SessionTab* GetTabForWindow(const std::string& session_tag,
+                              SessionID::id_type window_id,
+                              SessionID::id_type tab_id);
+
   // Returns a pointer to the SessionTab object associated with |tab_id| for
-  // the session specified with |session_tag|. If none exists, creates one and
-  // returns its pointer.
-  // |has_window| determines if newly created tabs are added to the pool of
-  // orphaned tabs (those which can't be reached by traversing sessions).
-  SessionTab* GetSessionTab(const std::string& session_tag,
-                            SessionID::id_type tab_id,
-                            bool has_window);
+  // the session specified with |session_tag|. If none exists, creates one.
+  SessionTab* GetTab(const std::string& session_tag,
+                     SessionID::id_type tab_id);
 
   // Free the memory for all dynamically allocated objects and clear the
   // tracking structures.
   void clear();
 
   inline bool empty() {
     return synced_tab_map_.empty() && synced_session_map_.empty();
   }
 
   // Includes both foreign sessions and the local session.
   inline size_t num_synced_sessions() {
     return synced_session_map_.size();
   }
 
   // Returns the number of tabs associated with the specified session tag.
   inline size_t num_synced_tabs(const std::string& session_tag) {
     if (synced_tab_map_.find(session_tag) != synced_tab_map_.end()) {
       return synced_tab_map_[session_tag]->size();
     } else {
       return 0;
     }
   }
  private:
   // Datatypes for accessing session data.
-  typedef std::map<SessionID::id_type, SessionTab*> IDToSessionTabMap;
+  // Note, we pair pointers with bools so that we can track what is in use and
+  // what can be deleted (see ResetSessionTracking(..) and CleanupSession(..)
+  // above).
+  struct SessionTabWrapper {
+    SessionTabWrapper() : tab_ptr(NULL), used(false) {}
+    SessionTabWrapper(SessionTab* tab_ptr, bool used)
+        : tab_ptr(tab_ptr),
+          used(used) {}
+    SessionTab* tab_ptr;
+    bool used;
+  };
+  typedef std::map<SessionID::id_type, SessionTabWrapper> IDToSessionTabMap;
   typedef std::map<std::string, IDToSessionTabMap*> SyncedTabMap;
+
+  struct SessionWindowWrapper {
+    SessionWindowWrapper() : window_ptr(NULL), used(false) {}
+    SessionWindowWrapper(SessionWindow* window_ptr, bool used)
+        : window_ptr(window_ptr),
+          used(used) {}
+    SessionWindow* window_ptr;
+    bool used;
+  };
+  typedef std::map<SessionID::id_type, SessionWindowWrapper>
+      IDToSessionWindowMap;
+  typedef std::map<std::string, IDToSessionWindowMap*> SyncedWindowMap;
+
   typedef std::map<std::string, SyncedSession*> SyncedSessionMap;
 
+  // Helper methods for deleting SessionWindows and SessionTabs.
+  bool ClearUnusedSessionWindow(SessionWindowWrapper window_wrapper,
+                                SyncedSession* session);
+  bool ClearUnusedSessionTab(SessionTabWrapper tab_wrapper);
+
   // Per client mapping of tab id's to their SessionTab objects.
   // Key: session tag.
   // Value: Tab id to SessionTab map pointer.
   SyncedTabMap synced_tab_map_;
 
+  // Per client mapping of the window id's to their SessionWindow objects.
+  // Key: session_tag
+  // Value: Window id to SessionWindow map pointer.
+  SyncedWindowMap synced_window_map_;
+
   // Per client mapping synced session objects.
   // Key: session tag.
   // Value: SyncedSession object pointer.
   SyncedSessionMap synced_session_map_;
 
   // The set of tabs that we have seen, and created SessionTab objects for, but
   // have not yet mapped to SyncedSessions. These are temporarily orphaned
   // tabs, and won't be deleted if we delete synced_session_map_.
   std::set<SessionTab*> unmapped_tabs_;
 
   // The tag for this machine's local session, so we can distinguish the foreign
   // sessions.
   std::string local_session_tag_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncedSessionTracker);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_