Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 412 matching lines @@
                                response_data,
                                auto_advance) {}
 
  protected:
   ~URLRequestTestDelayedCompletionJob() override {}
 
  private:
   bool NextReadAsync() override { return true; }
 };
 
+// This class is a variation on URLRequestTestJob that ensures that no read is
+// asked of this job.
+class URLRequestMustNotReadTestJob : public net::URLRequestTestJob {
+ public:
+  URLRequestMustNotReadTestJob(net::URLRequest* request,
+                               net::NetworkDelegate* network_delegate,
+                               const std::string& response_headers,
+                               const std::string& response_data)
+      : net::URLRequestTestJob(request,
+                               network_delegate,
+                               response_headers,
+                               response_data,
+                               false) {}
+
+  int ReadRawData(net::IOBuffer* buf, int buf_size) override {
+    EXPECT_TRUE(false) << "The job should have been cancelled before trying to "
+                          "read the response body.";
+    return 0;
+  }
+};
+
 class URLRequestBigJob : public net::URLRequestSimpleJob {
  public:
   URLRequestBigJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate)
       : net::URLRequestSimpleJob(request, network_delegate) {
   }
 
   // URLRequestSimpleJob implementation:
   int GetData(std::string* mime_type,
               std::string* charset,
@@ skipping 75 matching lines @@
 
 class ResourceDispatcherHostTest;
 
 class TestURLRequestJobFactory : public net::URLRequestJobFactory {
  public:
   explicit TestURLRequestJobFactory(ResourceDispatcherHostTest* test_fixture)
       : test_fixture_(test_fixture),
         hang_after_start_(false),
         delay_start_(false),
         delay_complete_(false),
-        url_request_jobs_created_count_(0) {
-  }
+        must_not_read_(false),
+        url_request_jobs_created_count_(0) {}
 
   void HandleScheme(const std::string& scheme) {
     supported_schemes_.insert(scheme);
   }
 
   int url_request_jobs_created_count() const {
     return url_request_jobs_created_count_;
   }
 
   // When set, jobs will hang eternally once started.
   void SetHangAfterStartJobGeneration(bool hang_after_start) {
     hang_after_start_ = hang_after_start;
   }
 
   void SetDelayedStartJobGeneration(bool delay_job_start) {
     delay_start_ = delay_job_start;
   }
 
   void SetDelayedCompleteJobGeneration(bool delay_job_complete) {
     delay_complete_ = delay_job_complete;
   }
 
+  void SetMustNotReadJobGeneration(bool must_not_read) {
+    must_not_read_ = must_not_read;
+  }
+
   net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override;
 
   net::URLRequestJob* MaybeInterceptRedirect(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       const GURL& location) const override;
 
@@ skipping 11 matching lines @@
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   ResourceDispatcherHostTest* test_fixture_;
   bool hang_after_start_;
   bool delay_start_;
   bool delay_complete_;
+  bool must_not_read_;
   mutable int url_request_jobs_created_count_;
   std::set<std::string> supported_schemes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLRequestJobFactory);
 };
 
 // Associated with an URLRequest to determine if the URLRequest gets deleted.
 class TestUserData : public base::SupportsUserData::Data {
  public:
   explicit TestUserData(bool* was_deleted)
@@ skipping 10 matching lines @@
     : public TestContentBrowserClient {
  public:
   bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context,
                                       const GURL& current_url,
                                       const GURL& new_url) override {
     return true;
   }
 };
 
 enum GenericResourceThrottleFlags {
-  NONE                      = 0,
-  DEFER_STARTING_REQUEST    = 1 << 0,
-  DEFER_PROCESSING_RESPONSE = 1 << 1,
-  CANCEL_BEFORE_START       = 1 << 2
+  NONE                       = 0,
+  DEFER_STARTING_REQUEST     = 1 << 0,
+  DEFER_PROCESSING_RESPONSE  = 1 << 1,
+  CANCEL_BEFORE_START        = 1 << 2,
+  CANCEL_PROCESSING_RESPONSE = 1 << 3,
+  MUST_NOT_CACHE_BODY        = 1 << 4,
 };
 
 // Throttle that tracks the current throttle blocking a request.  Only one
 // can throttle any request at a time.
 class GenericResourceThrottle : public ResourceThrottle {
  public:
   // The value is used to indicate that the throttle should not provide
   // a error code when cancelling a request. net::OK is used, because this
   // is not an error code.
   static const int USE_DEFAULT_CANCEL_ERROR_CODE = net::OK;
@@ skipping 24 matching lines @@
       }
     }
   }
 
   void WillProcessResponse(bool* defer) override {
     ASSERT_EQ(NULL, active_throttle_);
     if (flags_ & DEFER_PROCESSING_RESPONSE) {
       active_throttle_ = this;
       *defer = true;
     }
+
+    if (flags_ & CANCEL_PROCESSING_RESPONSE) {
+      if (error_code_for_cancellation_ == USE_DEFAULT_CANCEL_ERROR_CODE) {
+        controller()->Cancel();
+      } else {
+        controller()->CancelWithError(error_code_for_cancellation_);
+      }
+    }
   }
 
   const char* GetNameForLogging() const override {
     return "GenericResourceThrottle";
   }
 
   void Resume() {
     ASSERT_TRUE(this == active_throttle_);
     active_throttle_ = NULL;
     controller()->Resume();
   }
 
   static GenericResourceThrottle* active_throttle() {
     return active_throttle_;
   }
 
+  bool MustProcessResponseBeforeReadingBody() override {
+    return flags_ & MUST_NOT_CACHE_BODY;
+  }
+
  private:
   int flags_;  // bit-wise union of GenericResourceThrottleFlags.
   int error_code_for_cancellation_;
 
   // The currently active throttle, if any.
   static GenericResourceThrottle* active_throttle_;
 };
 // static
 GenericResourceThrottle* GenericResourceThrottle::active_throttle_ = NULL;
 
