Allows prefetch requests to live beyond the renderer by delaying

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 <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/browser/loader/resource_loader.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
@@ skipping 488 matching lines @@
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public IPC::Sender {
  public:
   ResourceDispatcherHostTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         cache_thread_(BrowserThread::CACHE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         old_factory_(NULL),
-        resource_type_(ResourceType::SUB_RESOURCE),
         send_data_received_acks_(false) {
     browser_context_.reset(new TestBrowserContext());
     BrowserContext::EnsureResourceContextInitialized(browser_context_.get());
     message_loop_.RunUntilIdle();
     filter_ = new ForwardingFilter(
         this, browser_context_->GetResourceContext());
   }
 
   virtual ~ResourceDispatcherHostTest() {
     for (std::set<int>::iterator it = child_ids_.begin();
@@ skipping 50 matching lines @@
     if (ResourceDispatcherHostImpl::Get())
       ResourceDispatcherHostImpl::Get()->CancelRequestsForContext(
           browser_context_->GetResourceContext());
 
     WorkerServiceImpl::GetInstance()->PerformTeardownForTesting();
 
     browser_context_.reset();
     message_loop_.RunUntilIdle();
   }
 
-  // Creates a request using the current test object as the filter.
+  // Creates a request using the current test object as the filter and
+  // SubResource as the resource type.
   void MakeTestRequest(int render_view_id,
                        int request_id,
                        const GURL& url);
 
-  // Generates a request using the given filter. This will probably be a
-  // ForwardingFilter.
-  void MakeTestRequest(ResourceMessageFilter* filter,
-                       int render_view_id,
-                       int request_id,
-                       const GURL& url);
+  // Generates a request using the given filter and resource type.
+  void MakeTestRequestWithResourceType(ResourceMessageFilter* filter,
+                                       int render_view_id, int request_id,
+                                       const GURL& url,
+                                       ResourceType::Type type);
 
   void CancelRequest(int request_id);
 
   void CompleteStartRequest(int request_id);
   void CompleteStartRequest(ResourceMessageFilter* filter, int request_id);
 
   void EnsureSchemeIsAllowed(const std::string& scheme) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     if (!policy->IsWebSafeScheme(scheme))
       policy->RegisterWebSafeScheme(scheme);
   }
 
   void EnsureTestSchemeIsAllowed() {
     EnsureSchemeIsAllowed("test");
   }
 
   // Sets a particular response for any request from now on. To switch back to
   // the default bahavior, pass an empty |headers|. |headers| should be raw-
   // formatted (NULLs instead of EOLs).
   void SetResponse(const std::string& headers, const std::string& data) {
     response_headers_ = net::HttpUtil::AssembleRawHeaders(headers.data(),
                                                           headers.size());
     response_data_ = data;
   }
   void SetResponse(const std::string& headers) {
     SetResponse(headers, std::string());
   }
 
-  // Sets a particular resource type for any request from now on.
-  void SetResourceType(ResourceType::Type type) {
-    resource_type_ = type;
-  }
-
   void SendDataReceivedACKs(bool send_acks) {
     send_data_received_acks_ = send_acks;
   }
 
   // Intercepts requests for the given protocol.
   void HandleScheme(const std::string& scheme) {
     DCHECK(scheme_.empty());
     DCHECK(!old_factory_);
     scheme_ = scheme;
     old_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
@@ skipping 65 matching lines @@
   BrowserThreadImpl cache_thread_;
   BrowserThreadImpl io_thread_;
   scoped_ptr<TestBrowserContext> browser_context_;
   scoped_refptr<ForwardingFilter> filter_;
   ResourceDispatcherHostImpl host_;
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   std::string scheme_;
   net::URLRequest::ProtocolFactory* old_factory_;
-  ResourceType::Type resource_type_;
   bool send_data_received_acks_;
   std::set<int> child_ids_;
   static ResourceDispatcherHostTest* test_fixture_;
   static bool delay_start_;
   static bool delay_complete_;
   static int url_request_jobs_created_count_;
 };
 // Static.
 ResourceDispatcherHostTest* ResourceDispatcherHostTest::test_fixture_ = NULL;
 bool ResourceDispatcherHostTest::delay_start_ = false;
 bool ResourceDispatcherHostTest::delay_complete_ = false;
 int ResourceDispatcherHostTest::url_request_jobs_created_count_ = 0;
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
-  MakeTestRequest(filter_.get(), render_view_id, request_id, url);
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  url, ResourceType::SUB_RESOURCE);
 }
 
