Merge TestResourceHandlers used by two different test fixtures.

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/browser/loader/test_resource_handler.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"
 #include "content/public/test/test_utils.h"
 #include "content/test/fake_plugin_service.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
-class TestResourceHandler : public ResourceHandler {
- public:
-  TestResourceHandler(bool response_started_succeeds,
-                      bool defer_on_response_started,
-                      bool will_read_succeeds,
-                      bool read_completed_succeeds,
-                      bool defer_on_read_completed)
-      : ResourceHandler(nullptr),
-        buffer_(new net::IOBuffer(2048)),
-        response_started_succeeds_(response_started_succeeds),
-        defer_on_response_started_(defer_on_response_started),
-        will_read_succeeds_(will_read_succeeds),
-        read_completed_succeeds_(read_completed_succeeds),
-        defer_on_read_completed_(defer_on_read_completed),
-        on_will_start_called_(0),
-        on_request_redirected_called_(0),
-        on_response_started_called_(0),
-        on_will_read_called_(0),
-        on_read_completed_called_(0) {}
-
-  void SetController(ResourceController* controller) override {}
-
-  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
-                           ResourceResponse* response,
-                           bool* defer) override {
-    on_request_redirected_called_++;
-    NOTREACHED();
-    return false;
-  }
-
-  bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
-    on_response_started_called_++;
-    if (defer_on_response_started_)
-      *defer = true;
-    return response_started_succeeds_;
-  }
-
-  bool OnWillStart(const GURL& url, bool* defer) override {
-    on_will_start_called_++;
-    return false;
-  }
-
-  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                  int* buf_size,
-                  int min_size) override {
-    on_will_read_called_++;
-    *buf = buffer_;
-    *buf_size = 2048;
-    return will_read_succeeds_;
-  }
-
-  bool OnReadCompleted(int bytes_read, bool* defer) override {
-    DCHECK_LT(bytes_read, 2048);
-    on_read_completed_called_++;
-    if (defer_on_read_completed_)
-      *defer = true;
-    return read_completed_succeeds_;
-  }
-
-  void OnResponseCompleted(const net::URLRequestStatus& status,
-                           bool* defer) override {}
-
-  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
-
-  scoped_refptr<net::IOBuffer> buffer() { return buffer_; }
-
-  int on_will_start_called() const { return on_will_start_called_; }
-  int on_request_redirected_called() const {
-    return on_request_redirected_called_;
-  }
-  int on_response_started_called() const { return on_response_started_called_; }
-  int on_will_read_called() const { return on_will_read_called_; }
-  int on_read_completed_called() const { return on_read_completed_called_; }
-
- private:
-  scoped_refptr<net::IOBuffer> buffer_;
-  bool response_started_succeeds_;
-  bool defer_on_response_started_;
-  bool will_read_succeeds_;
-  bool read_completed_succeeds_;
-  bool defer_on_read_completed_;
-
-  int on_will_start_called_;
-  int on_request_redirected_called_;
-  int on_response_started_called_;
-  int on_will_read_called_;
-  int on_read_completed_called_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
-};
-
 class TestResourceDispatcherHostDelegate
     : public ResourceDispatcherHostDelegate {
  public:
   explicit TestResourceDispatcherHostDelegate(bool must_download)
       : must_download_(must_download) {}
 
   bool ShouldForceDownloadResource(const GURL& url,
                                    const std::string& mime_type) override {
     return must_download_;
   }
@@ skipping 35 matching lines @@
     return intercepted_as_stream_count_;
   }
 
   TestResourceHandler* new_resource_handler() const {
     return new_resource_handler_;
   }
 
  private:
   std::unique_ptr<ResourceHandler> CreateNewResourceHandler() {
     std::unique_ptr<TestResourceHandler> new_resource_handler(
-        new TestResourceHandler(false, false, true, true, false));
+        new TestResourceHandler());
+    new_resource_handler->set_on_response_started_result(false);
     new_resource_handler_ = new_resource_handler.get();
     return std::move(new_resource_handler);
   }
 
   // Whether the URL request should be intercepted as a stream.
   bool stream_has_handler_;
 
   // Whether the URL request has been intercepted as a stream.
   bool intercepted_as_stream_;
 
@@ skipping 140 matching lines @@
                                           nullptr,        // context
                                           0,              // render_process_id
                                           0,              // render_view_id
                                           0,              // render_frame_id
                                           is_main_frame,  // is_main_frame
                                           false,   // parent_is_main_frame
                                           false,   // allow_download
                                           true,    // is_async
                                           false);  // is_using_lofi
 
+  std::unique_ptr<TestResourceHandler> scoped_test_handler(
+      new TestResourceHandler());
+  scoped_test_handler->set_on_response_started_result(false);
+
   std::unique_ptr<ResourceHandler> mime_sniffing_handler(
-      new MimeSniffingResourceHandler(
-          std::unique_ptr<ResourceHandler>(
-              new TestResourceHandler(false, false, false, false, false)),
-          nullptr, nullptr, nullptr, request,
-          REQUEST_CONTEXT_TYPE_UNSPECIFIED));
+      new MimeSniffingResourceHandler(std::move(scoped_test_handler), nullptr,
+                                      nullptr, nullptr, request,
+                                      REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   bool defer = false;
   mime_sniffing_handler->OnWillStart(request->url(), &defer);
   content::RunAllPendingInMessageLoop();
 
   std::string accept_header;
   request->extra_request_headers().GetHeader("Accept", &accept_header);
   return accept_header;
 }
 
