[Sync] Rename wifi_sync to sync_wifi.

components/sync_wifi/wifi_credential_syncable_service.cc

 // Copyright 2014 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 "components/wifi_sync/wifi_credential_syncable_service.h"
+#include "components/sync_wifi/wifi_credential_syncable_service.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/sync_data.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_merge_result.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/wifi_sync/wifi_credential.h"
-#include "components/wifi_sync/wifi_security_class.h"
+#include "components/sync_wifi/wifi_credential.h"
+#include "components/sync_wifi/wifi_security_class.h"
 
-namespace wifi_sync {
+namespace sync_wifi {
 
 namespace {
 
 struct RawCredentialData {
   std::vector<uint8_t> ssid;
   WifiSecurityClass security_class;
   std::string passphrase;
 };
 
 void BuildSpecifics(const WifiCredential& credential,
@@ skipping 73 matching lines @@
 
 const syncer::ModelType WifiCredentialSyncableService::kModelType =
     syncer::WIFI_CREDENTIALS;
 
 WifiCredentialSyncableService::WifiCredentialSyncableService(
     std::unique_ptr<WifiConfigDelegate> network_config_delegate)
     : network_config_delegate_(std::move(network_config_delegate)) {
   DCHECK(network_config_delegate_);
 }
 
-WifiCredentialSyncableService::~WifiCredentialSyncableService() {
-}
+WifiCredentialSyncableService::~WifiCredentialSyncableService() {}
 
 syncer::SyncMergeResult WifiCredentialSyncableService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
     std::unique_ptr<syncer::SyncErrorFactory> /* error_handler */) {
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK_EQ(kModelType, type);
 
@@ skipping 70 matching lines @@
 bool WifiCredentialSyncableService::AddToSyncedNetworks(
     const std::string& item_id,
     const WifiCredential& credential) {
   if (!sync_processor_.get()) {
     // Callers must queue updates until MergeDataAndStartSyncing has
     // been called on this SyncableService.
     LOG(WARNING) << "WifiCredentials syncable service is not started.";
     return false;
   }
 
-  const SsidAndSecurityClass network_id(
-      credential.ssid(), credential.security_class());
+  const SsidAndSecurityClass network_id(credential.ssid(),
+                                        credential.security_class());
   if (synced_networks_and_passphrases_.find(network_id) !=
       synced_networks_and_passphrases_.end()) {
     // TODO(quiche): If passphrase has changed, submit this to sync as
     // an ACTION_UPDATE. crbug.com/431436
     return false;
   }
 
   syncer::SyncChangeList change_list;
   syncer::SyncError sync_error;
   sync_pb::EntitySpecifics wifi_credential_specifics;
   BuildSpecifics(credential, &wifi_credential_specifics);
   change_list.push_back(
       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD,
                          syncer::SyncData::CreateLocalData(
                              item_id, item_id, wifi_credential_specifics)));
   sync_error = sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   if (sync_error.IsSet()) {
     LOG(ERROR) << sync_error.ToString();
     return false;
   }
 
   synced_networks_and_passphrases_[network_id] = credential.passphrase();
   return true;
 }
 
-}  // namespace wifi_sync
+}  // namespace sync_wifi