-void ResourceDispatcherHostTest::MakeTestRequest(
+void ResourceDispatcherHostTest::MakeTestRequestWithResourceType(
     ResourceMessageFilter* filter,
     int render_view_id,
     int request_id,
-    const GURL& url) {
+    const GURL& url,
+    ResourceType::Type type) {
   // If it's already there, this'll be dropped on the floor, which is fine.
   child_ids_.insert(filter->child_id());
 
   ResourceHostMsg_Request request =
-      CreateResourceRequest("GET", resource_type_, url);
+      CreateResourceRequest("GET", type, url);
   ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter, &msg_was_ok);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::CancelRequest(int request_id) {
   host_.CancelRequest(filter_->child_id(), request_id, false);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(int request_id) {
   CompleteStartRequest(filter_.get(), request_id);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(
     ResourceMessageFilter* filter,
     int request_id) {
   GlobalRequestID gid(filter->child_id(), request_id);
   net::URLRequest* req = host_.GetURLRequest(gid);
   EXPECT_TRUE(req);
   if (req)
     URLRequestTestDelayedStartJob::CompleteStart(req);
 }
 
+void CheckRequestCompleteErrorCode(const IPC::Message& message,
+                                   int expected_error_code) {
+  // Verify that there was no error.
+  int request_id;
+  int error_code;
+
+  ASSERT_EQ(ResourceMsg_RequestComplete::ID, message.type());
+
+  PickleIterator iter(message);
+  ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id));
+  ASSERT_TRUE(IPC::ReadParam(&message, &iter, &error_code));
+  ASSERT_EQ(error_code, expected_error_code);
+}
+
+void ExtractDataOffsetAndLength(const IPC::Message& message, int* data_offset,
+                                int* data_length) {
+  PickleIterator iter(message);
+  int request_id;
+  ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id));
+  ASSERT_TRUE(IPC::ReadParam(&message, &iter, data_offset));
+  ASSERT_TRUE(IPC::ReadParam(&message, &iter, data_length));
+}
+
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
   //     SetDataBuffer       (contains shared memory handle)
   //     DataReceived        (data offset and length into shared memory)
   //     RequestComplete     (request is done)
   //
   // This function verifies that we received 4 messages and that they
   // are appropriate.
   ASSERT_EQ(4U, messages.size());
 
   // The first messages should be received response
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   ASSERT_EQ(ResourceMsg_SetDataBuffer::ID, messages[1].type());
 
   PickleIterator iter(messages[1]);
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &request_id));
   base::SharedMemoryHandle shm_handle;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_handle));
   int shm_size;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_size));
 
   // Followed by the data, currently we only do the data in one chunk, but
   // should probably test multiple chunks later
   ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2].type());
 
-  PickleIterator iter2(messages[2]);
-  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &request_id));
   int data_offset;
-  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &data_offset));
   int data_length;
-  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &data_length));
+  ExtractDataOffsetAndLength(messages[2], &data_offset, &data_length);
 
   ASSERT_EQ(reference_data.size(), static_cast<size_t>(data_length));
   ASSERT_GE(shm_size, data_length);
 
   base::SharedMemory shared_mem(shm_handle, true);  // read only
   shared_mem.Map(data_length);
   const char* data = static_cast<char*>(shared_mem.memory()) + data_offset;
   ASSERT_EQ(0, memcmp(reference_data.c_str(), data, data_length));
 
   // The last message should be all data received.
-  ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[3].type());
+  CheckRequestCompleteErrorCode(messages[3], net::OK);
+}
+
+void CheckSuccessfulRedirect(const std::vector<IPC::Message>& messages,
+                             const std::string& reference_data) {
+  ASSERT_EQ(5U, messages.size());
+  ASSERT_EQ(ResourceMsg_ReceivedRedirect::ID, messages[0].type());
+
+  const std::vector<IPC::Message> second_req_msgs =
+      std::vector<IPC::Message>(messages.begin() + 1, messages.end());
+  CheckSuccessfulRequest(second_req_msgs, reference_data);
+}
+
+void CheckSuccessfulDetachedRequest(
+    const std::vector<IPC::Message>& messages) {
+  // A successful request will have received 2 messages:
+  //     ReceivedResponse    (indicates headers received)
+  //     RequestComplete     (request is done)
+  //
+  // This function verifies that we received 2 messages and that they
+  // are appropriate.
+  ASSERT_EQ(2U, messages.size());
+
+  // The first messages should be received response
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
+
+  // The last message should be all data received.
+  CheckRequestCompleteErrorCode(messages[1], net::OK);
 }
 
 void CheckFailedRequest(const std::vector<IPC::Message>& messages,
                         const std::string& reference_data,
                         int expected_error) {
   ASSERT_LT(0U, messages.size());
   ASSERT_GE(2U, messages.size());
   size_t failure_index = messages.size() - 1;
 
   if (messages.size() == 2) {
     EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
   }
-  EXPECT_EQ(ResourceMsg_RequestComplete::ID, messages[failure_index].type());
 
-  int request_id;
-  int error_code;
-
-  PickleIterator iter(messages[failure_index]);
-  EXPECT_TRUE(IPC::ReadParam(&messages[failure_index], &iter, &request_id));
-  EXPECT_TRUE(IPC::ReadParam(&messages[failure_index], &iter, &error_code));
-  EXPECT_EQ(expected_error, error_code);
+  CheckRequestCompleteErrorCode(messages[failure_index], expected_error);
 }
 
 // Tests whether many messages get dispatched properly.
 TEST_F(ResourceDispatcherHostTest, TestMany) {
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
+  MakeTestRequest(0, 4, net::URLRequestTestJob::test_url_4());
+  MakeTestRequest(0, 5, net::URLRequestTestJob::test_url_redirect_to_url_2());
+
+  // Finish the redirection
+  ResourceHostMsg_FollowRedirect redirect_msg(5, false, GURL());
+  bool msg_was_ok;
+  host_.OnMessageReceived(redirect_msg, filter_.get(), &msg_was_ok);
+  base::MessageLoop::current()->RunUntilIdle();
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // sorts out all the messages we saw by request
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
-  // there are three requests, so we should have gotten them classified as such
-  ASSERT_EQ(3U, msgs.size());
+  // there are five requests, so we should have gotten them classified as such
+  ASSERT_EQ(5U, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3());
+  CheckSuccessfulRequest(msgs[3], net::URLRequestTestJob::test_data_4());
+  CheckSuccessfulRedirect(msgs[4], net::URLRequestTestJob::test_data_2());
 }
 
