NetworkService: Destroy NetworkContexts on NetworkService teardown.

content/network/network_service.cc

 // Copyright 2017 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 "content/network/network_service.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "content/network/network_context.h"
@@ skipping 37 matching lines @@
   }
 
  private:
   std::unique_ptr<net::WriteToFileNetLogObserver> write_to_file_observer_;
   DISALLOW_COPY_AND_ASSIGN(MojoNetLog);
 };
 
 NetworkService::NetworkService(
     std::unique_ptr<service_manager::BinderRegistry> registry)
     : net_log_(new MojoNetLog), registry_(std::move(registry)), binding_(this) {
-  registry_->AddInterface<mojom::NetworkService>(
-      base::Bind(&NetworkService::Create, base::Unretained(this)));
+  // |registry_| may be nullptr in tests.
+  if (registry_) {
+    registry_->AddInterface<mojom::NetworkService>(
+        base::Bind(&NetworkService::Create, base::Unretained(this)));
+  }
 }
 
-NetworkService::~NetworkService() = default;
+NetworkService::~NetworkService() {
+  // Call each Network and ask it to release its net::URLRequestContext, as they
+  // may have references to shared objects owned by the NetworkService. The
+  // NetworkContexts deregister themselves in Cleanup(), so have to be careful.
+  while (!network_contexts_.empty())
+    (*network_contexts_.begin())->Cleanup();
+}
+
+std::unique_ptr<NetworkService> NetworkService::CreateForTesting() {
+  return base::WrapUnique(new NetworkService());
+}
+
+void NetworkService::RegisterNetworkContext(NetworkContext* network_context) {
+  DCHECK_EQ(0u, network_contexts_.count(network_context));
+  network_contexts_.insert(network_context);
+}
+
+void NetworkService::DeregisterNetworkContext(NetworkContext* network_context) {
+  DCHECK_EQ(1u, network_contexts_.count(network_context));
+  network_contexts_.erase(network_context);
+}
+
+void NetworkService::CreateNetworkContext(
+    mojom::NetworkContextRequest request,
+    mojom::NetworkContextParamsPtr params) {
+  // The NetworkContext will destroy itself on connection error, or when the
+  // service is destroyed.
+  new NetworkContext(this, std::move(request), std::move(params));
+}
+
+NetworkService::NetworkService() : NetworkService(nullptr) {}
 
 void NetworkService::OnBindInterface(
     const service_manager::BindSourceInfo& source_info,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   registry_->BindInterface(source_info, interface_name,
                            std::move(interface_pipe));
 }
 
 void NetworkService::Create(const service_manager::BindSourceInfo& source_info,
                             mojom::NetworkServiceRequest request) {
   DCHECK(!binding_.is_bound());
   binding_.Bind(std::move(request));
 }
 
-void NetworkService::CreateNetworkContext(
-    mojom::NetworkContextRequest request,
-    mojom::NetworkContextParamsPtr params) {
-  mojo::MakeStrongBinding(
-      base::MakeUnique<NetworkContext>(std::move(request), std::move(params)),
-      std::move(request));
-}
-
 }  // namespace content