Use explicit WebString conversions in remaining chrome/renderer files

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2012 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 "chrome/renderer/chrome_content_renderer_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 220 matching lines @@
 
   WebVector<WebString> names(total_size);
   WebVector<WebString> values(total_size);
 
   for (size_t i = 0; i < existing_size; ++i) {
     names[i] = (*existing_names)[i];
     values[i] = (*existing_values)[i];
   }
 
   for (size_t i = 0; i < additional_names.size(); ++i) {
-    names[existing_size + i] = additional_names[i];
-    values[existing_size + i] = additional_values[i];
+    names[existing_size + i] = WebString::fromUTF16(additional_names[i]);
+    values[existing_size + i] = WebString::fromUTF16(additional_values[i]);
   }
 
   existing_names->swap(names);
   existing_values->swap(values);
 }
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
 #if BUILDFLAG(ENABLE_SPELLCHECK)
 class SpellCheckReplacer : public content::RenderViewVisitor {
  public:
@@ skipping 168 matching lines @@
   if (command_line->HasSwitch(switches::kEnableBenchmarking))
     thread->RegisterExtension(extensions_v8::BenchmarkingExtension::Get());
   if (command_line->HasSwitch(switches::kEnableNetBenchmarking))
     thread->RegisterExtension(extensions_v8::NetBenchmarkingExtension::Get());
   if (command_line->HasSwitch(switches::kInstantProcess))
     thread->RegisterExtension(extensions_v8::SearchBoxExtension::Get());
 
   // chrome-search: and chrome-distiller: pages  should not be accessible by
   // normal content, and should also be unable to script anything but themselves
   // (to help limit the damage that a corrupt page could cause).
-  WebString chrome_search_scheme(ASCIIToUTF16(chrome::kChromeSearchScheme));
+  WebString chrome_search_scheme(
+      WebString::fromASCII(chrome::kChromeSearchScheme));
 
   // The Instant process can only display the content but not read it.  Other
   // processes can't display it or read it.
   if (!command_line->HasSwitch(switches::kInstantProcess))
     WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(chrome_search_scheme);
 
   WebString dom_distiller_scheme(
-      ASCIIToUTF16(dom_distiller::kDomDistillerScheme));
+      WebString::fromASCII(dom_distiller::kDomDistillerScheme));
   // TODO(nyquist): Add test to ensure this happens when the flag is set.
   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(dom_distiller_scheme);
 
 #if defined(OS_ANDROID)
   WebSecurityPolicy::registerURLSchemeAsAllowedForReferrer(
       WebString::fromUTF8(chrome::kAndroidAppScheme));
 #endif
 
   // chrome-search: pages should not be accessible by bookmarklets
   // or javascript: URLs typed in the omnibox.
   WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
       chrome_search_scheme);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   pdf_print_client_.reset(new ChromePDFPrintClient());
   pdf::PepperPDFHost::SetPrintClient(pdf_print_client_.get());
 #endif
 
   for (auto& origin : GetSecureOriginWhitelist()) {
     WebSecurityPolicy::addOriginTrustworthyWhiteList(
         WebSecurityOrigin::create(origin));
   }
 
   for (auto& scheme : GetSchemesBypassingSecureContextCheckWhitelist()) {
     WebSecurityPolicy::addSchemeToBypassSecureContextWhitelist(
-        WebString::fromUTF8(scheme));
+        WebString::fromASCII(scheme));
   }
 
 #if defined(OS_CHROMEOS)
   leak_detector_remote_client_.reset(new LeakDetectorRemoteClient());
   thread->AddObserver(leak_detector_remote_client_.get());
 #endif
 }
 
 void ChromeContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
@@ skipping 562 matching lines @@
 }
 
 void ChromeContentRendererClient::GetNavigationErrorStrings(
     content::RenderFrame* render_frame,
     const WebURLRequest& failed_request,
     const WebURLError& error,
     std::string* error_html,
     base::string16* error_description) {
   const GURL failed_url = error.unreachableURL;
 
-  bool is_post = base::EqualsASCII(
-      base::StringPiece16(failed_request.httpMethod()), "POST");
+  bool is_post = failed_request.httpMethod().ascii() == "POST";
   bool is_ignoring_cache =
       failed_request.getCachePolicy() == WebCachePolicy::BypassingCache;
   if (error_html) {
     NetErrorHelper::Get(render_frame)
         ->GetErrorHTML(error, is_post, is_ignoring_cache, error_html);
   }
 
   if (error_description) {
     *error_description = error_page::LocalizedError::GetErrorDetails(
         error.domain.utf8(), error.reason, is_post);
@@ skipping 308 matching lines @@
                                                   const GURL& url) {
   if (!rappor_recorder_)
     RenderThread::Get()->GetRemoteInterfaces()->GetInterface(&rappor_recorder_);
   rappor_recorder_->RecordRapporURL(metric, url);
 }
 
 void ChromeContentRendererClient::AddImageContextMenuProperties(
     const WebURLResponse& response,
     std::map<std::string, std::string>* properties) {
   DCHECK(properties);
-  WebString header_key(ASCIIToUTF16(
+  WebString header_key(WebString::fromASCII(
       data_reduction_proxy::chrome_proxy_content_transform_header()));
   if (!response.httpHeaderField(header_key).isNull() &&
       data_reduction_proxy::IsEmptyImagePreview(
           response.httpHeaderField(header_key).utf8())) {
     (*properties)[
         data_reduction_proxy::chrome_proxy_content_transform_header()] =
             data_reduction_proxy::empty_image_directive();
   }
 }
 
@@ skipping 121 matching lines @@
     std::vector<base::SchedulerWorkerPoolParams>* params_vector,
     base::TaskScheduler::WorkerPoolIndexForTraitsCallback*
         index_to_traits_callback) {
   DCHECK(params_vector);
   DCHECK(index_to_traits_callback);
   // If this call fails, content will fall back to the default params.
   *params_vector = task_scheduler_util::GetRendererWorkerPoolParams();
   *index_to_traits_callback =
       base::Bind(&task_scheduler_util::RendererWorkerPoolIndexForTraits);
 }