Multi-profile flag cleanup.

chrome/browser/extensions/api/networking_private/networking_private_apitest.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "extensions/common/switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/net/network_portal_detector.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 102 matching lines @@
 
   virtual void VerifyAndEncryptData(scoped_ptr<base::ListValue> args,
                                     std::string* encoded_data,
                                     std::string* error) OVERRIDE {
     *encoded_data = "encrypted_data";
   }
 };
 #endif  // defined(OS_CHROMEOS)
 
 class ExtensionNetworkingPrivateApiTest
-    : public ExtensionApiTest,
-      public testing::WithParamInterface<bool> {
+    : public ExtensionApiTest {
  public:
   ExtensionNetworkingPrivateApiTest()
 #if defined(OS_CHROMEOS)
       : detector_(NULL),
         service_test_(NULL),
         manager_test_(NULL)
 #endif
   {
   }
 
@@ skipping 29 matching lines @@
         "epcifkihnkjgphfkloaaleeakhpmgdmn");
 
     // TODO(pneubeck): Remove the following hack, once the NetworkingPrivateAPI
     // uses the ProfileHelper to obtain the userhash crbug/238623.
     const std::string login_user = chromeos::login::CanonicalizeUserID(
         command_line->GetSwitchValueNative(chromeos::switches::kLoginUser));
     const std::string sanitized_user =
         CryptohomeClient::GetStubSanitizedUsername(login_user);
     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile,
                                     sanitized_user);