@@ skipping 14 matching lines @@
                                           false,  // parent_is_main_frame
                                           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(base::MakeUnique<TestResourceHandler>(
-                                          true,    // response_started_succeeds
-                                          false,   // defer_response_started
-                                          true,    // will_read_succeeds,
-                                          true,    // read_completed_succeeds,
-                                          false),  // defer_read_completed
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       nullptr));
+  std::unique_ptr<TestResourceHandler> scoped_test_handler(
+      new TestResourceHandler());
+  scoped_test_handler->set_on_response_started_result(false);
   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(),
+      std::unique_ptr<ResourceHandler>(std::move(scoped_test_handler)), &host,
+      &plugin_service, intercepting_handler.get(), request.get(),
       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_handler->SetController(&resource_controller);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   // The MIME type isn't important but it shouldn't be empty.
   response->head.mime_type = "application/pdf";
 
   bool defer = false;
+  mime_handler->OnWillStart(request->url(), &defer);
+  EXPECT_FALSE(defer);
+
   mime_handler->OnResponseStarted(response.get(), &defer);
 
   content::RunAllPendingInMessageLoop();
   EXPECT_LT(host.intercepted_as_stream_count(), 2);
   if (allow_download)
     EXPECT_TRUE(intercepting_handler->new_handler_for_testing());
   return host.intercepted_as_stream();
 }
 
 void MimeSniffingResourceHandlerTest::TestHandlerSniffing(
@@ skipping 16 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(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
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       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));
+
+  std::unique_ptr<TestResourceHandler> scoped_test_handler(
+      new TestResourceHandler());
+  scoped_test_handler->set_on_response_started_result(response_started);
+  scoped_test_handler->set_defer_on_response_started(defer_response_started);
+  scoped_test_handler->set_on_will_read_result(will_read);
+  scoped_test_handler->set_on_read_completed_result(read_completed);
+  scoped_test_handler->set_defer_on_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(),
                                       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
@@ skipping 135 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(base::MakeUnique<TestResourceHandler>(
-                                          true,    // response_started_succeeds
-                                          false,   // defer_response_started
-                                          true,    // will_read_succeeds,
-                                          true,    // read_completed_succeeds,
-                                          false),  // defer_read_completed
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       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));
+  std::unique_ptr<TestResourceHandler> scoped_test_handler(
+      new TestResourceHandler());
+  scoped_test_handler->set_on_response_started_result(response_started);
+  scoped_test_handler->set_defer_on_response_started(defer_response_started);
+  scoped_test_handler->set_on_will_read_result(will_read);
+  scoped_test_handler->set_on_read_completed_result(read_completed);
+  scoped_test_handler->set_defer_on_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(),
                                       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
@@ skipping 367 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(base::MakeUnique<TestResourceHandler>(
-                                          true,    // response_started_succeeds
-                                          false,   // defer_response_started
-                                          true,    // will_read_succeeds,
-                                          true,    // read_completed_succeeds,
-                                          false),  // defer_read_completed
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       nullptr));
   std::unique_ptr<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
-      std::unique_ptr<ResourceHandler>(
-          new TestResourceHandler(true, false, true, true, false)),
-      &host, &plugin_service,
+      std::unique_ptr<ResourceHandler>(new TestResourceHandler()), &host,
+      &plugin_service,
       static_cast<InterceptingResourceHandler*>(intercepting_handler.get()),
       request.get(), REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_handler->SetController(&resource_controller);
 
+  // Request starts.
+  bool defer = false;
+  mime_handler->OnWillStart(request->url(), &defer);
+  EXPECT_FALSE(defer);
+
   // Simulate a 304 response.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   // The MIME type isn't important but it shouldn't be empty.
   response->head.mime_type = "application/pdf";
   response->head.headers = new net::HttpResponseHeaders("HTTP/1.x 304 OK");
 
   // The response is received. No new ResourceHandler should be created to
   // handle the download.
-  bool defer = false;
   mime_handler->OnResponseStarted(response.get(), &defer);
   EXPECT_FALSE(defer);
   EXPECT_FALSE(host.new_resource_handler());
 
   content::RunAllPendingInMessageLoop();
 }
 
 TEST_F(MimeSniffingResourceHandlerTest, FetchShouldDisableMimeSniffing) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
                                           0,        // render_frame_id
                                           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(base::MakeUnique<TestResourceHandler>(
-                                          true,    // response_started_succeeds
-                                          false,   // defer_response_started
-                                          true,    // will_read_succeeds,
-                                          true,    // read_completed_succeeds,
-                                          false),  // defer_read_completed
+      new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       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
+      new TestResourceHandler());
+  scoped_test_handler->set_on_response_started_result(false);
   std::unique_ptr<ResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
                                       intercepting_handler.get(), request.get(),
                                       REQUEST_CONTEXT_TYPE_FETCH));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
   bool defer = false;
   mime_sniffing_handler->OnWillStart(GURL(), &defer);
   ASSERT_FALSE(defer);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   response->head.mime_type = "text/plain";
 
   // |mime_sniffing_handler->OnResponseStarted| should return false because
   // 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