[Sync] Rename csync namespace to syncer

sync/internal_api/js_sync_manager_observer_unittest.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/internal_api/js_sync_manager_observer.h"
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_test_util.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace csync {
+namespace syncer {
 namespace {
 
 using ::testing::InSequence;
 using ::testing::StrictMock;
 
 class JsSyncManagerObserverTest : public testing::Test {
  protected:
   JsSyncManagerObserverTest() {
     js_sync_manager_observer_.SetJsEventHandler(
         mock_js_event_handler_.AsWeakHandle());
@@ skipping 55 matching lines @@
 
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onSyncCycleCompleted",
                            HasDetailsAsDictionary(expected_details)));
 
   js_sync_manager_observer_.OnSyncCycleCompleted(snapshot);
   PumpLoop();
 }
 
 TEST_F(JsSyncManagerObserverTest, OnActionableError) {
-  csync::SyncProtocolError sync_error;
-  sync_error.action = csync::CLEAR_USER_DATA_AND_RESYNC;
-  sync_error.error_type = csync::TRANSIENT_ERROR;
+  syncer::SyncProtocolError sync_error;
+  sync_error.action = syncer::CLEAR_USER_DATA_AND_RESYNC;
+  sync_error.error_type = syncer::TRANSIENT_ERROR;
   DictionaryValue expected_details;
   expected_details.Set("syncError", sync_error.ToValue());
 
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onActionableError",
                            HasDetailsAsDictionary(expected_details)));
 
   js_sync_manager_observer_.OnActionableError(sync_error);
   PumpLoop();
 }
 
 
 TEST_F(JsSyncManagerObserverTest, OnConnectionStatusChange) {
-  const csync::ConnectionStatus kStatus =
-      csync::CONNECTION_AUTH_ERROR;
+  const syncer::ConnectionStatus kStatus =
+      syncer::CONNECTION_AUTH_ERROR;
   DictionaryValue expected_details;
   expected_details.SetString("status",
-                             csync::ConnectionStatusToString(kStatus));
+                             syncer::ConnectionStatusToString(kStatus));
 
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onConnectionStatusChange",
                             HasDetailsAsDictionary(expected_details)));
 
   js_sync_manager_observer_.OnConnectionStatusChange(kStatus);
   PumpLoop();
 }
 
 TEST_F(JsSyncManagerObserverTest, OnPassphraseRequired) {
   InSequence dummy;
 
   DictionaryValue reason_passphrase_not_required_details;
   DictionaryValue reason_encryption_details;
   DictionaryValue reason_decryption_details;
 
   reason_passphrase_not_required_details.SetString(
       "reason",
-      csync::PassphraseRequiredReasonToString(
-          csync::REASON_PASSPHRASE_NOT_REQUIRED));
+      syncer::PassphraseRequiredReasonToString(
+          syncer::REASON_PASSPHRASE_NOT_REQUIRED));
   reason_encryption_details.SetString(
       "reason",
-      csync::PassphraseRequiredReasonToString(csync::REASON_ENCRYPTION));
+      syncer::PassphraseRequiredReasonToString(syncer::REASON_ENCRYPTION));
   reason_decryption_details.SetString(
       "reason",
-      csync::PassphraseRequiredReasonToString(csync::REASON_DECRYPTION));
+      syncer::PassphraseRequiredReasonToString(syncer::REASON_DECRYPTION));
 
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onPassphraseRequired",
                            HasDetailsAsDictionary(
                                reason_passphrase_not_required_details)));
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onPassphraseRequired",
                            HasDetailsAsDictionary(reason_encryption_details)));
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onPassphraseRequired",
                            HasDetailsAsDictionary(reason_decryption_details)));
 
   js_sync_manager_observer_.OnPassphraseRequired(
-      csync::REASON_PASSPHRASE_NOT_REQUIRED,
+      syncer::REASON_PASSPHRASE_NOT_REQUIRED,
       sync_pb::EncryptedData());
-  js_sync_manager_observer_.OnPassphraseRequired(csync::REASON_ENCRYPTION,
+  js_sync_manager_observer_.OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                                  sync_pb::EncryptedData());
-  js_sync_manager_observer_.OnPassphraseRequired(csync::REASON_DECRYPTION,
+  js_sync_manager_observer_.OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                                  sync_pb::EncryptedData());
   PumpLoop();
 }
 
 TEST_F(JsSyncManagerObserverTest, SensitiveNotifiations) {
   DictionaryValue redacted_token_details;
   redacted_token_details.SetString("token", "<redacted>");
   DictionaryValue redacted_bootstrap_token_details;
   redacted_bootstrap_token_details.SetString("bootstrapToken", "<redacted>");
 
@@ skipping 29 matching lines @@
   EXPECT_CALL(mock_js_event_handler_,
               HandleJsEvent("onEncryptedTypesChanged",
                             HasDetailsAsDictionary(expected_details)));
 
   js_sync_manager_observer_.OnEncryptedTypesChanged(
       encrypted_types, encrypt_everything);
   PumpLoop();
 }
 
 }  // namespace
-}  // namespace csync
+}  // namespace syncer