Use base::StringPairs where appropriate for src/media/

chrome/browser/media/encrypted_media_browsertest.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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/media/media_browsertest.h"
@@ skipping 100 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   bool IsWidevine(const std::string& key_system) {
     return key_system == kWidevineKeySystem;
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
   void RunEncryptedMediaTestPage(
       const std::string& html_page,
       const std::string& key_system,
-      const media::QueryParams& query_params,
+      base::StringPairs& query_params,
       const std::string& expected_title) {
-    media::QueryParams new_query_params = query_params;
+    base::StringPairs new_query_params = query_params;
     StartLicenseServerIfNeeded(key_system, &new_query_params);
     RunMediaTestPage(html_page, new_query_params, expected_title, true);
   }
 
   // Tests |html_page| using |media_file| (with |media_type|) and |key_system|.
   // When |session_to_load| is not empty, the test will try to load
   // |session_to_load| with stored keys, instead of creating a new session
   // and trying to update it with licenses.
   // When |force_invalid_response| is true, the test will provide invalid
   // responses, which should trigger errors.
   // TODO(xhwang): Find an easier way to pass multiple configuration test
   // options.
   void RunEncryptedMediaTest(const std::string& html_page,
                              const std::string& media_file,
                              const std::string& media_type,
                              const std::string& key_system,
                              SrcType src_type,
                              EmeVersion eme_version,
                              const std::string& session_to_load,
                              bool force_invalid_response,
                              const std::string& expected_title) {
     if (src_type == MSE && !IsMSESupported()) {
       VLOG(0) << "Skipping test - MSE not supported.";
       return;
     }
-    media::QueryParams query_params;
+    base::StringPairs query_params;
     query_params.push_back(std::make_pair("mediaFile", media_file));
     query_params.push_back(std::make_pair("mediaType", media_type));
     query_params.push_back(std::make_pair("keySystem", key_system));
     if (src_type == MSE)
       query_params.push_back(std::make_pair("useMSE", "1"));
     if (eme_version == PREFIXED)
       query_params.push_back(std::make_pair("usePrefixedEME", "1"));
     if (force_invalid_response)
       query_params.push_back(std::make_pair("forceInvalidResponse", "1"));
     if (!session_to_load.empty())
@@ skipping 26 matching lines @@
         browser()->tab_strip_model()->GetActiveWebContents(),
         "window.domAutomationController.send("
         "document.querySelector('video').receivedKeyMessage);",
         &receivedKeyMessage));
     EXPECT_TRUE(receivedKeyMessage);
   }
 
   // Starts a license server if available for the |key_system| and adds a
   // 'licenseServerURL' query parameter to |query_params|.
   void StartLicenseServerIfNeeded(const std::string& key_system,
-                                  media::QueryParams* query_params) {
+                                  base::StringPairs* query_params) {
     scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system);
     if (!config)
       return;
     license_server_.reset(new TestLicenseServer(config.Pass()));
     EXPECT_TRUE(license_server_->Start());
     query_params->push_back(
         std::make_pair("licenseServerURL", license_server_->GetServerURL()));
   }
 
   bool IsPlayBackPossible(const std::string& key_system) {
@@ skipping 192 matching lines @@
                           CurrentKeySystem(),
                           CurrentSourceType(),
                           CurrentEmeVersion(),
                           kNoSessionToLoad,
                           false,
                           kEnded);
   }
 
   void TestConfigChange() {
     DCHECK(IsMSESupported());
-    media::QueryParams query_params;
+    base::StringPairs query_params;
     query_params.push_back(std::make_pair("keySystem", CurrentKeySystem()));
     query_params.push_back(std::make_pair("runEncrypted", "1"));
     if (CurrentEmeVersion() == PREFIXED)
       query_params.push_back(std::make_pair("usePrefixedEME", "1"));
     RunEncryptedMediaTestPage("mse_config_change.html",
                               CurrentKeySystem(),
                               query_params,
                               kEnded);
   }
 
@@ skipping 240 matching lines @@
                         "bear-320x240-v_enc-v.webm",
                         kWebMVideoOnly,
                         kExternalClearKeyKeySystem,
                         SRC,
                         PREFIXED,
                         kUnknownSession,
                         false,
                         kEmeKeyError);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)