Update from https://crrev.com/312398

mojo/services/network/udp_socket_unittest.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 "base/at_exit.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/run_loop.h"
-#include "mojo/public/cpp/application/application_connection.h"
-#include "mojo/public/cpp/application/application_impl.h"
-#include "mojo/public/cpp/application/application_test_base.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/services/network/public/cpp/udp_socket_wrapper.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "mojo/services/network/public/interfaces/udp_socket.mojom.h"
+#include "mojo/shell/shell_test_helper.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 namespace mojo {
 namespace service {
 namespace {
 
 NetAddressPtr GetLocalHostWithAnyPort() {
   NetAddressPtr addr(NetAddress::New());
   addr->family = NET_ADDRESS_FAMILY_IPV4;
   addr->ipv4 = NetAddressIPv4::New();
   addr->ipv4->port = 0;
@@ skipping 30 matching lines @@
 
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
     run_loop.Run();
     run_loop_ = nullptr;
   }
 
  protected:
   struct StateBase : public CallbackType::Runnable {
     StateBase() : test_callback_(nullptr) {}
-    ~StateBase() override {}
+    virtual ~StateBase() {}
 
     void set_test_callback(TestCallbackBase* test_callback) {
       test_callback_ = test_callback;
     }
 
    protected:
     void NotifyRun() const {
       if (test_callback_) {
         test_callback_->ran_ = true;
         if (test_callback_->run_loop_)
@@ skipping 137 matching lines @@
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
   NetAddressPtr src_addr_;
   Array<uint8_t> data_;
 };
 
-class UDPSocketAppTest : public test::ApplicationTestBase {
+class UDPSocketTest : public testing::Test {
  public:
-  UDPSocketAppTest() {}
-  ~UDPSocketAppTest() override {}
+  UDPSocketTest() {}
+  virtual ~UDPSocketTest() {}
 
-  void SetUp() override {
-    ApplicationTestBase::SetUp();
+  virtual void SetUp() override {
+    test_helper_.Init();
 
-    ApplicationConnection* connection =
-        application_impl()->ConnectToApplication("mojo:network_service");
-    connection->ConnectToService(&network_service_);
+    test_helper_.application_manager()->ConnectToService(
+        GURL("mojo:network_service"), &network_service_);
 
     network_service_->CreateUDPSocket(GetProxy(&udp_socket_));
     udp_socket_.set_client(&udp_socket_client_);
   }
 
  protected:
   struct ReceiveResult {
     NetworkErrorPtr result;
     NetAddressPtr addr;
     Array<uint8_t> data;
@@ skipping 42 matching lines @@
     if (GetReceiveResults()->size() == count)
       return;
 
     udp_socket_client_.expected_receive_count_ = count;
     base::RunLoop run_loop;
     udp_socket_client_.run_loop_ = &run_loop;
     run_loop.Run();
     udp_socket_client_.run_loop_ = nullptr;
   }
 
+  base::ShadowingAtExitManager at_exit_;
+  shell::ShellTestHelper test_helper_;
+
   NetworkServicePtr network_service_;
   UDPSocketPtr udp_socket_;
   UDPSocketClientImpl udp_socket_client_;
 
-  DISALLOW_COPY_AND_ASSIGN(UDPSocketAppTest);
+  DISALLOW_COPY_AND_ASSIGN(UDPSocketTest);
 };
 
 }  // namespace
 
-TEST_F(UDPSocketAppTest, Settings) {
+TEST_F(UDPSocketTest, Settings) {
   TestCallback callback1;
   udp_socket_->AllowAddressReuse(callback1.callback());
   callback1.WaitForResult();
   EXPECT_EQ(net::OK, callback1.result()->code);
 
   // Should fail because the socket hasn't been bound.
   TestCallback callback2;
   udp_socket_->SetSendBufferSize(1024, callback2.callback());
   callback2.WaitForResult();
   EXPECT_NE(net::OK, callback2.result()->code);
@@ skipping 30 matching lines @@
   udp_socket_->NegotiateMaxPendingSendRequests(0, callback8.callback());
   callback8.WaitForResult();
   EXPECT_GT(callback8.result(), 0u);
 
   TestCallbackWithUint32 callback9;
   udp_socket_->NegotiateMaxPendingSendRequests(16, callback9.callback());
   callback9.WaitForResult();
   EXPECT_GT(callback9.result(), 0u);
 }
 
-TEST_F(UDPSocketAppTest, TestReadWrite) {
+TEST_F(UDPSocketTest, TestReadWrite) {
   TestCallbackWithAddress callback1;
   udp_socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
@@ skipping 25 matching lines @@
     scoped_ptr<ReceiveResult> result(GetReceiveResults()->front());
     GetReceiveResults()->pop();
 
     EXPECT_EQ(static_cast<int>(kDatagramSize), result->result->code);
     EXPECT_TRUE(result->addr.Equals(client_addr));
     EXPECT_TRUE(result->data.Equals(
         CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize)));
   }
 }
 
-TEST_F(UDPSocketAppTest, TestUDPSocketWrapper) {
+TEST_F(UDPSocketTest, TestUDPSocketWrapper) {
   UDPSocketWrapper udp_socket(udp_socket_.Pass(), 4, 4);
 
   TestCallbackWithAddress callback1;
   udp_socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
@@ skipping 33 matching lines @@
                 receive_callbacks[j].result()->code);
       EXPECT_TRUE(receive_callbacks[j].src_addr().Equals(client_addr));
       EXPECT_TRUE(receive_callbacks[j].data().Equals(
           CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize)));
     }
   }
 }
 
 }  // namespace service
 }  // namespace mojo