Relax ad-hoc assumptions on InterceptingResourceHandler

content/browser/loader/mime_sniffing_resource_handler_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 "content/browser/loader/mime_sniffing_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 348 matching lines @@
                                           allow_download,  // allow_download
                                           true,            // is_async
                                           false);          // is_using_lofi
 
   TestResourceDispatcherHost host(stream_has_handler_);
   TestResourceDispatcherHostDelegate host_delegate(must_download);
   host.SetDelegate(&host_delegate);
 
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(
+                                          true,    // response_started_succeeds
+                                          false,   // defer_response_started
+                                          true,    // will_read_succeeds,
+                                          true,    // read_completed_succeeds,
+                                          false),  // defer_read_completed
                                       nullptr));
   std::unique_ptr<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
       std::unique_ptr<ResourceHandler>(
           new TestResourceHandler(false, false, false, false, false)),
       &host, &plugin_service, intercepting_handler.get(), request.get(),
       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_handler->SetController(&resource_controller);
 
@@ skipping 31 matching lines @@
                                           false,    // allow_download
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   TestResourceDispatcherHost host(false);
   TestResourceDispatcherHostDelegate host_delegate(false);
   host.SetDelegate(&host_delegate);
 
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(
+                                          true,    // response_started_succeeds
+                                          false,   // defer_on_response_started
+                                          true,    // will_read_succeeds
+                                          true,    // read_completed_succeeds
+                                          false),  // defer_on_read_completed
                                       nullptr));
   std::unique_ptr<TestResourceHandler> scoped_test_handler =
       std::unique_ptr<TestResourceHandler>(new TestResourceHandler(
           response_started, defer_response_started, will_read, read_completed,
           defer_read_completed));
   TestResourceHandler* test_handler = scoped_test_handler.get();
   std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
                                       intercepting_handler.get(), request.get(),
@@ skipping 140 matching lines @@
                                           false,    // allow_download
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   TestResourceDispatcherHost host(false);
   TestResourceDispatcherHostDelegate host_delegate(false);
   host.SetDelegate(&host_delegate);
 
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(
+                                          true,    // response_started_succeeds
+                                          false,   // defer_response_started
+                                          true,    // will_read_succeeds,
+                                          true,    // read_completed_succeeds,
+                                          false),  // defer_read_completed
                                       nullptr));
 
   std::unique_ptr<TestResourceHandler> scoped_test_handler =
       std::unique_ptr<TestResourceHandler>(new TestResourceHandler(
           response_started, defer_response_started, will_read, read_completed,
           defer_read_completed));
   TestResourceHandler* test_handler = scoped_test_handler.get();
   std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
@@ skipping 373 matching lines @@
                                           true,     // allow_download
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   TestResourceDispatcherHost host(false);
   TestResourceDispatcherHostDelegate host_delegate(false);
   host.SetDelegate(&host_delegate);
 
   TestFakePluginService plugin_service(false, false);
   std::unique_ptr<ResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(
+                                          true,    // response_started_succeeds
+                                          false,   // defer_response_started
+                                          true,    // will_read_succeeds,
+                                          true,    // read_completed_succeeds,
+                                          false),  // defer_read_completed
                                       nullptr));
   std::unique_ptr<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
       std::unique_ptr<ResourceHandler>(
           new TestResourceHandler(true, false, true, true, false)),
       &host, &plugin_service,
       static_cast<InterceptingResourceHandler*>(intercepting_handler.get()),
       request.get(), REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_handler->SetController(&resource_controller);
@@ skipping 27 matching lines @@
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           false,    // allow_download
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   TestResourceDispatcherHost host(false);
 
   TestFakePluginService plugin_service(false, false);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(nullptr, nullptr));
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(
+                                          true,    // response_started_succeeds
+                                          false,   // defer_response_started
+                                          true,    // will_read_succeeds,
+                                          true,    // read_completed_succeeds,
+                                          false),  // defer_read_completed
+                                      nullptr));
 
   std::unique_ptr<TestResourceHandler> scoped_test_handler(
       new TestResourceHandler(false,    // response_started
                               false,    // defer_response_started
                               true,     // will_read,
                               true,     // read_completed,
                               false));  // defer_read_completed
   std::unique_ptr<ResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
@@ skipping 14 matching lines @@
   // mime sniffing is disabled and the wrapped resource handler returns false
   // on OnResponseStarted.
   EXPECT_FALSE(
       mime_sniffing_handler->OnResponseStarted(response.get(), &defer));
 
   // Process all messages to ensure proper test teardown.
   content::RunAllPendingInMessageLoop();
 }
 
 }  // namespace content