Skip base::string16 if not necessary for WebString <-> ASCII conversion

media/blink/key_system_config_selector.cc

 // Copyright 2014 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 "media/blink/key_system_config_selector.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 384 matching lines @@
     if (capability.mimeType.isEmpty()) {
       DVLOG(2) << "Rejecting requested configuration because "
                << "a capability contentType was empty.";
       return false;
     }
 
     // 3.4-3.11. (Implemented by IsSupportedContentType().)
     ConfigState proposed_config_state = *config_state;
     if (!base::IsStringASCII(capability.mimeType) ||
         !base::IsStringASCII(capability.codecs) ||
-        !IsSupportedContentType(key_system, media_type,
-                                base::UTF16ToASCII(
-                                    base::StringPiece16(capability.mimeType)),
-                                base::UTF16ToASCII(
-                                    base::StringPiece16(capability.codecs)),
-                                &proposed_config_state)) {
+        !IsSupportedContentType(
+            key_system, media_type, capability.mimeType.ascii(),
+            capability.codecs.ascii(), &proposed_config_state)) {
       continue;
     }
     // 3.12. If robustness is not the empty string, run the following steps:
     if (!capability.robustness.isEmpty()) {
       // 3.12.1. If robustness is an unrecognized value or not supported by
       //         implementation, continue to the next iteration. String
       //         comparison is case-sensitive.
       if (!base::IsStringASCII(capability.robustness))
         continue;
       EmeConfigRule robustness_rule = key_systems_->GetRobustnessConfigRule(
-          key_system, media_type, base::UTF16ToASCII(
-              base::StringPiece16(capability.robustness)));
+          key_system, media_type, capability.robustness.ascii());
       if (!proposed_config_state.IsRuleSupported(robustness_rule))
         continue;
       proposed_config_state.AddRule(robustness_rule);
       // 3.12.2. Add robustness to configuration.
       //         (It's already added, we use capability as configuration.)
     }
     // 3.13. If the user agent and implementation do not support playback of
     //       encrypted media data as specified by configuration, including all
     //       media types, in combination with local accumulated capabilities,
     //       continue to the next iteration.
@@ skipping 398 matching lines @@
     bool are_secure_codecs_supported,
     base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
                         const CdmConfig&)> succeeded_cb,
     base::Callback<void(const blink::WebString&)> not_supported_cb) {
   // Continued from requestMediaKeySystemAccess(), step 6, from
   // https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess
   //
   // 6.1 If keySystem is not one of the Key Systems supported by the user
   //     agent, reject promise with a NotSupportedError. String comparison
   //     is case-sensitive.
-  if (!base::IsStringASCII(key_system)) {
+  if (!key_system.containsOnlyASCII()) {
     not_supported_cb.Run("Only ASCII keySystems are supported");
     return;
   }
 
-  std::string key_system_ascii =
-      base::UTF16ToASCII(base::StringPiece16(key_system));
+  std::string key_system_ascii = key_system.ascii();
   if (!key_systems_->IsSupportedKeySystem(key_system_ascii)) {
     not_supported_cb.Run("Unsupported keySystem");
     return;
   }
 
   // 6.2-6.4. Implemented by OnSelectConfig().
   // TODO(sandersd): This should be async, ideally not on the main thread.
   std::unique_ptr<SelectionRequest> request(new SelectionRequest());
   request->key_system = key_system_ascii;
   request->candidate_configurations = candidate_configurations;
@@ skipping 70 matching lines @@
 
 void KeySystemConfigSelector::OnPermissionResult(
     std::unique_ptr<SelectionRequest> request,
     bool is_permission_granted) {
   request->was_permission_requested = true;
   request->is_permission_granted = is_permission_granted;
   SelectConfigInternal(std::move(request));
 }
 
 }  // namespace media