[Sync] Rename csync namespace to syncer

sync/engine/nigori_util.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 "sync/engine/nigori_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncable {
 
 bool ProcessUnsyncedChangesForEncryption(
     WriteTransaction* const trans,
-    csync::Cryptographer* cryptographer) {
+    syncer::Cryptographer* cryptographer) {
   DCHECK(cryptographer->is_ready());
   // Get list of all datatypes with unsynced changes. It's possible that our
   // local changes need to be encrypted if encryption for that datatype was
   // just turned on (and vice versa).
   // Note: we do not attempt to re-encrypt data with a new key here as key
   // changes in this code path are likely due to consistency issues (we have
   // to be updated to a key we already have, e.g. an old key).
   std::vector<int64> handles;
-  csync::SyncerUtil::GetUnsyncedEntries(trans, &handles);
+  syncer::SyncerUtil::GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     MutableEntry entry(trans, GET_BY_HANDLE, handles[i]);
     const sync_pb::EntitySpecifics& specifics = entry.Get(SPECIFICS);
     // Ignore types that don't need encryption or entries that are already
     // encrypted.
     if (!SpecificsNeedsEncryption(cryptographer->GetEncryptedTypes(),
                                   specifics)) {
       continue;
     }
     if (!UpdateEntryWithEncryption(cryptographer, specifics, &entry)) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool VerifyUnsyncedChangesAreEncrypted(
     BaseTransaction* const trans,
     ModelTypeSet encrypted_types) {
   std::vector<int64> handles;
-  csync::SyncerUtil::GetUnsyncedEntries(trans, &handles);
+  syncer::SyncerUtil::GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     Entry entry(trans, GET_BY_HANDLE, handles[i]);
     if (!entry.good()) {
       NOTREACHED();
       return false;
     }
     if (EntryNeedsEncryption(encrypted_types, entry))
       return false;
   }
   return true;
@@ skipping 20 matching lines @@
   if (type == PASSWORDS || type == NIGORI)
     return false;  // These types have their own encryption schemes.
   if (!encrypted_types.Has(type))
     return false;  // This type does not require encryption
   return !specifics.has_encrypted();
 }
 
 // Mainly for testing.
 bool VerifyDataTypeEncryptionForTest(
     BaseTransaction* const trans,
-    csync::Cryptographer* cryptographer,
+    syncer::Cryptographer* cryptographer,
     ModelType type,
     bool is_encrypted) {
   if (type == PASSWORDS || type == NIGORI) {
     NOTREACHED();
     return true;
   }
   std::string type_tag = ModelTypeToRootTag(type);
   Entry type_root(trans, GET_BY_SERVER_TAG, type_tag);
   if (!type_root.good()) {
     NOTREACHED();
@@ skipping 43 matching lines @@
           return false;
       }
     }
     // Push the successor.
     to_visit.push(child.Get(NEXT_ID));
   }
   return true;
 }
 
 bool UpdateEntryWithEncryption(
-    csync::Cryptographer* cryptographer,
+    syncer::Cryptographer* cryptographer,
     const sync_pb::EntitySpecifics& new_specifics,
     syncable::MutableEntry* entry) {
   syncable::ModelType type = syncable::GetModelTypeFromSpecifics(new_specifics);
   DCHECK_GE(type, syncable::FIRST_REAL_MODEL_TYPE);
   const sync_pb::EntitySpecifics& old_specifics = entry->Get(SPECIFICS);
   const syncable::ModelTypeSet encrypted_types =
       cryptographer->GetEncryptedTypes();
   // It's possible the nigori lost the set of encrypted types. If the current
   // specifics are already encrypted, we want to ensure we continue encrypting.
   bool was_encrypted = old_specifics.has_encrypted();
@@ skipping 70 matching lines @@
   }
   entry->Put(syncable::SPECIFICS, generated_specifics);
   DVLOG(1) << "Overwriting specifics of type "
            << syncable::ModelTypeToString(type)
            << " and marking for syncing.";
   syncable::MarkForSyncing(entry);
   return true;
 }
 
 }  // namespace syncable