[Sync] Rename wifi_sync to sync_wifi.

components/sync_wifi/wifi_config_delegate_chromeos_unittest.cc

 // Copyright 2015 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_config_delegate_chromeos.h"
+#include "components/sync_wifi/wifi_config_delegate_chromeos.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_handler_callbacks.h"
-#include "components/wifi_sync/wifi_credential.h"
+#include "components/sync_wifi/wifi_credential.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace wifi_sync {
+namespace sync_wifi {
 
 namespace {
 const char kSsid[] = "fake-ssid";
 const char kSsidNonUtf8[] = "\xc0";
 const char kUserHash[] = "fake-user-hash";
 }
 
 using chromeos::network_handler::DictionaryResultCallback;
 using chromeos::network_handler::ErrorCallback;
 using chromeos::network_handler::ServiceResultCallback;
 
 class FakeManagedNetworkConfigurationHandler
     : public chromeos::ManagedNetworkConfigurationHandler {
  public:
   FakeManagedNetworkConfigurationHandler()
-      : create_configuration_called_(false) {
-  }
+      : create_configuration_called_(false) {}
 
   // ManagedNetworkConfigurationHandler implementation.
   void AddObserver(chromeos::NetworkPolicyObserver* observer) override {
     NOTIMPLEMENTED();
   }
   void RemoveObserver(chromeos::NetworkPolicyObserver* observer) override {
     NOTIMPLEMENTED();
   }
-  void GetProperties(
-      const std::string& userhash,
-      const std::string& service_path,
-      const DictionaryResultCallback& callback,
-      const ErrorCallback& error_callback) override {
+  void GetProperties(const std::string& userhash,
+                     const std::string& service_path,
+                     const DictionaryResultCallback& callback,
+                     const ErrorCallback& error_callback) override {
     NOTIMPLEMENTED();
   }
-  void GetManagedProperties(
-      const std::string& userhash,
-      const std::string& service_path,
-      const DictionaryResultCallback& callback,
-      const ErrorCallback& error_callback) override {
+  void GetManagedProperties(const std::string& userhash,
+                            const std::string& service_path,
+                            const DictionaryResultCallback& callback,
+                            const ErrorCallback& error_callback) override {
     NOTIMPLEMENTED();
   }
-  void SetProperties(
-      const std::string& service_path,
-      const base::DictionaryValue& user_settings,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) override {
+  void SetProperties(const std::string& service_path,
+                     const base::DictionaryValue& user_settings,
+                     const base::Closure& callback,
+                     const ErrorCallback& error_callback) override {
     NOTIMPLEMENTED();
   }
   void CreateConfiguration(const std::string& userhash,
                            const base::DictionaryValue& properties,
                            const ServiceResultCallback& callback,
                            const ErrorCallback& error_callback) const override {
     EXPECT_FALSE(create_configuration_called_);
     create_configuration_called_ = true;
     create_configuration_success_callback_ = callback;
     create_configuration_error_callback_ = error_callback;
   }
-  void RemoveConfiguration(
-      const std::string& service_path,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) const override {
+  void RemoveConfiguration(const std::string& service_path,
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) const override {
     NOTIMPLEMENTED();
   }
-  void SetPolicy(
-      ::onc::ONCSource onc_source,
-      const std::string& userhash,
-      const base::ListValue& network_configs_onc,
-      const base::DictionaryValue& global_network_config) override {
+  void SetPolicy(::onc::ONCSource onc_source,
+                 const std::string& userhash,
+                 const base::ListValue& network_configs_onc,
+                 const base::DictionaryValue& global_network_config) override {
     NOTIMPLEMENTED();
   }
   bool IsAnyPolicyApplicationRunning() const override {
     NOTIMPLEMENTED();
     return false;
   }
   const base::DictionaryValue* FindPolicyByGUID(
       const std::string userhash,
       const std::string& guid,
       ::onc::ONCSource* onc_source) const override {
@@ skipping 33 matching lines @@
   // The last |callback| passed to CreateConfiguration.
   mutable ServiceResultCallback create_configuration_success_callback_;
   // The last |error_callback| passed to CreateConfiguration.
   mutable ErrorCallback create_configuration_error_callback_;
 };
 
 class WifiConfigDelegateChromeOsTest : public testing::Test {
  protected:
   WifiConfigDelegateChromeOsTest()
       : fake_managed_network_configuration_handler_(
-          new FakeManagedNetworkConfigurationHandler()) {
-    config_delegate_.reset(
-        new WifiConfigDelegateChromeOs(
-            kUserHash,
-            fake_managed_network_configuration_handler_.get()));
+            new FakeManagedNetworkConfigurationHandler()) {
+    config_delegate_.reset(new WifiConfigDelegateChromeOs(
+        kUserHash, fake_managed_network_configuration_handler_.get()));
   }
 
   // Wrapper for WifiConfigDelegateChromeOs::AddToLocalNetworks.
   void AddToLocalNetworks(const WifiCredential& network_credential) {
     config_delegate_->AddToLocalNetworks(network_credential);
   }
 
   // Returns a new WifiCredential constructed from the given parameters.
   WifiCredential MakeCredential(const std::string& ssid,
                                 WifiSecurityClass security_class,
@@ skipping 66 matching lines @@
        AddToLocalNetworksCreateConfigurationFailure) {
   AddToLocalNetworks(MakeCredential(kSsid, SECURITY_CLASS_NONE, ""));
   EXPECT_TRUE(create_configuration_called());
   if (!create_configuration_error_callback().is_null()) {
     create_configuration_error_callback().Run(
         "Config.CreateConfiguration Failed",
         base::MakeUnique<base::DictionaryValue>());
   }
 }
 
-}  // namespace wifi_sync
+}  // namespace sync_wifi