sync: add more integration tests for wifi_sync

chrome/browser/sync/test/integration/wifi_credentials_helper_chromeos.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 "chrome/browser/sync/test/integration/wifi_credentials_helper_chromeos.h"
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "chrome/browser/profiles/profile.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/stringprintf.h"
+#include "base/values.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_profile_client.h"
+#include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_handler.h"
-#include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "components/onc/onc_constants.h"
 #include "components/wifi_sync/network_state_helper_chromeos.h"
-#include "components/wifi_sync/wifi_security_class.h"
+#include "components/wifi_sync/wifi_credential_syncable_service_factory.h"
+#include "content/public/browser/browser_context.h"
+
+using wifi_sync::WifiCredential;
 
 using WifiCredentialSet = wifi_sync::WifiCredential::CredentialSet;
 
 namespace wifi_credentials_helper {
 
 namespace {
 
 const char kProfilePrefix[] = "/profile/";
 
+void LogCreateConfigurationFailure(
+    const std::string& debug_hint,
+    const std::string& /* network_config_error_message */,
+    scoped_ptr<base::DictionaryValue> /* network_config_error_data */) {
+  LOG(FATAL) << debug_hint;
+}
+
 std::string ChromeOsUserHashForBrowserContext(
     const content::BrowserContext& context) {
   return context.GetPath().BaseName().value();
 }
 
 std::string ShillProfilePathForBrowserContext(
     const content::BrowserContext& context) {
   return kProfilePrefix + ChromeOsUserHashForBrowserContext(context);
 }
 
-chromeos::NetworkStateHandler* GetNetworkStateHandler() {
-  DCHECK(chromeos::NetworkHandler::Get()->network_state_handler());
-  return chromeos::NetworkHandler::Get()->network_state_handler();
+::chromeos::ShillProfileClient::TestInterface*
+GetShillProfileClientTestInterface() {
+  DCHECK(::chromeos::DBusThreadManager::Get()->GetShillProfileClient());
+  DCHECK(::chromeos::DBusThreadManager::Get()->GetShillProfileClient()
+         ->GetTestInterface());
+  return ::chromeos::DBusThreadManager::Get()->GetShillProfileClient()
+      ->GetTestInterface();
+}
+
+::chromeos::ManagedNetworkConfigurationHandler*
+GetManagedNetworkConfigurationHandler() {
+  DCHECK(::chromeos::NetworkHandler::Get()
+         ->managed_network_configuration_handler());
+  return ::chromeos::NetworkHandler::Get()
+      ->managed_network_configuration_handler();
+}
+
+::chromeos::NetworkStateHandler* GetNetworkStateHandler() {
+  DCHECK(::chromeos::NetworkHandler::Get()->network_state_handler());
+  return ::chromeos::NetworkHandler::Get()->network_state_handler();
 }
 
 }  // namespace
 
-WifiCredentialSet GetWifiCredentialsForProfileChromeOs(const Profile* profile) {
-  DCHECK(profile);
-  return wifi_sync::GetWifiCredentialsForShillProfile(
-      GetNetworkStateHandler(), ShillProfilePathForBrowserContext(*profile));
+namespace chromeos {
+
+void SetUpChromeOs() {
+  wifi_sync::WifiCredentialSyncableServiceFactory::GetInstance()
+      ->IgnoreLoginStateForTest();
 }
 
+bool SetupClientForProfileChromeOs(
+    const content::BrowserContext* browser_context) {
+  DCHECK(browser_context);
+  GetShillProfileClientTestInterface()
+      ->AddProfile(ShillProfilePathForBrowserContext(*browser_context),
+                   ChromeOsUserHashForBrowserContext(*browser_context));
+
+  const base::ListValue policy_network_configs;
+  const base::DictionaryValue policy_global_config;
+  GetManagedNetworkConfigurationHandler()
+      ->SetPolicy(onc::ONC_SOURCE_UNKNOWN,
+                  ChromeOsUserHashForBrowserContext(*browser_context),
+                  policy_network_configs,
+                  policy_global_config);
+
+  return true;
+}
+
+void AddWifiCredentialToProfileChromeOs(
+    const content::BrowserContext* browser_context,
+    const WifiCredential& credential) {
+  DCHECK(browser_context);
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  CHECK(onc_properties) << "Failed to generate ONC properties for "
+                        << credential.ToString();
+  GetManagedNetworkConfigurationHandler()
+      ->CreateConfiguration(
+          ChromeOsUserHashForBrowserContext(*browser_context),
+          *onc_properties,
+          ::chromeos::network_handler::StringResultCallback(),
+          base::Bind(LogCreateConfigurationFailure,
+                     base::StringPrintf("Failed to add credential %s",
+                                        credential.ToString().c_str())));
+}
+
+WifiCredentialSet GetWifiCredentialsForProfileChromeOs(
+    const content::BrowserContext* browser_context) {
+  DCHECK(browser_context);
+  return wifi_sync::GetWifiCredentialsForShillProfile(
+      GetNetworkStateHandler(),
+      ShillProfilePathForBrowserContext(*browser_context));
+}
+
+}  // namespace chromeos
+
 }  // namespace wifi_credentials_helper