-void CheckCancelledRequestCompleteMessage(const IPC::Message& message) {
-  ASSERT_EQ(ResourceMsg_RequestComplete::ID, message.type());
-
-  int request_id;
-  int error_code;
-
-  PickleIterator iter(message);
-  ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id));
-  ASSERT_TRUE(IPC::ReadParam(&message, &iter, &error_code));
-
-  EXPECT_EQ(net::ERR_ABORTED, error_code);
-}
-
-// Tests whether messages get canceled properly. We issue three requests,
-// cancel one of them, and make sure that each sent the proper notifications.
+// Tests whether messages get canceled properly. We issue four requests,
+// cancel two of them, and make sure that each sent the proper notifications.
 TEST_F(ResourceDispatcherHostTest, Cancel) {
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
+  MakeTestRequestWithResourceType(filter_.get(), 0, 4,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
+
   CancelRequest(2);
 
+  // Cancel request must come from the renderer for a detachable resource to
+  // delay.
+  host_.CancelRequest(filter_->child_id(), 4, true);
+
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
-  // there are three requests, so we should have gotten them classified as such
-  ASSERT_EQ(3U, msgs.size());
+  // there are four requests, so we should have gotten them classified as such
+  ASSERT_EQ(4U, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3());
+  // The detachable resource should have delayed its cancellation and completed.
+  CheckSuccessfulDetachedRequest(msgs[3]);
 
   // Check that request 2 got canceled.
   ASSERT_EQ(2U, msgs[1].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[1][0].type());
-  CheckCancelledRequestCompleteMessage(msgs[1][1]);
+  CheckRequestCompleteErrorCode(msgs[1][1], net::ERR_ABORTED);
+}
+
+// Shows that detachable requests will timeout if the request takes too long to
+// complete.
+TEST_F(ResourceDispatcherHostTest, DetachableResourceTimesOut) {
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::PREFETCH);  // detachable type
+  ResourceLoader* loader = host_.GetLoader(filter_->child_id(), 1);
+  ASSERT_TRUE(loader);
+  loader->set_detachable_delay_ms(200);
+  base::MessageLoop::current()->RunUntilIdle();
+  host_.CancelRequest(filter_->child_id(), 1, true);
+
+  EXPECT_EQ(1, host_.pending_requests());
+
+  // Wait until after the delay timer times out before we start processing any
+  // messages.
+  base::OneShotTimer<base::MessageLoop> timer;
+  timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(210),
+              base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle);
+  base::MessageLoop::current()->Run();
+
+  // We should have cancelled the prefetch by now.
+  EXPECT_EQ(0, host_.pending_requests());
+
+  // In case any messages are still to be processed.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+
+  // The request should have cancelled.
+  ASSERT_EQ(2U, msgs[0].size());
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
+  CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED);
+}
+
+// If the filter has disappeared then detachable resources should continue to
+// load.
+TEST_F(ResourceDispatcherHostTest, DeletedFilterDetachable) {
+  ResourceHostMsg_Request request = CreateResourceRequest(
+      "GET", ResourceType::PREFETCH, net::URLRequestTestJob::test_url_4());
+
+  ResourceHostMsg_RequestResource msg(0, 1, request);
+  bool msg_was_ok;
+  host_.OnMessageReceived(msg, filter_, &msg_was_ok);
+
+  // Remove the filter before processing the request by simulating channel
+  // closure.
+  GlobalRequestID global_request_id(filter_->child_id(), 1);
+  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
+      host_.GetURLRequest(global_request_id));
+  info->filter_->OnChannelClosing();
+  info->filter_.reset();
+
+  EXPECT_EQ(1, host_.pending_requests());
+
+  KickOffRequest();
+
+  // Make sure the request wasn't canceled early.
+  EXPECT_EQ(1, host_.pending_requests());
+
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(0, host_.pending_requests());
+
+  // Because the filter was gone, no messages should have been sent.
+  // TODO(jkarlin): It would be nice to verify that we successfully completed
+  // the request, but we have no messages to verify with.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(0U, msgs.size());
+}
+
+// If the filter has disappeared (original process dies) then detachable
+// resources should continue to load, even when redirected.
+TEST_F(ResourceDispatcherHostTest, DeletedFilterDetachableRedirect) {
+  ResourceHostMsg_Request request = CreateResourceRequest(
+      "GET", ResourceType::PREFETCH,
+      net::URLRequestTestJob::test_url_redirect_to_url_2());
+
+  ResourceHostMsg_RequestResource msg(0, 1, request);
+  bool msg_was_ok;
+  host_.OnMessageReceived(msg, filter_, &msg_was_ok);
+
+  // Remove the filter before processing the request by simulating channel
+  // closure.
+  GlobalRequestID global_request_id(filter_->child_id(), 1);
+  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
+      host_.GetURLRequest(global_request_id));
+  info->filter_->OnChannelClosing();
+  info->filter_.reset();
+
+  EXPECT_EQ(1, host_.pending_requests());
+  // Verify no redirects before resetting the filter.
+  net::URLRequest* url_request = host_.GetURLRequest(global_request_id);
+  EXPECT_EQ(1u, url_request->url_chain().size());
+  KickOffRequest();
+
+  // Verify that a redirect was followed.
+  EXPECT_EQ(2u, url_request->url_chain().size());
+
+  // Make sure the request wasn't canceled early.
+  EXPECT_EQ(1, host_.pending_requests());
+
+  // Finish up the request.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(0, host_.pending_requests());
+
+  // Because the filter was deleted, no messages should have been sent.
+  // TODO(jkarlin): It would be nice to verify that we successfully completed
+  // the request, but we have no messages to verify with.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(0U, msgs.size());
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) {
   bool was_deleted = false;
 
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_url_request_user_data(new TestUserData(&was_deleted));
   host_.SetDelegate(&delegate);
@@ skipping 24 matching lines @@
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check that request got canceled.
   ASSERT_EQ(1U, msgs[0].size());
-  CheckCancelledRequestCompleteMessage(msgs[0][0]);
+  CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
 
   // Make sure URLRequest is never started.
   EXPECT_EQ(0, url_request_jobs_created_count_);
 }
 
 TEST_F(ResourceDispatcherHostTest, PausedStartError) {
   // Arrange to have requests deferred before processing response headers.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_PROCESSING_RESPONSE);
   host_.SetDelegate(&delegate);
@@ skipping 59 matching lines @@
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check the cancellation
   ASSERT_EQ(1U, msgs.size());
   ASSERT_EQ(1U, msgs[0].size());
-  ASSERT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
-  int request_id;
-  int error_code;
-
-  PickleIterator iter(msgs[0][0]);
-  ASSERT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
-  ASSERT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &error_code));
-
-  EXPECT_EQ(net::ERR_ACCESS_DENIED, error_code);
+  CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ACCESS_DENIED);
 }
 
 // The host delegate acts as a second one so we can have some requests
 // pending and some canceled.
 class TestFilter : public ForwardingFilter {
  public:
   explicit TestFilter(ResourceContext* resource_context)
       : ForwardingFilter(NULL, resource_context),
         has_canceled_(false),
         received_after_canceled_(0) {
@@ skipping 17 matching lines @@
 
 // Tests CancelRequestsForProcess
 TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
   scoped_refptr<TestFilter> test_filter = new TestFilter(
       browser_context_->GetResourceContext());
 
   // request 1 goes to the test delegate
   ResourceHostMsg_Request request = CreateResourceRequest(
       "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
 
-  MakeTestRequest(test_filter.get(), 0, 1,
-                  net::URLRequestTestJob::test_url_1());
+  MakeTestRequestWithResourceType(test_filter.get(), 0, 1,
+                                  net::URLRequestTestJob::test_url_1(),
+                                  ResourceType::SUB_RESOURCE);
 
   // request 2 goes to us
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
 
   // request 3 goes to the test delegate
-  MakeTestRequest(test_filter.get(), 0, 3,
-                  net::URLRequestTestJob::test_url_3());
+  MakeTestRequestWithResourceType(test_filter.get(), 0, 3,
+                                  net::URLRequestTestJob::test_url_3(),
+                                  ResourceType::SUB_RESOURCE);
+
+  // request 4 goes to us
+  MakeTestRequestWithResourceType(filter_.get(), 0, 4,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
+
 
   // Make sure all requests have finished stage one. test_url_1 will have
   // finished.
   base::MessageLoop::current()->RunUntilIdle();
 
   // TODO(mbelshe):
   // Now that the async IO path is in place, the IO always completes on the
   // initial call; so the requests have already completed.  This basically
   // breaks the whole test.
   //EXPECT_EQ(3, host_.pending_requests());
 
-  // Process each request for one level so one callback is called.
+  // Process test_url_2 and test_url_3 for one level so one callback is called.
+  // We'll cancel test_url_4 (detachable) before processing it to verify that it
+  // delays the cancel.
   for (int i = 0; i < 2; i++)
     EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
 
   // Cancel the requests to the test process.
   host_.CancelRequestsForProcess(filter_->child_id());
   test_filter->has_canceled_ = true;
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.pending_requests());
 
   // The test delegate should not have gotten any messages after being canceled.
   ASSERT_EQ(0, test_filter->received_after_canceled_);
 
-  // We should have gotten exactly one result.
+  // We should have gotten two results.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(2U, msgs.size());
+  CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2());
+  // We cancelled the detachable request before it finished, and it should have
+  // delayed and completed regardless.
+  CheckSuccessfulDetachedRequest(msgs[1]);
+}
+
+TEST_F(ResourceDispatcherHostTest, TestProcessCancelDetachableTimesOut) {
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
+  ResourceLoader* loader = host_.GetLoader(filter_->child_id(), 1);
+  EXPECT_TRUE(loader);
+  loader->set_detachable_delay_ms(200);
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // Cancel the requests to the test process.
+  host_.CancelRequestsForProcess(filter_->child_id());
+  EXPECT_EQ(1, host_.pending_requests());
+
+  // Wait until after the delay timer times out before we start processing any
+  // messages.
+  base::OneShotTimer<base::MessageLoop> timer;
+  timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(210),
+              base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle);
+  base::MessageLoop::current()->Run();
+
+  // We should have cancelled the prefetch by now.
+  EXPECT_EQ(0, host_.pending_requests());
+
+  // In case any messages are still to be processed.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
   ASSERT_EQ(1U, msgs.size());
-  CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2());
+
+  // The request should have cancelled.
+  ASSERT_EQ(2U, msgs[0].size());
+  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
+  CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED);
 }
 
 // Tests blocking and resuming requests.
 TEST_F(ResourceDispatcherHostTest, TestBlockingResumingRequests) {
   host_.BlockRequestsForRoute(filter_->child_id(), 1);
   host_.BlockRequestsForRoute(filter_->child_id(), 2);
   host_.BlockRequestsForRoute(filter_->child_id(), 3);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(1, 2, net::URLRequestTestJob::test_url_2());
@@ skipping 48 matching lines @@
 }
 
 // Tests blocking and canceling requests.
 TEST_F(ResourceDispatcherHostTest, TestBlockingCancelingRequests) {
   host_.BlockRequestsForRoute(filter_->child_id(), 1);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(1, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequest(1, 4, net::URLRequestTestJob::test_url_1());
+  // Blocked detachable resources should not delay cancellation.
+  MakeTestRequestWithResourceType(filter_.get(), 1, 5,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sort out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // The 2 requests for the RVH 0 should have been processed.
   ASSERT_EQ(2U, msgs.size());
@@ skipping 12 matching lines @@
 }
 
 // Tests that blocked requests are canceled if their associated process dies.
 TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
       this, browser_context_->GetResourceContext());
 
   host_.BlockRequestsForRoute(second_filter->child_id(), 0);
 
-  MakeTestRequest(filter_.get(), 0, 1, net::URLRequestTestJob::test_url_1());
-  MakeTestRequest(second_filter.get(), 0, 2,
-                  net::URLRequestTestJob::test_url_2());
-  MakeTestRequest(filter_.get(), 0, 3, net::URLRequestTestJob::test_url_3());
-  MakeTestRequest(second_filter.get(), 0, 4,
-                  net::URLRequestTestJob::test_url_1());
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1,
+                                  net::URLRequestTestJob::test_url_1(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(second_filter.get(), 0, 2,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 0, 3,
+                                  net::URLRequestTestJob::test_url_3(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(second_filter.get(), 0, 4,
+                                  net::URLRequestTestJob::test_url_1(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(second_filter.get(), 0, 5,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
 
   // Simulate process death.
   host_.CancelRequestsForProcess(second_filter->child_id());
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sort out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
-  // The 2 requests for the RVH 0 should have been processed.
+  // The 2 requests for the RVH 0 should have been processed.  Note that
+  // blocked detachable requests are canceled without delay.
   ASSERT_EQ(2U, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3());
 
   EXPECT_TRUE(host_.blocked_loaders_map_.empty());
 }
 
 // Tests that blocked requests don't leak when the ResourceDispatcherHost goes
 // away.  Note that we rely on Purify for finding the leaks if any.
 // If this test turns the Purify bot red, check the ResourceDispatcherHost
 // destructor to make sure the blocked requests are deleted.
 TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
       this, browser_context_->GetResourceContext());
 
   host_.BlockRequestsForRoute(filter_->child_id(), 1);
   host_.BlockRequestsForRoute(filter_->child_id(), 2);
   host_.BlockRequestsForRoute(second_filter->child_id(), 1);
 
-  MakeTestRequest(filter_.get(), 0, 1, net::URLRequestTestJob::test_url_1());
-  MakeTestRequest(filter_.get(), 1, 2, net::URLRequestTestJob::test_url_2());
-  MakeTestRequest(filter_.get(), 0, 3, net::URLRequestTestJob::test_url_3());
-  MakeTestRequest(second_filter.get(), 1, 4,
-                  net::URLRequestTestJob::test_url_1());
-  MakeTestRequest(filter_.get(), 2, 5, net::URLRequestTestJob::test_url_2());
-  MakeTestRequest(filter_.get(), 2, 6, net::URLRequestTestJob::test_url_3());
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1,
+                                  net::URLRequestTestJob::test_url_1(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 1, 2,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 0, 3,
+                                  net::URLRequestTestJob::test_url_3(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(second_filter.get(), 1, 4,
+                                  net::URLRequestTestJob::test_url_1(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 2, 5,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 2, 6,
+                                  net::URLRequestTestJob::test_url_3(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 0, 7,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
+  MakeTestRequestWithResourceType(second_filter.get(), 1, 8,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
 
   host_.CancelRequestsForProcess(filter_->child_id());
   host_.CancelRequestsForProcess(second_filter->child_id());
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 }
 
 // Test the private helper method "CalculateApproximateMemoryCost()".
 TEST_F(ResourceDispatcherHostTest, CalculateApproximateMemoryCost) {
@@ skipping 38 matching lines @@
   // Determine how many instance of test_url_2() we can request before
   // throttling kicks in.
   size_t kMaxRequests = kMaxCostPerProcess / kMemoryCostOfTest2Req;
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
       this, browser_context_->GetResourceContext());
 
   // Saturate the number of outstanding requests for our process.
   for (size_t i = 0; i < kMaxRequests; ++i) {
-    MakeTestRequest(filter_.get(), 0, i + 1,
-                    net::URLRequestTestJob::test_url_2());
+    MakeTestRequestWithResourceType(filter_.get(), 0, i + 1,
+                                    net::URLRequestTestJob::test_url_2(),
+                                    ResourceType::SUB_RESOURCE);
   }
 
   // Issue two more requests for our process -- these should fail immediately.
-  MakeTestRequest(filter_.get(), 0, kMaxRequests + 1,
-                  net::URLRequestTestJob::test_url_2());
-  MakeTestRequest(filter_.get(), 0, kMaxRequests + 2,
-                  net::URLRequestTestJob::test_url_2());
+  MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequests + 1,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequests + 2,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
 
   // Issue two requests for the second process -- these should succeed since
   // it is just process 0 that is saturated.
-  MakeTestRequest(second_filter.get(), 0, kMaxRequests + 3,
-                  net::URLRequestTestJob::test_url_2());
-  MakeTestRequest(second_filter.get(), 0, kMaxRequests + 4,
-                  net::URLRequestTestJob::test_url_2());
+  MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 3,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
+  MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 4,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We issued (kMaxRequests + 4) total requests.
@@ skipping 30 matching lines @@
   host_.set_max_num_in_flight_requests(kMaxRequests);
 
   // Needed to emulate additional processes.
   scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
       this, browser_context_->GetResourceContext());
   scoped_refptr<ForwardingFilter> third_filter = new ForwardingFilter(
       this, browser_context_->GetResourceContext());
 
   // Saturate the number of outstanding requests for our process.
   for (size_t i = 0; i < kMaxRequestsPerProcess; ++i) {
-    MakeTestRequest(filter_.get(), 0, i + 1,
-                    net::URLRequestTestJob::test_url_2());
+    MakeTestRequestWithResourceType(filter_.get(), 0, i + 1,
+                                    net::URLRequestTestJob::test_url_2(),
+                                    ResourceType::SUB_RESOURCE);
   }
 
   // Issue another request for our process -- this should fail immediately.
-  MakeTestRequest(filter_.get(), 0, kMaxRequestsPerProcess + 1,
-                  net::URLRequestTestJob::test_url_2());
+  MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequestsPerProcess + 1,
+                                  net::URLRequestTestJob::test_url_2(),
+                                  ResourceType::SUB_RESOURCE);
 
   // Issue a request for the second process -- this should succeed, because it
   // is just process 0 that is saturated.
-  MakeTestRequest(second_filter.get(), 0, kMaxRequestsPerProcess + 2,
-                  net::URLRequestTestJob::test_url_2());
+  MakeTestRequestWithResourceType(
+      second_filter.get(), 0, kMaxRequestsPerProcess + 2,
+      net::URLRequestTestJob::test_url_2(), ResourceType::SUB_RESOURCE);
 
   // Issue a request for the third process -- this should fail, because the
   // global limit has been reached.
-  MakeTestRequest(third_filter.get(), 0, kMaxRequestsPerProcess + 3,
-                  net::URLRequestTestJob::test_url_2());
+  MakeTestRequestWithResourceType(
+      third_filter.get(), 0, kMaxRequestsPerProcess + 3,
+      net::URLRequestTestJob::test_url_2(), ResourceType::SUB_RESOURCE);
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // The processes issued the following requests:
@@ skipping 119 matching lines @@
 }
 
 // Tests for crbug.com/31266 (Non-2xx + application/octet-stream).
 TEST_F(ResourceDispatcherHostTest, ForbiddenDownload) {
   std::string raw_headers("HTTP/1.1 403 Forbidden\n"
                           "Content-disposition: attachment; filename=blah\n"
                           "Content-type: application/octet-stream\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
+  HandleScheme("http");
+
   // Only MAIN_FRAMEs can trigger a download.
-  SetResourceType(ResourceType::MAIN_FRAME);
-
-  HandleScheme("http");
-  MakeTestRequest(0, 1, GURL("http:bla"));
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1, GURL("http:bla"),
+                                  ResourceType::MAIN_FRAME);
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We should have gotten one RequestComplete message.
   ASSERT_EQ(1U, msgs[0].size());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
   // The RequestComplete message should have had the error code of
   // ERR_FILE_NOT_FOUND.
-  int request_id;
-  int error_code;
-
-  PickleIterator iter(msgs[0][0]);
-  EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
-  EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &error_code));
-
-  EXPECT_EQ(1, request_id);
-  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, error_code);
+  CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_FILE_NOT_FOUND);
 }
 
 // Test for http://crbug.com/76202 .  We don't want to destroy a
 // download request prematurely when processing a cancellation from
 // the renderer.
 TEST_F(ResourceDispatcherHostTest, IgnoreCancelForDownloads) {
   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");
   std::string response_data("01234567890123456789\x01foobar");
 
   // Get past sniffing metrics in the BufferedResourceHandler.  Note that
   // if we don't get past the sniffing metrics, the result will be that
   // the BufferedResourceHandler won't have figured out that it's a download,
   // won't have constructed a DownloadResourceHandler, and and the request
   // will be successfully canceled below, failing the test.
   response_data.resize(1025, ' ');
 
   SetResponse(raw_headers, response_data);
-  SetResourceType(ResourceType::MAIN_FRAME);
   SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  GURL("http://example.com/blah"),
+                                  ResourceType::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());
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
   // Since the request had already started processing as a download,
@@ skipping 10 matching lines @@
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP\n"
                           "Content-disposition: attachment; filename=foo\n\n");
   std::string response_data("01234567890123456789\x01foobar");
   // Get past sniffing metrics.
   response_data.resize(1025, ' ');
 
   SetResponse(raw_headers, response_data);
-  SetResourceType(ResourceType::MAIN_FRAME);
   SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  GURL("http://example.com/blah"),
+                                  ResourceType::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());
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
   // 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());
 }
 
+TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextDetachable) {
+  EXPECT_EQ(0, host_.pending_requests());
+
+  int render_view_id = 0;
+  int request_id = 1;
+
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  net::URLRequestTestJob::test_url_4(),
+                                  ResourceType::PREFETCH);  // detachable type
+
+  // Simulate a cancel coming from the renderer.
+  host_.CancelRequest(filter_->child_id(), request_id, true);
+
+  // Since the request had already started processing as detachable,
+  // the cancellation above should have been ignored and the request
+  // should still be alive.
+  EXPECT_EQ(1, host_.pending_requests());
+
+  // Cancelling by other methods should also be delayed.
+  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());
+}
+
 // Test the cancelling of requests that are being transferred to a new renderer
 // due to a redirection.
 TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextTransferred) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Content-Type: text/html; charset=utf-8\n\n");
   std::string response_data("<html>foobar</html>");
 
   SetResponse(raw_headers, response_data);
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                               GURL("http://example.com/blah"),
+                               ResourceType::MAIN_FRAME);
+
 
   GlobalRequestID global_request_id(filter_->child_id(), request_id);
   host_.MarkAsTransferredNavigation(global_request_id,
                                     GURL("http://example.com/blah"));
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
@@ skipping 16 matching lines @@
 TEST_F(ResourceDispatcherHostTest, TransferNavigationHtml) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   // Configure initial request.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blech\n\n");
 
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   // Temporarily replace ContentBrowserClient with one that will trigger the
   // transfer navigation code paths.
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                  GURL("http://example.com/blah"), ResourceType::MAIN_FRAME);
 
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/html\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id, false, GURL());
   bool msg_was_ok;
   host_.OnMessageReceived(redirect_msg, filter_.get(), &msg_was_ok);
