[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/session_model_associator.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/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 62 matching lines @@
   // sync_manager.cc[1060]
 #if defined(OS_CHROMEOS)
   return sync_pb::SessionHeader_DeviceType_TYPE_CROS;
 #elif defined(OS_LINUX)
   return sync_pb::SessionHeader_DeviceType_TYPE_LINUX;
 #elif defined(OS_MACOSX)
   return sync_pb::SessionHeader_DeviceType_TYPE_MAC;
 #elif defined(OS_WIN)
   return sync_pb::SessionHeader_DeviceType_TYPE_WIN;
 #elif defined(OS_ANDROID)
-  return csync::internal::IsTabletUi() ?
+  return syncer::internal::IsTabletUi() ?
       sync_pb::SessionHeader_DeviceType_TYPE_TABLET :
       sync_pb::SessionHeader_DeviceType_TYPE_PHONE;
 #else
   return sync_pb::SessionHeader_DeviceType_TYPE_OTHER;
 #endif
 }
 
 }  // namespace
 
 SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service,
     DataTypeErrorHandler* error_handler)
     : tab_pool_(sync_service),
-      local_session_syncid_(csync::kInvalidId),
+      local_session_syncid_(syncer::kInvalidId),
       sync_service_(sync_service),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       setup_for_test_(false),
       waiting_for_change_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(test_weak_factory_(this)),
       profile_(sync_service->profile()),
       pref_service_(profile_->GetPrefs()),
       error_handler_(error_handler) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_service_);
   DCHECK(profile_);
   if (pref_service_->FindPreference(kSyncSessionsGUID) == NULL) {
     pref_service_->RegisterStringPref(kSyncSessionsGUID,
                                       std::string(),
                                       PrefService::UNSYNCABLE_PREF);
   }
 }
 
 SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service,
                                                bool setup_for_test)
     : tab_pool_(sync_service),
-      local_session_syncid_(csync::kInvalidId),
+      local_session_syncid_(syncer::kInvalidId),
       sync_service_(sync_service),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       setup_for_test_(setup_for_test),
       waiting_for_change_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(test_weak_factory_(this)),
       profile_(sync_service->profile()),
       pref_service_(NULL),
       error_handler_(NULL) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_service_);
   DCHECK(profile_);
   DCHECK(setup_for_test);
 }
 
 SessionModelAssociator::~SessionModelAssociator() {
   DCHECK(CalledOnValidThread());
 }
 
 bool SessionModelAssociator::InitSyncNodeFromChromeId(
     const std::string& id,
-    csync::BaseNode* sync_node) {
+    syncer::BaseNode* sync_node) {
   NOTREACHED();
   return false;
 }
 
 bool SessionModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   CHECK(has_nodes);
   *has_nodes = false;
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::ReadNode root(&trans);
-  if (root.InitByTagLookup(kSessionsTag) != csync::BaseNode::INIT_OK) {
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadNode root(&trans);
+  if (root.InitByTagLookup(kSessionsTag) != syncer::BaseNode::INIT_OK) {
     LOG(ERROR) << kNoSessionsFolderError;
     return false;
   }
   // The sync model has user created nodes iff the sessions folder has
   // any children.
   *has_nodes = root.HasChildren();
   return true;
 }
 
 int64 SessionModelAssociator::GetSyncIdFromChromeId(const size_t& id) {
   DCHECK(CalledOnValidThread());
   return GetSyncIdFromSessionTag(TabIdToTag(GetCurrentMachineTag(), id));
 }
 
 int64 SessionModelAssociator::GetSyncIdFromSessionTag(const std::string& tag) {
   DCHECK(CalledOnValidThread());
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::ReadNode node(&trans);
-  if (node.InitByClientTagLookup(SESSIONS, tag) != csync::BaseNode::INIT_OK)
-    return csync::kInvalidId;
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadNode node(&trans);
+  if (node.InitByClientTagLookup(SESSIONS, tag) != syncer::BaseNode::INIT_OK)
+    return syncer::kInvalidId;
   return node.GetId();
 }
 
 const SyncedTabDelegate*
 SessionModelAssociator::GetChromeNodeFromSyncId(int64 sync_id) {
   NOTREACHED();
   return NULL;
 }
 
 bool SessionModelAssociator::InitSyncNodeFromChromeId(
     const size_t& id,
-    csync::BaseNode* sync_node) {
+    syncer::BaseNode* sync_node) {
   NOTREACHED();
   return false;
 }
 
 bool SessionModelAssociator::AssociateWindows(bool reload_tabs,
-                                              csync::SyncError* error) {
+                                              syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   std::string local_tag = GetCurrentMachineTag();
   sync_pb::SessionSpecifics specifics;
   specifics.set_session_tag(local_tag);
   sync_pb::SessionHeader* header_s = specifics.mutable_header();
   SyncedSession* current_session =
       synced_session_tracker_.GetSession(local_tag);
   current_session->modified_time = base::Time::Now();
   header_s->set_client_name(current_session_name_);
   header_s->set_device_type(GetLocalDeviceType());
@@ skipping 67 matching lines @@
             window_s,
             base::Time::Now(),
             current_session->windows[window_id],
             &synced_session_tracker_);
       }
     }
   }
   // Free memory for closed windows and tabs.
   synced_session_tracker_.CleanupSession(local_tag);
 
-  csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::WriteNode header_node(&trans);
+  syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::WriteNode header_node(&trans);
   if (header_node.InitByIdLookup(local_session_syncid_) !=
-          csync::BaseNode::INIT_OK) {
+          syncer::BaseNode::INIT_OK) {
     if (error) {
       *error = error_handler_->CreateAndUploadError(
            FROM_HERE,
            "Failed to load local session header node.",
            model_type());
     }
     return false;
   }
   header_node.SetSessionSpecifics(specifics);
   if (waiting_for_change_) QuitLoopForSubtleTesting();
   return true;
 }
 
 // Static.
 bool SessionModelAssociator::ShouldSyncWindow(
     const SyncedWindowDelegate* window) {
   if (window->IsApp())
     return false;
   return window->IsTypeTabbed() || window->IsTypePopup();
 }
 
 bool SessionModelAssociator::AssociateTabs(
     const std::vector<SyncedTabDelegate*>& tabs,
-    csync::SyncError* error) {
+    syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   for (std::vector<SyncedTabDelegate*>::const_iterator i = tabs.begin();
        i != tabs.end();
        ++i) {
     if (!AssociateTab(**i, error))
       return false;
   }
   if (waiting_for_change_) QuitLoopForSubtleTesting();
   return true;
 }
 
 bool SessionModelAssociator::AssociateTab(const SyncedTabDelegate& tab,
-                                          csync::SyncError* error) {
+                                          syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   int64 sync_id;
   SessionID::id_type tab_id = tab.GetSessionId();
   if (tab.IsBeingDestroyed()) {
     // This tab is closing.
     TabLinksMap::iterator tab_iter = tab_map_.find(tab_id);
     if (tab_iter == tab_map_.end()) {
       // We aren't tracking this tab (for example, sync setting page).
       return true;
     }
     tab_pool_.FreeTabNode(tab_iter->second->sync_id());
     load_consumer_.CancelAllRequestsForClientData(tab_id);
     tab_map_.erase(tab_iter);
     return true;
   }
 
   if (!ShouldSyncTab(tab))
     return true;
 
   TabLinksMap::iterator tab_map_iter = tab_map_.find(tab_id);
   TabLink* tab_link = NULL;
   if (tab_map_iter == tab_map_.end()) {
     // This is a new tab, get a sync node for it.
     sync_id = tab_pool_.GetFreeTabNode();
-    if (sync_id == csync::kInvalidId) {
+    if (sync_id == syncer::kInvalidId) {
       if (error) {
         *error = error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Received invalid tab node from tab pool.",
             model_type());
       }
       return false;
     }
     tab_link = new TabLink(sync_id, &tab);
     tab_map_[tab_id] = make_linked_ptr<TabLink>(tab_link);
   } else {
     // This tab is already associated with a sync node, reuse it.
     // Note: on some platforms the tab object may have changed, so we ensure
     // the tab link is up to date.
     tab_link = tab_map_iter->second.get();
     tab_map_iter->second->set_tab(&tab);
   }
   DCHECK(tab_link);
-  DCHECK_NE(tab_link->sync_id(), csync::kInvalidId);
+  DCHECK_NE(tab_link->sync_id(), syncer::kInvalidId);
 
   DVLOG(1) << "Reloading tab " << tab_id << " from window "
            << tab.GetWindowId();
   return WriteTabContentsToSyncModel(tab_link, error);
 }
 
 bool SessionModelAssociator::WriteTabContentsToSyncModel(
     TabLink* tab_link,
-    csync::SyncError* error) {
+    syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   const SyncedTabDelegate& tab = *(tab_link->tab());
   const SyncedWindowDelegate& window =
       *SyncedWindowDelegate::FindSyncedWindowDelegateWithId(
           tab.GetWindowId());
   int64 sync_id = tab_link->sync_id();
   GURL old_tab_url = tab_link->url();
 
   // Load the last stored version of this tab so we can compare changes. If this
   // is a new tab, session_tab will be a blank/newly created SessionTab object.
@@ skipping 13 matching lines @@
   // transaction to avoid jank.
   tab_link->set_url(new_url);
   if (new_url != old_tab_url) {
     LoadFaviconForTab(tab_link);
   }
 
   // Update our last modified time.
   synced_session_tracker_.GetSession(GetCurrentMachineTag())->modified_time =
       base::Time::Now();
 
-  csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::WriteNode tab_node(&trans);
-  if (tab_node.InitByIdLookup(sync_id) != csync::BaseNode::INIT_OK) {
+  syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::WriteNode tab_node(&trans);
+  if (tab_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
     if (error) {
       *error = error_handler_->CreateAndUploadError(
           FROM_HERE,
           "Failed to look up local tab node",
           model_type());
     }
     return false;
   }
 
   if (new_url == old_tab_url) {
@@ skipping 83 matching lines @@
 
       // If this navigation is an old one, reuse the old timestamp. Otherwise we
       // leave the timestamp as the current time.
       if (prev_nav_iter != prev_tab->synced_tab_navigations.end() &&
           prev_nav_iter->unique_id() == entry->GetUniqueID()) {
         // Check that we haven't gone back/foward in the nav stack to this page
         // (if so, we want to refresh the timestamp).
         if (!(current_index != prev_tab->current_navigation_index &&
               current_index == i)) {
           sync_nav->set_timestamp(
-              csync::TimeToProtoTime(prev_nav_iter->timestamp()));
+              syncer::TimeToProtoTime(prev_nav_iter->timestamp()));
           DVLOG(2) << "Nav to " << sync_nav->virtual_url() << " already known, "
                    << "reusing old timestamp " << sync_nav->timestamp();
         }
         // Even if the user went back in their history, they may have skipped
         // over navigations, so the subsequent navigation entries may need their
         // old timestamps preserved.
         ++prev_nav_iter;
       } else if (current_index != i &&
                  prev_tab->synced_tab_navigations.empty()) {
         // If this is a new tab, and has more than one navigation, we don't
@@ skipping 53 matching lines @@
   DCHECK(tab_link);
   DCHECK(tab_link->url().is_valid());
   // The tab_link holds the current url. Because this load request would have
   // been canceled if the url had changed, we know the url must still be
   // up to date.
 
   if (favicon.is_valid()) {
     DCHECK_EQ(handle, tab_link->favicon_load_handle());
     tab_link->set_favicon_load_handle(0);
     DCHECK_EQ(favicon.icon_type, history::FAVICON);
-    DCHECK_NE(tab_link->sync_id(), csync::kInvalidId);
+    DCHECK_NE(tab_link->sync_id(), syncer::kInvalidId);
     // Load the sync tab node and update the favicon data.
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::WriteNode tab_node(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteNode tab_node(&trans);
     if (tab_node.InitByIdLookup(tab_link->sync_id()) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       LOG(WARNING) << "Failed to load sync tab node for tab id " << tab_id
                    << " and url " << tab_link->url().spec();
       return;
     }
     sync_pb::SessionSpecifics session_specifics =
         tab_node.GetSessionSpecifics();
     DCHECK(session_specifics.has_tab());
     sync_pb::SessionTab* tab = session_specifics.mutable_tab();
     if (favicon.image_data->size() > 0) {
       DVLOG(1) << "Storing session favicon for "
@@ skipping 110 matching lines @@
     case content::PAGE_TRANSITION_SERVER_REDIRECT:
       tab_navigation->set_navigation_qualifier(
         sync_pb::SyncEnums_PageTransitionQualifier_SERVER_REDIRECT);
       break;
     default:
       tab_navigation->set_page_transition(
         sync_pb::SyncEnums_PageTransition_TYPED);
   }
   tab_navigation->set_unique_id(navigation.GetUniqueID());
   tab_navigation->set_timestamp(
-      csync::TimeToProtoTime(base::Time::Now()));
+      syncer::TimeToProtoTime(base::Time::Now()));
 }
 
 void SessionModelAssociator::Associate(const SyncedTabDelegate* tab,
                                        int64 sync_id) {
   NOTIMPLEMENTED();
 }
 
 void SessionModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-csync::SyncError SessionModelAssociator::AssociateModels() {
+syncer::SyncError SessionModelAssociator::AssociateModels() {
   DCHECK(CalledOnValidThread());
-  csync::SyncError error;
+  syncer::SyncError error;
 
   // Ensure that we disassociated properly, otherwise memory might leak.
   DCHECK(synced_session_tracker_.Empty());
   DCHECK_EQ(0U, tab_pool_.capacity());
 
-  local_session_syncid_ = csync::kInvalidId;
+  local_session_syncid_ = syncer::kInvalidId;
 
   // Read any available foreign sessions and load any session data we may have.
   // If we don't have any local session data in the db, create a header node.
   {
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
-    csync::ReadNode root(&trans);
+    syncer::ReadNode root(&trans);
     if (root.InitByTagLookup(syncable::ModelTypeToRootTag(model_type())) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           FROM_HERE,
           kNoSessionsFolderError,
           model_type());
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty()) {
       InitializeCurrentMachineTag(&trans);
       // The session name is retrieved asynchronously so it might not come back
       // for the writing of the session. However, we write to the session often
       // enough (on every navigation) that we'll pick it up quickly.
       InitializeCurrentSessionName();
     }
     synced_session_tracker_.SetLocalSessionTag(current_machine_tag_);
     if (!UpdateAssociationsFromSyncModel(root, &trans, &error)) {
       DCHECK(error.IsSet());
       return error;
     }
 
-    if (local_session_syncid_ == csync::kInvalidId) {
+    if (local_session_syncid_ == syncer::kInvalidId) {
       // The sync db didn't have a header node for us, we need to create one.
-      csync::WriteNode write_node(&trans);
-      csync::WriteNode::InitUniqueByCreationResult result =
+      syncer::WriteNode write_node(&trans);
+      syncer::WriteNode::InitUniqueByCreationResult result =
           write_node.InitUniqueByCreation(SESSIONS, root, current_machine_tag_);
-      if (result != csync::WriteNode::INIT_SUCCESS) {
+      if (result != syncer::WriteNode::INIT_SUCCESS) {
         // If we can't look it up, and we can't create it, chances are there's
         // a pre-existing node that has encryption issues. But, since we can't
         // load the item, we can't remove it, and error out at this point.
         return error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to create sessions header sync node.",
             model_type());
       }
 
       // Write the initial values to the specifics so that in case of a crash or
@@ skipping 14 matching lines @@
   if (!UpdateSyncModelDataFromClient(&error)) {
     DCHECK(error.IsSet());
     return error;
   }
 
   DVLOG(1) << "Session models associated.";
   DCHECK(!error.IsSet());
   return error;
 }
 
-csync::SyncError SessionModelAssociator::DisassociateModels() {
+syncer::SyncError SessionModelAssociator::DisassociateModels() {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "Disassociating local session " << GetCurrentMachineTag();
   synced_session_tracker_.Clear();
   tab_map_.clear();
   tab_pool_.clear();
-  local_session_syncid_ = csync::kInvalidId;
+  local_session_syncid_ = syncer::kInvalidId;
   current_machine_tag_ = "";
   current_session_name_ = "";
   load_consumer_.CancelAllRequests();
   synced_favicons_.clear();
   synced_favicon_pages_.clear();
 
   // There is no local model stored with which to disassociate, just notify
   // foreign session handlers.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
       content::Source<Profile>(sync_service_->profile()),
       content::NotificationService::NoDetails());
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 void SessionModelAssociator::InitializeCurrentMachineTag(
-    csync::WriteTransaction* trans) {
+    syncer::WriteTransaction* trans) {
   DCHECK(CalledOnValidThread());
   DCHECK(current_machine_tag_.empty());
   std::string persisted_guid;
   if (pref_service_)
     persisted_guid = pref_service_->GetString(kSyncSessionsGUID);
   if (!persisted_guid.empty()) {
     current_machine_tag_ = persisted_guid;
     DVLOG(1) << "Restoring persisted session sync guid: "
              << persisted_guid;
   } else {
@@ skipping 40 matching lines @@
   DCHECK(CalledOnValidThread());
   if (setup_for_test_) {
     // We post this task to break out of any transactional locks a caller may be
     // holding.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&SessionModelAssociator::OnSessionNameInitialized,
                    AsWeakPtr(),
                    std::string("TestSessionName")));
   } else {
-    csync::GetSessionName(
+    syncer::GetSessionName(
         BrowserThread::GetBlockingPool(),
         base::Bind(&SessionModelAssociator::OnSessionNameInitialized,
                    AsWeakPtr()));
   }
 }
 
 bool SessionModelAssociator::UpdateAssociationsFromSyncModel(
-    const csync::ReadNode& root,
-    csync::WriteTransaction* trans,
-    csync::SyncError* error) {
+    const syncer::ReadNode& root,
+    syncer::WriteTransaction* trans,
+    syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   DCHECK(tab_pool_.empty());
-  DCHECK_EQ(local_session_syncid_, csync::kInvalidId);
+  DCHECK_EQ(local_session_syncid_, syncer::kInvalidId);
 
   // Iterate through the nodes and associate any foreign sessions.
   int64 id = root.GetFirstChildId();
-  while (id != csync::kInvalidId) {
-    csync::WriteNode sync_node(trans);
-    if (sync_node.InitByIdLookup(id) != csync::BaseNode::INIT_OK) {
+  while (id != syncer::kInvalidId) {
+    syncer::WriteNode sync_node(trans);
+    if (sync_node.InitByIdLookup(id) != syncer::BaseNode::INIT_OK) {
       if (error) {
         *error = error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to load sync node",
             model_type());
       }
       return false;
     }
     int64 next_id = sync_node.GetSuccessorId();
 
     const sync_pb::SessionSpecifics& specifics =
         sync_node.GetSessionSpecifics();
     const base::Time& modification_time = sync_node.GetModificationTime();
     if (specifics.session_tag().empty()) {
       // This is a corrupted node. Just delete it.
       LOG(WARNING) << "Found node with no session tag, deleting.";
       sync_node.Remove();
     } else if (specifics.session_tag() != GetCurrentMachineTag()) {
       AssociateForeignSpecifics(specifics, modification_time);
     } else {
       // This is previously stored local session information.
       if (specifics.has_header() &&
-          local_session_syncid_ == csync::kInvalidId) {
+          local_session_syncid_ == syncer::kInvalidId) {
         // This is our previous header node, reuse it.
         local_session_syncid_ = id;
         if (specifics.header().has_client_name()) {
           current_session_name_ = specifics.header().client_name();
         }
       } else {
         if (specifics.has_header()) {
           LOG(WARNING) << "Found more than one session header node with local "
                        << " tag.";
         } else if (!specifics.has_tab()) {
@@ skipping 317 matching lines @@
             break;
             case sync_pb::SyncEnums_PageTransitionQualifier_SERVER_REDIRECT:
             transition = content::PAGE_TRANSITION_SERVER_REDIRECT;
               break;
             default:
             transition = content::PAGE_TRANSITION_TYPED;
         }
     }
   }
   if (specifics.has_timestamp()) {
-    timestamp = csync::ProtoTimeToTime(specifics.timestamp());
+    timestamp = syncer::ProtoTimeToTime(specifics.timestamp());
   }
   if (specifics.has_unique_id()) {
     unique_id = specifics.unique_id();
   }
   SyncedTabNavigation tab_navigation(
       index, virtual_url,
       content::Referrer(referrer, WebKit::WebReferrerPolicyDefault), title,
       state, transition, unique_id, timestamp);
   // We insert it twice, once for our SyncedTabNavigations, once for the normal
   // TabNavigation (used by the session restore UI).
@@ skipping 35 matching lines @@
     synced_favicons_[favicon_source.spec()] =
         make_linked_ptr<SyncedFaviconInfo>(new SyncedFaviconInfo(favicon));
   } else {
     favicon_iter->second->data = favicon;
     ++favicon_iter->second->usage_count;
   }
   synced_favicon_pages_[navigation_url.spec()] = favicon_source.spec();
 }
 
 bool SessionModelAssociator::UpdateSyncModelDataFromClient(
-    csync::SyncError* error) {
+    syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
 
   // Associate all open windows and their tabs.
   return AssociateWindows(true, error);
 }
 
 SessionModelAssociator::TabNodePool::TabNodePool(
     ProfileSyncService* sync_service)
     : tab_pool_fp_(-1),
       sync_service_(sync_service) {
 }
 
 SessionModelAssociator::TabNodePool::~TabNodePool() {}
 
 void SessionModelAssociator::TabNodePool::AddTabNode(int64 sync_id) {
   tab_syncid_pool_.resize(tab_syncid_pool_.size() + 1);
   tab_syncid_pool_[static_cast<size_t>(++tab_pool_fp_)] = sync_id;
 }
 
 int64 SessionModelAssociator::TabNodePool::GetFreeTabNode() {
   DCHECK_GT(machine_tag_.length(), 0U);
   if (tab_pool_fp_ == -1) {
     // Tab pool has no free nodes, allocate new one.
-    csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-    csync::ReadNode root(&trans);
-    if (root.InitByTagLookup(kSessionsTag) != csync::BaseNode::INIT_OK) {
+    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadNode root(&trans);
+    if (root.InitByTagLookup(kSessionsTag) != syncer::BaseNode::INIT_OK) {
       LOG(ERROR) << kNoSessionsFolderError;
-      return csync::kInvalidId;
+      return syncer::kInvalidId;
     }
     size_t tab_node_id = tab_syncid_pool_.size();
     std::string tab_node_tag = TabIdToTag(machine_tag_, tab_node_id);
-    csync::WriteNode tab_node(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode tab_node(&trans);
+    syncer::WriteNode::InitUniqueByCreationResult result =
         tab_node.InitUniqueByCreation(SESSIONS, root, tab_node_tag);
-    if (result != csync::WriteNode::INIT_SUCCESS) {
+    if (result != syncer::WriteNode::INIT_SUCCESS) {
       LOG(ERROR) << "Could not create new node with tag "
                  << tab_node_tag << "!";
-      return csync::kInvalidId;
+      return syncer::kInvalidId;
     }
     // We fill the new node with just enough data so that in case of a crash/bug
     // we can identify the node as our own on re-association and reuse it.
     tab_node.SetTitle(UTF8ToWide(tab_node_tag));
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(machine_tag_);
     specifics.set_tab_node_id(tab_node_id);
     tab_node.SetSessionSpecifics(specifics);
 
     // Grow the pool by 1 since we created a new node. We don't actually need
@@ skipping 106 matching lines @@
     LOG(ERROR) << "Attempting to delete local session. This is not currently "
                << "supported.";
     return;
   }
 
   if (!DisassociateForeignSession(tag)) {
     // We don't have any data for this session, our work here is done!
     return;
   }
 
-  csync::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
-  csync::ReadNode root(&trans);
-  if (root.InitByTagLookup(kSessionsTag) != csync::BaseNode::INIT_OK) {
+  syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadNode root(&trans);
+  if (root.InitByTagLookup(kSessionsTag) != syncer::BaseNode::INIT_OK) {
     LOG(ERROR) << kNoSessionsFolderError;
     return;
   }
   int64 id = root.GetFirstChildId();
-  while (id != csync::kInvalidId) {
-    csync::WriteNode sync_node(&trans);
-    if (sync_node.InitByIdLookup(id) != csync::BaseNode::INIT_OK) {
+  while (id != syncer::kInvalidId) {
+    syncer::WriteNode sync_node(&trans);
+    if (sync_node.InitByIdLookup(id) != syncer::BaseNode::INIT_OK) {
       LOG(ERROR) << "Failed to fetch sync node for id " << id;
       continue;
     }
     id = sync_node.GetSuccessorId();
     const sync_pb::SessionSpecifics& specifics =
         sync_node.GetSessionSpecifics();
     if (specifics.session_tag() == tag)
       sync_node.Remove();
   }
 }
@@ skipping 57 matching lines @@
   waiting_for_change_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&SessionModelAssociator::QuitLoopForSubtleTesting,
                  test_weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(timeout_milliseconds));
 }
 
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
-  csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+  syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncable::ModelTypeSet encrypted_types =
-      csync::GetEncryptedTypes(&trans);
+      syncer::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync