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

net/proxy/proxy_resolver_factory_mojo_unittest.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 <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.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/base/test_completion_callback.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/log/test_net_log.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 309 matching lines @@
 
   void AddCreateProxyResolverAction(CreateProxyResolverAction action);
 
   void WaitForNextRequest();
 
   void ClearBlockedClients();
 
  private:
   // Overridden from interfaces::ProxyResolver:
   void CreateResolver(
-      const mojo::String& pac_url,
+      const std::string& pac_url,
       mojo::InterfaceRequest<interfaces::ProxyResolver> request,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override;
 
   void WakeWaiter();
 
   MockMojoProxyResolver* resolver_;
   std::queue<CreateProxyResolverAction> create_resolver_actions_;
 
   base::Closure quit_closure_;
 
@@ skipping 30 matching lines @@
   if (!quit_closure_.is_null())
     quit_closure_.Run();
   quit_closure_.Reset();
 }
 
 void MockMojoProxyResolverFactory::ClearBlockedClients() {
   blocked_clients_.clear();
 }
 
 void MockMojoProxyResolverFactory::CreateResolver(
-    const mojo::String& pac_script,
+    const std::string& pac_script,
     mojo::InterfaceRequest<interfaces::ProxyResolver> request,
     interfaces::ProxyResolverFactoryRequestClientPtr client) {
   ASSERT_FALSE(create_resolver_actions_.empty());
   CreateProxyResolverAction action = create_resolver_actions_.front();
   create_resolver_actions_.pop();
 
-  EXPECT_EQ(action.expected_pac_script, pac_script.To<std::string>());
+  EXPECT_EQ(action.expected_pac_script, pac_script);
   client->Alert(pac_script);
   client->OnError(12345, pac_script);
   switch (action.action) {
     case CreateProxyResolverAction::COMPLETE: {
       if (action.error == OK)
         resolver_->AddConnection(std::move(request));
       client->ReportResult(action.error);
       break;
     }
     case CreateProxyResolverAction::DROP_CLIENT: {
@@ skipping 108 matching lines @@
         this, &host_resolver_,
         base::Callback<std::unique_ptr<ProxyResolverErrorObserver>()>(),
         &net_log_));
   }
 
   std::unique_ptr<Request> MakeRequest(const GURL& url) {
     return base::MakeUnique<Request>(proxy_resolver_mojo_.get(), url);
   }
 
   std::unique_ptr<base::ScopedClosureRunner> CreateResolver(
-      const mojo::String& pac_script,
+      const std::string& pac_script,
       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
     factory_ptr_->CreateResolver(pac_script, std::move(req), std::move(client));
     return base::MakeUnique<base::ScopedClosureRunner>(
         on_delete_callback_.closure());
   }
 
   ProxyInfo ProxyServersFromPacString(const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
@@ skipping 348 matching lines @@
   mock_proxy_resolver_.ClearBlockedClients();
   request->WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net