@@ skipping 1811 matching lines @@
   SetResponse(raw_headers, response_data);
   job_factory_->SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
   // Return some data so that the request is identified as a download
   // and the proper resource handlers are created.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
+  base::RunLoop().RunUntilIdle();
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
   host_.OnMessageReceived(msg, filter_.get());
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(ResourceDispatcherHostTest, CancelRequestsForContext) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP\n"
                           "Content-disposition: attachment; filename=foo\n\n");
@@ skipping 40 matching lines @@
     EXPECT_EQ(0, host_.pending_requests());
 
     base::RunLoop().RunUntilIdle();
   } else {
     MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                     download_url, RESOURCE_TYPE_MAIN_FRAME);
 
     // Return some data so that the request is identified as a download
     // and the proper resource handlers are created.
     EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
+    base::RunLoop().RunUntilIdle();
 
     // And now simulate a cancellation coming from the renderer.
     ResourceHostMsg_CancelRequest msg(request_id);
     host_.OnMessageReceived(msg, filter_.get());
 
     // Since the request had already started processing as a download,
     // the cancellation above should have been ignored and the request
     // should still be alive.
     EXPECT_EQ(1, host_.pending_requests());
 
     // Cancelling by other methods shouldn't work either.
     host_.CancelRequestsForProcess(render_view_id);
     EXPECT_EQ(1, host_.pending_requests());
 
     // Cancelling by context should work.
     host_.CancelRequestsForContext(filter_->resource_context());
     EXPECT_EQ(0, host_.pending_requests());
+
+    while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
+    }
+    base::RunLoop().RunUntilIdle();
   }
 }
 
 TEST_P(ResourceDispatcherHostTest, CancelRequestsForContextDetached) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
@@ skipping 351 matching lines @@
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
   host_.OnMessageReceived(redirect_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::RunLoop().RunUntilIdle();
 
   // Restore, now that we've set up a transfer.
   SetBrowserClientForTesting(old_client);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
@@ skipping 148 matching lines @@
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg2(request_id);
   host_.OnMessageReceived(redirect_msg2, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::RunLoop().RunUntilIdle();
 
   // Restore.
   SetBrowserClientForTesting(old_client);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
@@ skipping 586 matching lines @@
 TEST_P(ResourceDispatcherHostTest, TransferRequestRedirectedDownload) {
   int initial_count(web_contents_observer_->resource_request_redirect_count());
 
   MakeWebContentsAssociatedDownloadRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_count,
             web_contents_observer_->resource_request_redirect_count());
 }
 
+// Tests that a ResourceThrottle that needs to process the response before any
+// part of the body is read can do so.
+TEST_P(ResourceDispatcherHostTest, ThrottleMustProcessResponseBeforeRead) {
+  // Ensure all jobs will check that no read operation is called.
+  job_factory_->SetMustNotReadJobGeneration(true);
+  HandleScheme("http");
+
+  // Create a ResourceThrottle that must process the response before any part of
+  // the body is read. This throttle will also cancel the request in
+  // WillProcessResponse.
+  TestResourceDispatcherHostDelegate delegate;
+  int throttle_flags = CANCEL_PROCESSING_RESPONSE | MUST_NOT_CACHE_BODY;
+  delegate.set_flags(throttle_flags);
+  host_.SetDelegate(&delegate);
+
+  // This response should normally result in the MIME type being sniffed, which
+  // requires reading the body.
+  std::string raw_headers(
+      "HTTP/1.1 200 OK\n"
+      "Content-Type: text/plain; charset=utf-8\n\n");
+  std::string response_data("p { text-align: center; }");
+  SetResponse(raw_headers, response_data);
+
+  MakeTestRequestWithResourceType(filter_.get(), filter_->child_id(), 1,
+                                  GURL("http://example.com/blah"),
+                                  RESOURCE_TYPE_STYLESHEET);
+
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
+  }
+  base::RunLoop().RunUntilIdle();
+}
+
 // A URLRequestTestJob that sets a test certificate on the |ssl_info|
 // field of the response.
 class TestHTTPSURLRequestJob : public net::URLRequestTestJob {
  public:
   TestHTTPSURLRequestJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
                          const std::string& response_headers,
                          const std::string& response_data,
                          bool auto_advance)
       : net::URLRequestTestJob(request,
@@ skipping 43 matching lines @@
     if (delay_start_) {
       return new URLRequestTestDelayedStartJob(
           request, network_delegate,
           test_fixture_->response_headers_, test_fixture_->response_data_,
           false);
     } else if (delay_complete_) {
       return new URLRequestTestDelayedCompletionJob(
           request, network_delegate,
           test_fixture_->response_headers_, test_fixture_->response_data_,
           false);
+    } else if (must_not_read_) {
+      return new URLRequestMustNotReadTestJob(request, network_delegate,
+                                              test_fixture_->response_headers_,
+                                              test_fixture_->response_data_);
     } else if (test_fixture_->use_test_ssl_certificate_) {
       return new TestHTTPSURLRequestJob(request, network_delegate,
                                         test_fixture_->response_headers_,
                                         test_fixture_->response_data_, false);
     } else {
       return new net::URLRequestTestJob(
           request, network_delegate, test_fixture_->response_headers_,
           test_fixture_->response_data_, test_fixture_->auto_advance_);
     }
   }
@@ skipping 12 matching lines @@
   return nullptr;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceDispatcherHostTests,
     ResourceDispatcherHostTest,
     testing::Values(TestConfig::kDefault,
                     TestConfig::kOptimizeIPCForSmallResourceEnabled));
 
 }  // namespace content