Invoke createNetwork() callback with GUID, not service name

components/wifi_sync/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 <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace wifi_sync {
 
 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::StringResultCallback;
+using chromeos::network_handler::ServiceResultCallback;
 
 class FakeManagedNetworkConfigurationHandler
     : public chromeos::ManagedNetworkConfigurationHandler {
  public:
   FakeManagedNetworkConfigurationHandler()
       : create_configuration_called_(false) {
   }
 
   // ManagedNetworkConfigurationHandler implementation.
   void AddObserver(chromeos::NetworkPolicyObserver* observer) override {
@@ skipping 16 matching lines @@
       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 {
     NOTIMPLEMENTED();
   }
-  void CreateConfiguration(
-      const std::string& userhash,
-      const base::DictionaryValue& properties,
-      const StringResultCallback& callback,
-      const ErrorCallback& error_callback) const override {
+  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 {
     NOTIMPLEMENTED();
@@ skipping 29 matching lines @@
   const base::DictionaryValue* FindPolicyByGuidAndProfile(
       const std::string& guid,
       const std::string& profile_path) const override {
     NOTIMPLEMENTED();
     return nullptr;
   }
 
   bool create_configuration_called() const {
     return create_configuration_called_;
   }
-  const StringResultCallback& create_configuration_success_callback() const {
+  const ServiceResultCallback& create_configuration_success_callback() const {
     return create_configuration_success_callback_;
   }
   const ErrorCallback& create_configuration_error_callback() const {
     return create_configuration_error_callback_;
   }
 
  private:
   // Whether or not CreateConfiguration has been called on this fake.
   mutable bool create_configuration_called_;
   // The last |callback| passed to CreateConfiguration.
-  mutable StringResultCallback create_configuration_success_callback_;
+  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(
@@ skipping 17 matching lines @@
             security_class,
             passphrase);
     CHECK(credential);
     return *credential;
   }
 
   // Runs the last |callback| passed to CreateConfiguration, unless
   // that |callback| is null.
   void RunCreateConfigurationSuccessCallback() {
     const char new_service_path[] = "/service/0";
-    const StringResultCallback callback =
+    const ServiceResultCallback callback =
         fake_managed_network_configuration_handler_
-        ->create_configuration_success_callback();
+            ->create_configuration_success_callback();
     if (!callback.is_null())
-      callback.Run(new_service_path);
+      callback.Run(new_service_path, nullptr);
   }
 
   // Returns whether or not CreateConfiguration has been called
   // on |fake_managed_network_configuration_handler_|.
   size_t create_configuration_called() const {
     return fake_managed_network_configuration_handler_
         ->create_configuration_called();
   }
 
   // Returns the last |error_callback| passed to the CreateConfiguration
@@ skipping 41 matching lines @@
   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",
         make_scoped_ptr(new base::DictionaryValue()));
   }
 }
 
 }  // namespace wifi_sync