Add servicetest for network service.

BUG=598073

Change-Id: I575dec98b3b0145a7fd953de5821f10524a4b8e6
Reviewed-on: https://chromium-review.googlesource.com/588086
Commit-Queue: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Ken Rockot <rockot@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491439}

content/network/DEPS

@@ -23,6 +23,7 @@ include_rules = [
 specific_include_rules = {
   '.*_[a-z]*test.*': [
     "+content/public/common/content_paths.h",
+    "+content/public/common/service_names.mojom.h",
     "+content/public/test/test_url_loader_client.h",
   ],
 }

content/network/network_service_impl.cc

@@ -57,7 +57,7 @@ class NetworkServiceImpl::MojoNetLog : public net::NetLog {
 NetworkServiceImpl::NetworkServiceImpl(
     std::unique_ptr<service_manager::BinderRegistry> registry)
     : net_log_(new MojoNetLog), registry_(std::move(registry)), binding_(this) {
-  // |registry_| is nullptr in tests and when an in-process NetworkService is
+  // |registry_| is nullptr when an in-process NetworkService is
   // created directly. The latter is done in concert with using
   // CreateNetworkContextWithBuilder to ease the transition to using the network
   // service.
@@ -94,7 +94,8 @@ NetworkServiceImpl::CreateNetworkContextWithBuilder(
 }
 
 std::unique_ptr<NetworkServiceImpl> NetworkServiceImpl::CreateForTesting() {
-  return base::WrapUnique(new NetworkServiceImpl(nullptr));
+  return base::WrapUnique(new NetworkServiceImpl(
+      base::MakeUnique<service_manager::BinderRegistry>()));
 }
 
 void NetworkServiceImpl::RegisterNetworkContext(

content/network/network_service_unittest.cc

@@ -10,6 +10,13 @@
 #include "content/network/network_context.h"
 #include "content/network/network_service_impl.h"
 #include "content/public/common/network_service.mojom.h"
+#include "content/public/common/service_names.mojom.h"
+#include "content/public/test/test_url_loader_client.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
+#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_test.h"
+#include "services/service_manager/public/interfaces/service_factory.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -66,6 +73,110 @@ TEST_F(NetworkServiceTest, DestroyingServiceDestroysContext) {
   run_loop.Run();
 }
 
+namespace {
+
+class ServiceTestClient : public service_manager::test::ServiceTestClient,
+                          public service_manager::mojom::ServiceFactory {
+ public:
+  explicit ServiceTestClient(service_manager::test::ServiceTest* test)
+      : service_manager::test::ServiceTestClient(test) {
+    registry_.AddInterface<service_manager::mojom::ServiceFactory>(base::Bind(
+        &ServiceTestClient::BindServiceFactoryRequest, base::Unretained(this)));
+  }
+  ~ServiceTestClient() override {}
+
+ protected:
+  void OnBindInterface(const service_manager::BindSourceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override {
+    registry_.BindInterface(interface_name, std::move(interface_pipe));
+  }
+
+  void CreateService(service_manager::mojom::ServiceRequest request,
+                     const std::string& name) override {
+    if (name == mojom::kNetworkServiceName) {
+      service_context_.reset(new service_manager::ServiceContext(
+          NetworkServiceImpl::CreateForTesting(), std::move(request)));
+    }
+  }
+
+  void BindServiceFactoryRequest(
+      service_manager::mojom::ServiceFactoryRequest request) {
+    service_factory_bindings_.AddBinding(this, std::move(request));
+  }
+
+ private:
+  service_manager::BinderRegistry registry_;
+  mojo::BindingSet<service_manager::mojom::ServiceFactory>
+      service_factory_bindings_;
+  std::unique_ptr<service_manager::ServiceContext> service_context_;
+};
+
+}  // namespace
+
+class NetworkServiceTestWithService
+    : public service_manager::test::ServiceTest {
+ public:
+  NetworkServiceTestWithService()
+      : ServiceTest("content_unittests",
+                    false,
+                    base::test::ScopedTaskEnvironment::MainThreadType::IO) {}
+  ~NetworkServiceTestWithService() override {}
+
+  void LoadURL(const GURL& url) {
+    mojom::NetworkServicePtr network_service;
+    connector()->BindInterface(mojom::kNetworkServiceName, &network_service);
+
+    mojom::NetworkContextPtr network_context;
+    mojom::NetworkContextParamsPtr context_params =
+        mojom::NetworkContextParams::New();
+    network_service->CreateNetworkContext(mojo::MakeRequest(&network_context),
+                                          std::move(context_params));
+
+    mojom::URLLoaderFactoryPtr loader_factory;
+    network_context->CreateURLLoaderFactory(mojo::MakeRequest(&loader_factory),
+                                            0);
+
+    mojom::URLLoaderPtr loader;
+    ResourceRequest request;
+    request.url = url;
+    request.method = "GET";
+    request.request_initiator = url::Origin();
+    loader_factory->CreateLoaderAndStart(
+        mojo::MakeRequest(&loader), 1, 1, mojom::kURLLoadOptionNone, request,
+        client_.CreateInterfacePtr(),
+        net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
+    client_.RunUntilComplete();
+  }
+
+  net::EmbeddedTestServer* test_server() { return &test_server_; }
+  TestURLLoaderClient* client() { return &client_; }
+
+ private:
+  std::unique_ptr<service_manager::Service> CreateService() override {
+    return base::MakeUnique<ServiceTestClient>(this);
+  }
+
+  void SetUp() override {
+    base::FilePath content_test_data(FILE_PATH_LITERAL("content/test/data"));
+    test_server_.AddDefaultHandlers(content_test_data);
+    ASSERT_TRUE(test_server_.Start());
+    service_manager::test::ServiceTest::SetUp();
+  }
+
+  net::EmbeddedTestServer test_server_;
+  TestURLLoaderClient client_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkServiceTestWithService);
+};
+
+// Verifies that loading a URL through the network service's mojo interface
+// works.
+TEST_F(NetworkServiceTestWithService, Basic) {
+  LoadURL(test_server()->GetURL("/echo"));
+  EXPECT_EQ(net::OK, client()->completion_status().error_code);
+}
+
 }  // namespace
 
 }  // namespace content

content/test/BUILD.gn

@@ -1888,7 +1888,10 @@ test("content_unittests") {
 service_manifest("content_unittests_manifest") {
   name = "content_unittests"
   source = "unittests_manifest.json"
-  packaged_services = [ "//services/file:manifest" ]
+  packaged_services = [
+    "//content/network:manifest",
+    "//services/file:manifest",
+  ]
 }
 
 catalog("content_unittests_catalog") {

content/test/unittests_manifest.json

@@ -9,7 +9,8 @@
          ]
       },
       "requires": {
-        "file": [ "file:filesystem", "file:leveldb" ]
+        "file": [ "file:filesystem", "file:leveldb" ],
+        "network": [ "network_service" ]
       }
     }
   }