@@ skipping 42 matching lines @@
 TEST_F(ResourceDispatcherHostTest, TransferNavigationText) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   // Configure initial request.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blech\n\n");
 
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   // Temporarily replace ContentBrowserClient with one that will trigger the
   // transfer navigation code paths.
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  GURL("http://example.com/blah"),
+                                  ResourceType::MAIN_FRAME);
 
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.  Use a text/plain
   // MIME type, which causes BufferedResourceHandler to buffer it before the
   // transfer occurs.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id, false, GURL());
@@ skipping 43 matching lines @@
 
   int render_view_id = 0;
   int request_id = 1;
   int first_child_id = -1;
 
   // Configure initial request.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blech\n\n");
   const std::string kResponseBody = "hello world";
 
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   // Temporarily replace ContentBrowserClient with one that will trigger the
   // transfer navigation code paths.
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
   // Create a first filter that can be deleted before the second one starts.
   {
     scoped_refptr<ForwardingFilter> first_filter = new ForwardingFilter(
@@ skipping 68 matching lines @@
 TEST_F(ResourceDispatcherHostTest, TransferNavigationWithTwoRedirects) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   // Configure initial request.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blech\n\n");
 
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   // Temporarily replace ContentBrowserClient with one that will trigger the
   // transfer navigation code paths.
   TransfersAllNavigationsContentBrowserClient new_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client);
 
-  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  GURL("http://example.com/blah"),
+                                  ResourceType::MAIN_FRAME);
 
   // Now that we're blocked on the redirect, simulate hitting another redirect.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blerg\n\n");
   ResourceHostMsg_FollowRedirect redirect_msg(request_id, false, GURL());
   bool msg_was_ok;
   host_.OnMessageReceived(redirect_msg, filter_.get(), &msg_was_ok);
   base::MessageLoop::current()->RunUntilIdle();
 
   // Now that we're blocked on the second redirect, update the response and
