ChromeOS: Remove MockDBusThreadManager.

chromeos/network/managed_network_configuration_handler_unittest.cc

 // Copyright (c) 2013 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 <iostream>
 #include <sstream>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/mock_dbus_thread_manager.h"
+#include "chromeos/dbus/fake_dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
-#include "chromeos/dbus/mock_shill_service_client.h"
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
@@ skipping 115 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestNetworkProfileHandler);
 };
 
 }  // namespace
 
 class ManagedNetworkConfigurationHandlerTest : public testing::Test {
  public:
-  ManagedNetworkConfigurationHandlerTest() {
+  ManagedNetworkConfigurationHandlerTest()
+      : mock_manager_client_(NULL),
+        mock_profile_client_(NULL) {
   }
 
   virtual ~ManagedNetworkConfigurationHandlerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    MockDBusThreadManager* dbus_thread_manager = new MockDBusThreadManager;
-    EXPECT_CALL(*dbus_thread_manager, GetSystemBus())
-        .WillRepeatedly(Return(static_cast<dbus::Bus*>(NULL)));
+    FakeDBusThreadManager* dbus_thread_manager = new FakeDBusThreadManager;
+    mock_manager_client_ = new StrictMock<MockShillManagerClient>();
+    mock_profile_client_ = new StrictMock<MockShillProfileClient>();
+    dbus_thread_manager->SetShillManagerClient(
+        scoped_ptr<ShillManagerClient>(mock_manager_client_).Pass());
+    dbus_thread_manager->SetShillProfileClient(
+        scoped_ptr<ShillProfileClient>(mock_profile_client_).Pass());
+
     DBusThreadManager::InitializeForTesting(dbus_thread_manager);
 
     SetNetworkConfigurationHandlerExpectations();
 
-    EXPECT_CALL(*dbus_thread_manager, GetShillManagerClient())
-        .WillRepeatedly(Return(&mock_manager_client_));
-    EXPECT_CALL(*dbus_thread_manager, GetShillServiceClient())
-        .WillRepeatedly(Return(&mock_service_client_));
-    EXPECT_CALL(*dbus_thread_manager, GetShillProfileClient())
-        .WillRepeatedly(Return(&mock_profile_client_));
-
-    ON_CALL(mock_profile_client_, GetProperties(_,_,_))
+    ON_CALL(*mock_profile_client_, GetProperties(_,_,_))
         .WillByDefault(Invoke(&profiles_stub_,
                               &ShillProfileTestClient::GetProperties));
 
-    ON_CALL(mock_profile_client_, GetEntry(_,_,_,_))
+    ON_CALL(*mock_profile_client_, GetEntry(_,_,_,_))
         .WillByDefault(Invoke(&profiles_stub_,
                               &ShillProfileTestClient::GetEntry));
 
     network_profile_handler_.reset(new TestNetworkProfileHandler());
     network_configuration_handler_.reset(
         NetworkConfigurationHandler::InitializeForTest(
             NULL /* no NetworkStateHandler */));
     managed_network_configuration_handler_.reset(
         new ManagedNetworkConfigurationHandlerImpl());
     managed_network_configuration_handler_->Init(
         NULL /* no NetworkStateHandler */,
         network_profile_handler_.get(),
         network_configuration_handler_.get());
 
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     managed_network_configuration_handler_.reset();
     network_configuration_handler_.reset();
     network_profile_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
   void VerifyAndClearExpectations() {
-    Mock::VerifyAndClearExpectations(&mock_manager_client_);
-    Mock::VerifyAndClearExpectations(&mock_service_client_);
-    Mock::VerifyAndClearExpectations(&mock_profile_client_);
+    Mock::VerifyAndClearExpectations(mock_manager_client_);
+    Mock::VerifyAndClearExpectations(mock_profile_client_);
     SetNetworkConfigurationHandlerExpectations();
   }
 
   void InitializeStandardProfiles() {
     profiles_stub_.AddProfile(kUser1ProfilePath, kUser1);
     network_profile_handler_->
         AddProfileForTest(NetworkProfile(kUser1ProfilePath, kUser1));
     network_profile_handler_->
         AddProfileForTest(NetworkProfile(kSharedProfilePath, std::string()));
   }
@@ skipping 25 matching lines @@
     policy->GetDictionaryWithoutPathExpansion(
         ::onc::toplevel_config::kGlobalNetworkConfiguration,
         &global_network_config);
 
     managed_handler()->SetPolicy(
         onc_source, userhash, *network_configs, *global_network_config);
   }
 
   void SetNetworkConfigurationHandlerExpectations() {
     // These calls occur in NetworkConfigurationHandler.
-    EXPECT_CALL(mock_manager_client_, GetProperties(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_manager_client_,
+    EXPECT_CALL(*mock_manager_client_, GetProperties(_)).Times(AnyNumber());
+    EXPECT_CALL(*mock_manager_client_,
                 AddPropertyChangedObserver(_)).Times(AnyNumber());
-    EXPECT_CALL(mock_manager_client_,
+    EXPECT_CALL(*mock_manager_client_,
                 RemovePropertyChangedObserver(_)).Times(AnyNumber());
   }
 
   ManagedNetworkConfigurationHandler* managed_handler() {
     return managed_network_configuration_handler_.get();
   }
 
  protected:
-  StrictMock<MockShillManagerClient> mock_manager_client_;
-  StrictMock<MockShillServiceClient> mock_service_client_;
-  StrictMock<MockShillProfileClient> mock_profile_client_;
+  MockShillManagerClient* mock_manager_client_;
+  MockShillProfileClient* mock_profile_client_;
   ShillProfileTestClient profiles_stub_;
   scoped_ptr<TestNetworkProfileHandler> network_profile_handler_;
   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
   scoped_ptr<ManagedNetworkConfigurationHandlerImpl>
         managed_network_configuration_handler_;
   base::MessageLoop message_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ManagedNetworkConfigurationHandlerTest);
 };
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, ProfileInitialization) {
   InitializeStandardProfiles();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, RemoveIrrelevantFields) {
   InitializeStandardProfiles();
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unconfigured_wifi1.json");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
             kUser1,
             "policy/policy_wifi1_with_redundant_fields.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyManageUnconfigured) {
   InitializeStandardProfiles();
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unconfigured_wifi1.json");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 // Ensure that EAP settings for ethernet are matched with the right profile
 // entry and written to the dedicated EthernetEAP service.
 TEST_F(ManagedNetworkConfigurationHandlerTest,
        SetPolicyManageUnmanagedEthernetEAP) {
   InitializeStandardProfiles();
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/"
           "shill_policy_on_unmanaged_ethernet_eap.json");
 
   SetUpEntry("policy/shill_unmanaged_ethernet_eap.json",
              kUser1ProfilePath,
              "eth_entry");
 
   // Also setup an unrelated WiFi configuration to verify that the right entry
   // is matched.
   SetUpEntry("policy/shill_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "wifi_entry");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetEntry(dbus::ObjectPath(kUser1ProfilePath), _, _, _)).Times(2);
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "eth_entry", _, _));
 
   EXPECT_CALL(
-      mock_manager_client_,
+      *mock_manager_client_,
       ConfigureServiceForProfile(dbus::ObjectPath(kUser1ProfilePath),
                                  IsEqualTo(expected_shill_properties.get()),
                                  _, _));
 
   SetPolicy(
       ::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_ethernet_eap.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyIgnoreUnmodified) {
   InitializeStandardProfiles();
-  EXPECT_CALL(mock_profile_client_, GetProperties(_, _, _));
+  EXPECT_CALL(*mock_profile_client_, GetProperties(_, _, _));
 
-  EXPECT_CALL(mock_manager_client_, ConfigureServiceForProfile(_, _, _, _));
+  EXPECT_CALL(*mock_manager_client_, ConfigureServiceForProfile(_, _, _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
   VerifyAndClearExpectations();
 
   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "some_entry_path");
 
-  EXPECT_CALL(mock_profile_client_, GetProperties(_, _, _));
+  EXPECT_CALL(*mock_profile_client_, GetProperties(_, _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "some_entry_path", _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyManageUnmanaged) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unmanaged_wifi1.json");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 // Old ChromeOS versions may not have used the UIData property
 TEST_F(ManagedNetworkConfigurationHandlerTest,
        SetPolicyManageUnmanagedWithoutUIData) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unmanaged_wifi1.json");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUpdateManagedNewGUID) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_managed_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unmanaged_wifi1.json");
 
   // The passphrase isn't sent again, because it's configured by the user and
   // Shill doesn't sent it on GetProperties calls.
   expected_shill_properties->RemoveWithoutPathExpansion(
       shill::kPassphraseProperty, NULL);
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyReapplyToManaged) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unmanaged_wifi1.json");
 
   // The passphrase isn't sent again, because it's configured by the user and
   // Shill doesn't sent it on GetProperties calls.
   expected_shill_properties->RemoveWithoutPathExpansion(
       shill::kPassphraseProperty, NULL);
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
   VerifyAndClearExpectations();
 
   // If we apply the policy again, without change, then the Shill profile will
   // not be modified.
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUnmanageManaged) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetEntry(dbus::ObjectPath(kUser1ProfilePath),
                        "old_entry_path",
                        _, _));
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               DeleteEntry(dbus::ObjectPath(kUser1ProfilePath),
                           "old_entry_path",
                           _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetEmptyPolicyIgnoreUnmanaged) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_unmanaged_wifi1.json",
              kUser1ProfilePath,
              "old_entry_path");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetEntry(dbus::ObjectPath(kUser1ProfilePath),
                        "old_entry_path",
                        _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyIgnoreUnmanaged) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_unmanaged_wifi2.json",
              kUser1ProfilePath,
              "wifi2_entry_path");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "wifi2_entry_path", _, _));
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unconfigured_wifi1.json");
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, AutoConnectDisallowed) {
   InitializeStandardProfiles();
   SetUpEntry("policy/shill_unmanaged_wifi2.json",
              kUser1ProfilePath,
              "wifi2_entry_path");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
-      mock_profile_client_,
+      *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "wifi2_entry_path", _, _));
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_disallow_autoconnect_on_unmanaged_wifi2.json");
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
             kUser1,
             "policy/policy_disallow_autoconnect.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, LateProfileLoading) {
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 
   message_loop_.RunUntilIdle();
   VerifyAndClearExpectations();
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_policy_on_unconfigured_wifi1.json");
 
-  EXPECT_CALL(mock_profile_client_,
+  EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
-  EXPECT_CALL(mock_manager_client_,
+  EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   InitializeStandardProfiles();
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace chromeos