services/service_manager/public/cpp/service_test.cc

@@ -34,9 +34,10 @@ void ServiceTestClient::OnBindInterface(
 
 ServiceTest::ServiceTest() : ServiceTest(std::string(), true) {}
 
-ServiceTest::ServiceTest(const std::string& test_name, bool init_edk)
-    : scoped_task_environment_(
-          base::test::ScopedTaskEnvironment::MainThreadType::UI),
+ServiceTest::ServiceTest(const std::string& test_name,
+                         bool init_edk,
+                         base::test::ScopedTaskEnvironment::MainThreadType type)
+    : scoped_task_environment_(type),
       test_name_(test_name),
       init_edk_(init_edk) {}
 

services/service_manager/public/cpp/service_test.h

@@ -60,7 +60,10 @@ class ServiceTest : public testing::Test {
   // Once set via this constructor, it cannot be changed later by calling
   // InitTestName(). The test executable must provide a manifest in the
   // appropriate location that specifies this name also.
-  explicit ServiceTest(const std::string& test_name, bool init_edk = false);
+  ServiceTest(const std::string& test_name,
+              bool init_edk = false,
+              base::test::ScopedTaskEnvironment::MainThreadType type =
+                  base::test::ScopedTaskEnvironment::MainThreadType::UI);
   ~ServiceTest() override;
 
  protected: