[Sync] Put everything in sync/api into csync namespace

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 167 matching lines @@
 }
 
 bool SessionModelAssociator::InitSyncNodeFromChromeId(
     const size_t& id,
     csync::BaseNode* sync_node) {
   NOTREACHED();
   return false;
 }
 
 bool SessionModelAssociator::AssociateWindows(bool reload_tabs,
-                                              SyncError* error) {
+                                              csync::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 94 matching lines @@
 // 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,
-    SyncError* error) {
+    csync::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,
-                                          SyncError* error) {
+                                          csync::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;
     }
@@ skipping 30 matching lines @@
     tab_map_iter->second->set_tab(&tab);
   }
   DCHECK(tab_link);
   DCHECK_NE(tab_link->sync_id(), csync::kInvalidId);
 
   DVLOG(1) << "Reloading tab " << tab_id << " from window "
            << tab.GetWindowId();
   return WriteTabContentsToSyncModel(tab_link, error);
 }
 
-bool SessionModelAssociator::WriteTabContentsToSyncModel(TabLink* tab_link,
-                                                         SyncError* error) {
+bool SessionModelAssociator::WriteTabContentsToSyncModel(
+    TabLink* tab_link,
+    csync::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 342 matching lines @@
 void SessionModelAssociator::Associate(const SyncedTabDelegate* tab,
                                        int64 sync_id) {
   NOTIMPLEMENTED();
 }
 
 void SessionModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-SyncError SessionModelAssociator::AssociateModels() {
+csync::SyncError SessionModelAssociator::AssociateModels() {
   DCHECK(CalledOnValidThread());
-  SyncError error;
+  csync::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;
 
   // 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.
   {
@@ skipping 55 matching lines @@
   if (!UpdateSyncModelDataFromClient(&error)) {
     DCHECK(error.IsSet());
     return error;
   }
 
   DVLOG(1) << "Session models associated.";
   DCHECK(!error.IsSet());
   return error;
 }
 
-SyncError SessionModelAssociator::DisassociateModels() {
+csync::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;
   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 SyncError();
+  return csync::SyncError();
 }
 
 void SessionModelAssociator::InitializeCurrentMachineTag(
     csync::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()) {
@@ skipping 54 matching lines @@
     csync::GetSessionName(
         BrowserThread::GetBlockingPool(),
         base::Bind(&SessionModelAssociator::OnSessionNameInitialized,
                    AsWeakPtr()));
   }
 }
 
 bool SessionModelAssociator::UpdateAssociationsFromSyncModel(
     const csync::ReadNode& root,
     csync::WriteTransaction* trans,
-    SyncError* error) {
+    csync::SyncError* error) {
   DCHECK(CalledOnValidThread());
   DCHECK(tab_pool_.empty());
   DCHECK_EQ(local_session_syncid_, csync::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) {
       if (error) {
@@ skipping 404 matching lines @@
   if (favicon_iter == synced_favicons_.end()) {
     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(SyncError* error) {
+bool SessionModelAssociator::UpdateSyncModelDataFromClient(
+    csync::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) {
@@ skipping 239 matching lines @@
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   csync::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncable::ModelTypeSet encrypted_types =
       csync::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync