NetworkService: Destroy URLLoaders when a NetworkContext is destroyed.

net/test/embedded_test_server/default_handlers.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/test/embedded_test_server/default_handlers.h"
 
 #include <stdlib.h>
 #include <ctime>
 #include <map>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/md5.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 568 matching lines @@
     delay = std::atof(request_url.query().c_str());
 
   std::unique_ptr<BasicHttpResponse> http_response(
       new DelayedHttpResponse(delay));
   http_response->set_content_type("text/plain");
   http_response->set_content(base::StringPrintf("waited %.1f seconds", delay));
   return std::move(http_response);
 }
 
 // Never returns a response.
-class HungHttpResponse : public BasicHttpResponse {
+class HungHttpResponse : public HttpResponse {
  public:
   HungHttpResponse() {}
 
   void SendResponse(const SendBytesCallback& send,
                     const SendCompleteCallback& done) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HungHttpResponse);
 };
 
 // /hung
 // Never returns a response.
 std::unique_ptr<HttpResponse> HandleHungResponse(const HttpRequest& request) {
   return base::MakeUnique<HungHttpResponse>();
 }
 
+// Return headers, then hangs.
+class HungAfterHeadersHttpResponse : public HttpResponse {
+ public:
+  HungAfterHeadersHttpResponse() {}
+
+  void SendResponse(const SendBytesCallback& send,
+                    const SendCompleteCallback& done) override {
+    send.Run("HTTP/1.1 OK\r\n\r\n", base::Bind(&base::DoNothing));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(HungAfterHeadersHttpResponse);
+};
+
+// /hung-after-headers
+// Never returns a response.
+std::unique_ptr<HttpResponse> HandleHungAfterHeadersResponse(
+    const HttpRequest& request) {
+  return base::MakeUnique<HungAfterHeadersHttpResponse>();
+}
+
 }  // anonymous namespace
 
 #define PREFIXED_HANDLER(prefix, handler) \
   base::Bind(&HandlePrefixedRequest, prefix, base::Bind(handler))
 
 void RegisterDefaultHandlers(EmbeddedTestServer* server) {
   server->RegisterDefaultHandler(base::Bind(&HandleDefaultConnect));
 
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/cachetime", &HandleCacheTime));
@@ skipping 25 matching lines @@
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/server-redirect", &HandleServerRedirect));
   server->RegisterDefaultHandler(base::Bind(&HandleCrossSiteRedirect, server));
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/client-redirect", &HandleClientRedirect));
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/defaultresponse", &HandleDefaultResponse));
   server->RegisterDefaultHandler(PREFIXED_HANDLER("/slow", &HandleSlowServer));
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/hung", &HandleHungResponse));
+  server->RegisterDefaultHandler(
+      PREFIXED_HANDLER("/hung-after-headers", &HandleHungAfterHeadersResponse));
 
   // TODO(svaldez): HandleDownload
   // TODO(svaldez): HandleDownloadFinish
   // TODO(svaldez): HandleZipFile
   // TODO(svaldez): HandleSSLManySmallRecords
   // TODO(svaldez): HandleChunkedServer
   // TODO(svaldez): HandleGetSSLSessionCache
   // TODO(svaldez): HandleGetChannelID
   // TODO(svaldez): HandleGetClientCert
   // TODO(svaldez): HandleClientCipherList
   // TODO(svaldez): HandleEchoMultipartPost
 }
 
 #undef PREFIXED_HANDLER
 
 }  // namespace test_server
 }  // namespace net