-    if (GetParam())
-      command_line->AppendSwitch(::switches::kMultiProfiles);
   }
 
   void InitializeSanitizedUsername() {
     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
     chromeos::User* user = user_manager->GetActiveUser();
     CHECK(user);
     std::string userhash;
     DBusThreadManager::Get()->GetCryptohomeClient()->GetSanitizedUsername(
         user->email(),
         base::Bind(&AssignString, &userhash_));
@@ skipping 163 matching lines @@
   ShillManagerClient::TestInterface* manager_test_;
   policy::MockConfigurationPolicyProvider provider_;
   std::string userhash_;
 #endif
 };
 
 // Place each subtest into a separate browser test so that the stub networking
 // library state is reset for each subtest run. This way they won't affect each
 // other.
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, StartConnect) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, StartConnect) {
   EXPECT_TRUE(RunNetworkingSubtest("startConnect")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, StartDisconnect) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, StartDisconnect) {
   EXPECT_TRUE(RunNetworkingSubtest("startDisconnect")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        StartConnectNonexistent) {
   EXPECT_TRUE(RunNetworkingSubtest("startConnectNonexistent")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        StartDisconnectNonexistent) {
   EXPECT_TRUE(RunNetworkingSubtest("startDisconnectNonexistent")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        StartGetPropertiesNonexistent) {
   EXPECT_TRUE(RunNetworkingSubtest("startGetPropertiesNonexistent"))
       << message_;
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(stevenjb/mef): Fix these on non-Chrome OS, crbug.com/371442.
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetNetworks) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, GetNetworks) {
   // Remove "stub_wifi2" from the visible list.
   manager_test_->RemoveManagerService("stub_wifi2", false);
   // Add a couple of additional networks that are not configured (saved).
   AddService("stub_wifi3", "wifi3", shill::kTypeWifi, shill::kStateIdle);
   AddService("stub_wifi4", "wifi4", shill::kTypeWifi, shill::kStateIdle);
   EXPECT_TRUE(RunNetworkingSubtest("getNetworks")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetVisibleNetworks) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, GetVisibleNetworks) {
   EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworks")) << message_;
 }
 #endif
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        GetVisibleNetworksWifi) {
   EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworksWifi")) << message_;
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(stevenjb/mef): Fix this on non-Chrome OS, crbug.com/371442.
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, RequestNetworkScan) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, RequestNetworkScan) {
   EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
 }
 #endif
 
 // Properties are filtered and translated through
 // ShillToONCTranslator::TranslateWiFiWithState
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetProperties) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, GetProperties) {
   EXPECT_TRUE(RunNetworkingSubtest("getProperties")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetState) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, GetState) {
   EXPECT_TRUE(RunNetworkingSubtest("getState")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetStateNonExistent) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, GetStateNonExistent) {
   EXPECT_TRUE(RunNetworkingSubtest("getStateNonExistent")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, SetProperties) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, SetProperties) {
   EXPECT_TRUE(RunNetworkingSubtest("setProperties")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, CreateNetwork) {
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest, CreateNetwork) {
   EXPECT_TRUE(RunNetworkingSubtest("createNetwork")) << message_;
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(stevenjb/mef): Find a maintainable way to support this on win/mac and
 // a better way to set this up on Chrome OS.
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        GetManagedProperties) {
   const std::string uidata_blob =
       "{ \"user_settings\": {"
       "      \"WiFi\": {"
       "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
       "    }"
       "}";
   service_test_->SetServiceProperty("stub_wifi2",
                                     shill::kUIDataProperty,
                                     base::StringValue(uidata_blob));
@@ skipping 31 matching lines @@
              new base::StringValue(user_policy_blob),
              NULL);
   provider_.UpdateChromePolicy(policy);
 
   content::RunAllPendingInMessageLoop();
 
   EXPECT_TRUE(RunNetworkingSubtest("getManagedProperties")) << message_;
 }
 #endif  // OS_CHROMEOS
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        OnNetworksChangedEventConnect) {
   EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventConnect"))
       << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        OnNetworksChangedEventDisconnect) {
   EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventDisconnect"))
       << message_;
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(stevenjb/mef): Fix this on non-Chrome OS, crbug.com/371442.
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        OnNetworkListChangedEvent) {
   EXPECT_TRUE(RunNetworkingSubtest("onNetworkListChangedEvent")) << message_;
 }
 #endif  // OS_CHROMEOS
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        VerifyDestination) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        VerifyAndEncryptCredentials) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }
 
 #if defined(OS_CHROMEOS)
 // Currently TDLS support is only enabled for Chrome OS.
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        SetWifiTDLSEnabledState) {
   EXPECT_TRUE(RunNetworkingSubtest("setWifiTDLSEnabledState")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        GetWifiTDLSStatus) {
   EXPECT_TRUE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 }
 #endif
 
 // NetworkPortalDetector is only enabled for Chrome OS.
 #if defined(OS_CHROMEOS)
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        GetCaptivePortalStatus) {
   AddService("stub_cellular1", "cellular1",
              shill::kTypeCellular, shill::kStateIdle);
   service_test_->SetServiceProperty(
       "stub_cellular1",
       shill::kNetworkTechnologyProperty,
       base::StringValue(shill::kNetworkTechnologyGsm));
   service_test_->SetServiceProperty(
       "stub_cellular1",
       shill::kActivationStateProperty,
@@ skipping 16 matching lines @@
   state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
   detector()->SetDetectionResultsForTesting("stub_wifi2", state);
 
   state.status =
       NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
   detector()->SetDetectionResultsForTesting("stub_cellular1", state);
 
   EXPECT_TRUE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
+IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        CaptivePortalNotification) {
   detector()->SetDefaultNetworkPathForTesting("wifi");
   NetworkPortalDetector::CaptivePortalState state;
   state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
   detector()->SetDetectionResultsForTesting("wifi", state);
 
   TestListener listener(
       "notifyPortalDetectorObservers",
       base::Bind(&NetworkPortalDetectorTestImpl::NotifyObserversForTesting,
                  base::Unretained(detector())));
   EXPECT_TRUE(RunNetworkingSubtest("captivePortalNotification")) << message_;
 }
 #endif  // defined(OS_CHROMEOS)
 
-INSTANTIATE_TEST_CASE_P(ExtensionNetworkingPrivateApiTestInstantiation,
-                        ExtensionNetworkingPrivateApiTest,
-                        testing::Bool());
-
 }  // namespace