Clean up shill fake implementations

chromeos/network/network_cert_migrator_unittest.cc

 // Copyright 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 "chromeos/network/network_cert_migrator.h"
 
 #include <cert.h>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 88 matching lines @@
   }
 
   void SetupNetworkHandlers() {
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     network_cert_migrator_.reset(new NetworkCertMigrator);
     network_cert_migrator_->Init(network_state_handler_.get());
   }
 
   void SetupWifiWithNss() {
     const bool add_to_visible = true;
-    const bool add_to_watchlist = true;
     service_test_->AddService(kWifiStub,
                               kWifiStub,
                               shill::kTypeWifi,
                               shill::kStateOnline,
-                              add_to_visible,
-                              add_to_watchlist);
+                              add_to_visible);
     service_test_->SetServiceProperty(kWifiStub,
                                       shill::kEapCaCertNssProperty,
                                       base::StringValue(kNSSNickname));
   }
 
   void GetEapCACertProperties(std::string* nss_nickname, std::string* ca_pem) {
     nss_nickname->clear();
     ca_pem->clear();
     const base::DictionaryValue* properties =
         service_test_->GetServiceProperties(kWifiStub);
     properties->GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty,
                                               nss_nickname);
     const base::ListValue* ca_pems = NULL;
     properties->GetListWithoutPathExpansion(shill::kEapCaCertPemProperty,
                                             &ca_pems);
     if (ca_pems && !ca_pems->empty())
       ca_pems->GetString(0, ca_pem);
   }
 
   void SetupVpnWithNss(bool open_vpn) {
     const bool add_to_visible = true;
-    const bool add_to_watchlist = true;
     service_test_->AddService(kVPNStub,
                               kVPNStub,
                               shill::kTypeVPN,
                               shill::kStateIdle,
-                              add_to_visible,
-                              add_to_watchlist);
+                              add_to_visible);
     base::DictionaryValue provider;
     const char* nss_property = open_vpn ? shill::kOpenVPNCaCertNSSProperty
                                         : shill::kL2tpIpsecCaCertNssProperty;
     provider.SetStringWithoutPathExpansion(nss_property, kNSSNickname);
     service_test_->SetServiceProperty(
         kVPNStub, shill::kProviderProperty, provider);
   }
 
   void GetVpnCACertProperties(bool open_vpn,
                               std::string* nss_nickname,
@@ skipping 104 matching lines @@
   SetupNetworkHandlers();
 
   base::RunLoop().RunUntilIdle();
   std::string nss_nickname, ca_pem;
   GetVpnCACertProperties(false /* not OpenVPN */, &nss_nickname, &ca_pem);
   EXPECT_TRUE(nss_nickname.empty());
   EXPECT_EQ(test_ca_cert_pem_, ca_pem);
 }
 
 }  // namespace chromeos