@@ skipping 52 matching lines @@
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 }
 
 TEST_F(ResourceDispatcherHostTest, UnknownURLScheme) {
   EXPECT_EQ(0, host_.pending_requests());
 
-  SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
-  MakeTestRequest(0, 1, GURL("foo://bar"));
+  MakeTestRequestWithResourceType(filter_.get(), 0, 1, GURL("foo://bar"),
+                                  ResourceType::MAIN_FRAME);
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We should have gotten one RequestComplete message.
   ASSERT_EQ(1U, msgs[0].size());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
   // The RequestComplete message should have the error code of
   // ERR_UNKNOWN_URL_SCHEME.
-  int request_id;
-  int error_code;
-
-  PickleIterator iter(msgs[0][0]);
-  EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
-  EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &error_code));
-
-  EXPECT_EQ(1, request_id);
-  EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, error_code);
+  CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_UNKNOWN_URL_SCHEME);
 }
 
 TEST_F(ResourceDispatcherHostTest, DataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   SendDataReceivedACKs(true);
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   size_t size = msgs[0].size();
 
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < size - 1; ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][size - 1].type());
 }
 
+// Request a very large detachable resource and cancel part way. Some of the
+// data should have been sent to the renderer, but not all.
+TEST_F(ResourceDispatcherHostTest, DataSentBeforeDetach) {
+  EXPECT_EQ(0, host_.pending_requests());
+
+  int render_view_id = 0;
+  int request_id = 1;
+
+  std::string raw_headers("HTTP\n"
+                          "Content-type: image/jpeg\n\n");
+  std::string response_data("01234567890123456789\x01foobar");
+
+  // Create a response larger than kMaxAllocationSize (currently 32K). Note
+  // that if this increase beyond 512K we'll need to make the response longer.
+  const int kAllocSize = 1024*512;
+  response_data.resize(kAllocSize, ' ');
+
+  SetResponse(raw_headers, response_data);
+  SetDelayedCompleteJobGeneration(true);
+  HandleScheme("http");
+
+  MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
+                                  GURL("http://example.com/blah"),
+                                  ResourceType::PREFETCH);
+
+  // Get a bit of data before cancelling.
+  EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
+
+  // Simulate a cancellation coming from the renderer.
+  ResourceHostMsg_CancelRequest msg(request_id);
+  bool msg_was_ok;
+  host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
+
+  EXPECT_EQ(1, host_.pending_requests());
+
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+
+  // Sort all the messages we saw by request.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  EXPECT_EQ(4U, msgs[0].size());
+
+  // Figure out how many bytes were received by the renderer.
+  int data_offset;
+  int data_length;
+  ExtractDataOffsetAndLength(msgs[0][2], &data_offset, &data_length);
+  EXPECT_LT(0, data_length);
+  EXPECT_GT(kAllocSize, data_length);
+
+  // Verify the data that was received before cancellation. Also verify that the
+  // response completed.
+  CheckSuccessfulRequest(
+      msgs[0],
+      std::string(response_data.begin(), response_data.begin() + data_length));
+}
+
 TEST_F(ResourceDispatcherHostTest, DelayedDataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
@@ skipping 81 matching lines @@
     }
 
     base::MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content