[Sync] Add per-navigation timestamps/unique ids to tab sync.

chrome/browser/sync/glue/session_model_associator.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_
 #define CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 18 matching lines @@
 #include "chrome/browser/sync/glue/model_associator.h"
 #include "chrome/browser/sync/glue/synced_session_tracker.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "sync/syncable/model_type.h"
 
 class Prefservice;
 class Profile;
 class ProfileSyncService;
 
+namespace content {
+class NavigationEntry;
+}  // namespace content
+
 namespace sync_api {
 class BaseTransaction;
 class ReadNode;
 class WriteTransaction;
 }  // namespace sync_api
 
 namespace sync_pb {
 class SessionHeader;
 class SessionSpecifics;
 class SessionTab;
@@ skipping 168 matching lines @@
   static syncable::ModelType model_type() { return syncable::SESSIONS; }
 
   // Testing only. Will cause the associator to call MessageLoop::Quit()
   // when a local change is made, or when timeout_milli occurs, whichever is
   // first.
   void BlockUntilLocalChangeForTest(int64 timeout_milli);
 
   // Callback for when the session name has been computed.
   void OnSessionNameInitialized(const std::string& name);
 
+  // If a valid favicon for the page at |url| is found, fills |png_favicon| with
+  // the png-encoded image and returns true. Else, returns false.
+  bool GetSyncedFaviconForPageURL(const std::string& url,
+                                  std::string* png_favicon) const;
+
  private:
+  friend class SyncSessionModelAssociatorTest;
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, WriteSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest,
                            WriteFilledSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest,
                            WriteForeignSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, TabNodePoolEmpty);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, TabNodePoolNonEmpty);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, ValidTabs);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, ExistingTabs);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, MissingLocalTabNode);
@@ skipping 41 matching lines @@
 
     // The currently visible url of the tab (used for syncing favicons).
     GURL url_;
 
     // Handle for loading favicons.
     FaviconService::Handle favicon_load_handle_;
   };
 
   // A pool for managing free/used tab sync nodes. Performs lazy creation
   // of sync nodes when necessary.
+  // TODO(zea): pull this into it's own file.

[Andrew T Wilson (Slow), 2012/04/23 23:43:11]

nit: it's->its

[Nicolas Zea, 2012/04/24 22:09:49]

Done.

   class TabNodePool {
    public:
     explicit TabNodePool(ProfileSyncService* sync_service);
     ~TabNodePool();
 
     // Add a previously allocated tab sync node to our pool. Increases the size
     // of tab_syncid_pool_ by one and marks the new tab node as free.
     // 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).
@@ skipping 94 matching lines @@
                                        sync_api::WriteTransaction* trans,
                                        SyncError* error);
 
   // Fills a tab sync node with data from a TabContents object. Updates
   // |tab_link| with the current url if it's valid and triggers a favicon
   // load if the url has changed.
   // Returns true on success, false if we need to reassociate due to corruption.
   bool WriteTabContentsToSyncModel(TabLink* tab_link,
                                    SyncError* error);
 
+  // Decrements the favicon usage counters for the favicon used by |page_url|.
+  // Deletes the favicon and associated pages from the favicon usage maps
+  // if no page is found to be referring to the favicon anymore.
+  void DecrementAndCleanFaviconForURL(std::string page_url);
+
+  // Helper method to build sync's tab specifics from a newly modified
+  // tab, window, and the locally stored previous tab data. After completing,
+  // |prev_tab| will be updated to reflect the current data, |sync_tab| will
+  // be filled with the tab data (preserving old timestamps as necessary), and
+  // |new_url| will be the tab's current url.
+  void AssociateTabContents(const SyncedWindowDelegate& window,
+                            const SyncedTabDelegate& new_tab,
+                            SyncedSessionTab* prev_tab,
+                            sync_pb::SessionTab* sync_tab,
+                            GURL* new_url);
+
   // Load the favicon for the tab specified by |tab_link|. Will cancel any
   // outstanding request for this tab. OnFaviconDataAvailable(..) will be called
   // when the load completes.
   void LoadFaviconForTab(TabLink* tab_link);
 
   // Callback method to store a tab's favicon into its sync node once it becomes
   // available. Does nothing if no favicon data was available.
   void OnFaviconDataAvailable(FaviconService::Handle handle,
                               history::FaviconData favicon);
 
   // Used to populate a session header from the session specifics header
   // provided.
   static void PopulateSessionHeaderFromSpecifics(
     const sync_pb::SessionHeader& header_specifics,
     const base::Time& mtime,
     SyncedSession* session_header);
 
   // Used to populate a session window from the session specifics window
   // provided. Tracks any foreign session data created through |tracker|.
   static void PopulateSessionWindowFromSpecifics(
       const std::string& foreign_session_tag,
       const sync_pb::SessionWindow& window,
       const base::Time& mtime,
       SessionWindow* session_window,
       SyncedSessionTracker* tracker);
 
   // Used to populate a session tab from the session specifics tab provided.
   static void PopulateSessionTabFromSpecifics(const sync_pb::SessionTab& tab,
                                               const base::Time& mtime,
-                                              SessionTab* session_tab);
+                                              SyncedSessionTab* session_tab);
 
