[Sync] Rename csync namespace to syncer

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 22 matching lines @@
 #include "sync/internal_api/public/syncable/model_type.h"
 
 class Prefservice;
 class Profile;
 class ProfileSyncService;
 
 namespace content {
 class NavigationEntry;
 }  // namespace content
 
-namespace csync {
+namespace syncer {
 class BaseTransaction;
 class ReadNode;
 class WriteTransaction;
-}  // namespace csync
+}  // namespace syncer
 
 namespace sync_pb {
 class SessionHeader;
 class SessionSpecifics;
 class SessionTab;
 class SessionWindow;
 class TabNavigation;
 }  // namespace sync_pb
 
 namespace browser_sync {
@@ skipping 21 matching lines @@
 
   // AssociatorInterface and PerDataTypeAssociator Interface implementation.
   virtual void AbortAssociation() OVERRIDE {
     // No implementation needed, this associator runs on the main thread.
   }
 
   // See ModelAssociator interface.
   virtual bool CryptoReadyIfNecessary() OVERRIDE;
 
   // Returns sync id for the given chrome model id.
-  // Returns csync::kInvalidId if the sync node is not found for the given
+  // Returns syncer::kInvalidId if the sync node is not found for the given
   // chrome id.
   virtual int64 GetSyncIdFromChromeId(const size_t& id) OVERRIDE;
 
   // Returns sync id for the given session tag.
-  // Returns csync::kInvalidId if the sync node is not found for the given
+  // Returns syncer::kInvalidId if the sync node is not found for the given
   // tag
   virtual int64 GetSyncIdFromSessionTag(const std::string& tag);
 
   // Not used.
   virtual const SyncedTabDelegate* GetChromeNodeFromSyncId(int64 sync_id)
       OVERRIDE;
 
   // Not used.
   virtual bool InitSyncNodeFromChromeId(const size_t& id,
-                                        csync::BaseNode* sync_node) OVERRIDE;
+                                        syncer::BaseNode* sync_node) OVERRIDE;
 
   // Not used.
   virtual void Associate(const SyncedTabDelegate* tab, int64 sync_id) OVERRIDE;
 
   // Not used.
   virtual void Disassociate(int64 sync_id) OVERRIDE;
 
   // Resync local window information. Updates the local sessions header node
   // with the status of open windows and the order of tabs they contain. Should
   // only be called for changes that affect a window, not a change within a
   // single tab.
   //
   // If |reload_tabs| is true, will also resync all tabs (same as calling
   // AssociateTabs with a vector of all tabs).
   // |error| gets set if any association error occurred.
   // Returns: false if the local session's sync nodes were deleted and
   // reassociation is necessary, true otherwise.
-  bool AssociateWindows(bool reload_tabs, csync::SyncError* error);
+  bool AssociateWindows(bool reload_tabs, syncer::SyncError* error);
 
   // Loads and reassociates the local tabs referenced in |tabs|.
   // |error| gets set if any association error occurred.
   // Returns: false if the local session's sync nodes were deleted and
   // reassociation is necessary, true otherwise.
   bool AssociateTabs(const std::vector<SyncedTabDelegate*>& tabs,
-                     csync::SyncError* error);
+                     syncer::SyncError* error);
 
   // Reassociates a single tab with the sync model. Will check if the tab
   // already is associated with a sync node and allocate one if necessary.
   // |error| gets set if any association error occurred.
   // Returns: false if the local session's sync nodes were deleted and
   // reassociation is necessary, true otherwise.
   bool AssociateTab(const SyncedTabDelegate& tab,
-                    csync::SyncError* error);
+                    syncer::SyncError* error);
 
   // Load any foreign session info stored in sync db and update the sync db
   // with local client data. Processes/reuses any sync nodes owned by this
   // client and creates any further sync nodes needed to store local header and
   // tab info.
-  virtual csync::SyncError AssociateModels() OVERRIDE;
+  virtual syncer::SyncError AssociateModels() OVERRIDE;
 
   // Initializes the given sync node from the given chrome node id.
   // Returns false if no sync node was found for the given chrome node id or
   // if the initialization of sync node fails.
   virtual bool InitSyncNodeFromChromeId(const std::string& id,
-                                        csync::BaseNode* sync_node);
+                                        syncer::BaseNode* sync_node);
 
   // Clear local sync data buffers. Does not delete sync nodes to avoid
   // tombstones. TODO(zea): way to eventually delete orphaned nodes.
-  virtual csync::SyncError DisassociateModels() OVERRIDE;
+  virtual syncer::SyncError DisassociateModels() OVERRIDE;
 
   // Returns the tag used to uniquely identify this machine's session in the
   // sync model.
   const std::string& GetCurrentMachineTag() const {
     DCHECK(!current_machine_tag_.empty());
     return current_machine_tag_;
   }
 
   // Load and associate window and tab data for a foreign session.
   void AssociateForeignSpecifics(const sync_pb::SessionSpecifics& specifics,
@@ skipping 141 matching lines @@
     // 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).
     void AddTabNode(int64 sync_id);
 
     // Returns the sync_id for the next free tab node. If none are available,
     // creates a new tab node.
     // Note: We make use of the following "id's"
-    // - a sync_id: an int64 used in |csync::InitByIdLookup|
+    // - a sync_id: an int64 used in |syncer::InitByIdLookup|
     // - 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_%ui", local_session_tag, tab_node_id);
     // tab_node_id and sync_id are both unique to a particular sync node. The
     // difference is that tab_node_id is controlled by the model associator and
     // is used when creating a new sync node, which returns the sync_id, created
     // by the sync db.
     int64 GetFreeTabNode();
 
@@ skipping 54 matching lines @@
   static bool ShouldSyncWindow(const SyncedWindowDelegate* window);
 
   // Build a sync tag from tab_node_id.
   static std::string TabIdToTag(
       const std::string machine_tag,
       size_t tab_node_id) {
     return base::StringPrintf("%s %"PRIuS"", machine_tag.c_str(), tab_node_id);
   }
 
   // Initializes the tag corresponding to this machine.
-  void InitializeCurrentMachineTag(csync::WriteTransaction* trans);
+  void InitializeCurrentMachineTag(syncer::WriteTransaction* trans);
 
   // Initializes the user visible name for this session
   void InitializeCurrentSessionName();
 
   // Updates the server data based upon the current client session.  If no node
   // corresponding to this machine exists in the sync model, one is created.
   // Returns true on success, false if association failed.
-  bool UpdateSyncModelDataFromClient(csync::SyncError* error);
+  bool UpdateSyncModelDataFromClient(syncer::SyncError* error);
 
   // Pulls the current sync model from the sync database and returns true upon
   // update of the client model. Will associate any foreign sessions as well as
   // keep track of any local tab nodes, adding them to our free tab node pool.
-  bool UpdateAssociationsFromSyncModel(const csync::ReadNode& root,
-                                       csync::WriteTransaction* trans,
-                                       csync::SyncError* error);
+  bool UpdateAssociationsFromSyncModel(const syncer::ReadNode& root,
+                                       syncer::WriteTransaction* trans,
+                                       syncer::SyncError* error);
 
   // Fills a tab sync node with data from a WebContents 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,
-                                   csync::SyncError* error);
+                                   syncer::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(const 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
@@ skipping 136 matching lines @@
   std::map<std::string, linked_ptr<SyncedFaviconInfo> > synced_favicons_;
   // 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_