Use std::string instead of mojo::String in //net.

net/proxy/proxy_resolver_factory_mojo.cc

 // Copyright 2015 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 "net/proxy/proxy_resolver_factory_mojo.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "base/values.h"
-#include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/dns/mojo_host_resolver_impl.h"
 #include "net/interfaces/host_resolver_service.mojom.h"
 #include "net/interfaces/proxy_resolver_service.mojom.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_script_data.h"
 
 namespace net {
 
 namespace {
 
 std::unique_ptr<base::Value> NetLogErrorCallback(
     int line_number,
-    const base::string16* message,
+    const std::string* message,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("line_number", line_number);
   dict->SetString("message", *message);
   return std::move(dict);
 }
 
 // A mixin that forwards logging to (Bound)NetLog and ProxyResolverErrorObserver
 // and DNS requests to a MojoHostResolverImpl, which is implemented in terms of
 // a HostResolver.
 template <typename ClientInterface>
 class ClientMixin : public ClientInterface {
  public:
   ClientMixin(HostResolver* host_resolver,
               ProxyResolverErrorObserver* error_observer,
               NetLog* net_log,
               const NetLogWithSource& net_log_with_source)
       : host_resolver_(host_resolver, net_log_with_source),
         error_observer_(error_observer),
         net_log_(net_log),
         net_log_with_source_(net_log_with_source) {}
 
   // Overridden from ClientInterface:
-  void Alert(const mojo::String& message) override {
-    base::string16 message_str = message.To<base::string16>();
-    auto callback = NetLog::StringCallback("message", &message_str);
+  void Alert(const std::string& message) override {
+    auto callback = NetLog::StringCallback("message", &message);
     net_log_with_source_.AddEvent(NetLogEventType::PAC_JAVASCRIPT_ALERT,
                                   callback);
     if (net_log_)
       net_log_->AddGlobalEntry(NetLogEventType::PAC_JAVASCRIPT_ALERT, callback);
   }
 
-  void OnError(int32_t line_number, const mojo::String& message) override {
-    base::string16 message_str = message.To<base::string16>();
-    auto callback = base::Bind(&NetLogErrorCallback, line_number, &message_str);
+  void OnError(int32_t line_number, const std::string& message) override {
+    auto callback = base::Bind(&NetLogErrorCallback, line_number, &message);
     net_log_with_source_.AddEvent(NetLogEventType::PAC_JAVASCRIPT_ERROR,
                                   callback);
     if (net_log_)
       net_log_->AddGlobalEntry(NetLogEventType::PAC_JAVASCRIPT_ERROR, callback);
-    if (error_observer_)
-      error_observer_->OnPACScriptError(line_number, message_str);
+    if (error_observer_) {
+      error_observer_->OnPACScriptError(line_number,
+                                        base::UTF8ToUTF16(message));
+    }
   }
 
   void ResolveDns(std::unique_ptr<HostResolver::RequestInfo> request_info,
                   interfaces::HostResolverRequestClientPtr client) override {
     host_resolver_.Resolve(std::move(request_info), std::move(client));
   }
 
  protected:
   bool dns_request_in_progress() {
     return host_resolver_.request_in_progress();
@@ skipping 243 matching lines @@
             factory->host_resolver_,
             error_observer.get(),
             factory->net_log_,
             NetLogWithSource()),
         factory_(factory),
         resolver_(resolver),
         callback_(callback),
         binding_(this),
         error_observer_(std::move(error_observer)) {
     on_delete_callback_runner_ = factory_->mojo_proxy_factory_->CreateResolver(
-        mojo::String::From(pac_script->utf16()), mojo::GetProxy(&resolver_ptr_),
+        base::UTF16ToUTF8(pac_script->utf16()), mojo::GetProxy(&resolver_ptr_),
         binding_.CreateInterfacePtrAndBind());
     resolver_ptr_.set_connection_error_handler(
         base::Bind(&ProxyResolverFactoryMojo::Job::OnConnectionError,
                    base::Unretained(this)));
     binding_.set_connection_error_handler(
         base::Bind(&ProxyResolverFactoryMojo::Job::OnConnectionError,
                    base::Unretained(this)));
   }
 
   void OnConnectionError() { ReportResult(ERR_PAC_SCRIPT_TERMINATED); }
@@ skipping 47 matching lines @@
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback,
                          error_observer_factory_.is_null()
                              ? nullptr
                              : error_observer_factory_.Run()));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net