-  // Helper method to take the favicon data in a foreign tab and store it
-  // into the history db.
+  // Helper method to load the favicon data from the tab specifics. If the
+  // favicon is valid, stores it in |synced_favicons_|, increments
+  // |synced_favicon_usage_| and updates |synced_favicon_pages_| appropriately.
   void LoadForeignTabFavicon(const sync_pb::SessionTab& tab);
 
-  // Used to populate a session tab from the session specifics tab provided.
+  // Append a new navigation from sync specifics onto |tab| navigation vectors.
   static void AppendSessionTabNavigation(
      const sync_pb::TabNavigation& navigation,
-     std::vector<TabNavigation>* navigations);
+     SyncedSessionTab* tab);
 
   // Populates the navigation portion of the session specifics.
   static void PopulateSessionSpecificsNavigation(
-     const TabNavigation* navigation,
+     const content::NavigationEntry& navigation,
      sync_pb::TabNavigation* tab_navigation);
 
   // Returns true if this tab belongs to this profile and belongs to a window,
   // false otherwise.
   bool IsValidTab(const SyncedTabDelegate& tab) const;
 
   // Having a valid entry is defined as the url being valid and and having a
   // syncable scheme (non chrome:// and file:// url's). In other words, we don't
   // want to sync a tab that is nothing but chrome:// and file:// navigations or
   // invalid url's.
   bool TabHasValidEntry(const SyncedTabDelegate& tab) const;
 
   // For testing only.
+  size_t NumFaviconsForTesting() const;
+
+  // For testing only.
   void QuitLoopForSubtleTesting();
 
   // Unique client tag.
   std::string current_machine_tag_;
 
   // User-visible machine name.
   std::string current_session_name_;
 
   // Pool of all used/available sync nodes associated with tabs.
   TabNodePool tab_pool_;
@@ skipping 27 matching lines @@
 
   // Pref service. Used to persist the session sync guid. Weak pointer.
   PrefService* const pref_service_;
 
   DataTypeErrorHandler* error_handler_;
 
   // Used for loading favicons. For each outstanding favicon load, stores the
   // SessionID for the tab whose favicon is being set.
   CancelableRequestConsumerTSimple<SessionID::id_type> load_consumer_;
 
+  // Synced favicon storage and tracking.
+  // Map of favicon URL -> favicon data for favicons synced from other clients.
+  // Favicons are stored as png-encoded strings.
+  // TODO(zea): if this becomes expensive memory-wise, reconsider using the
+  // favicon service instead. For now, this is simpler due to the history
+  // backend not properly supporting expiration of synced favicons.
+  // See crbug.com/122890.
+  std::map<std::string, linked_ptr<std::string> > synced_favicons_;
+  // Map of favicon URL -> usage count. When the count reaches zero, we can
+  // safely delete the favicon as no tabs are referring to it anymore.
+  std::map<std::string, size_t> synced_favicon_usage_;
+  // Map of page URL -> favicon url.
+  std::map<std::string, std::string> synced_favicon_pages_;
+
   DISALLOW_COPY_AND_ASSIGN(SessionModelAssociator);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_