Use ByteStream in downloads system to decouple source and sink.

content/browser/renderer_host/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 "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 247 matching lines @@
     list_head_ = this;
   }
 
   static URLRequestTestDelayedStartJob* list_head_;
   URLRequestTestDelayedStartJob* next_;
 };
 
 URLRequestTestDelayedStartJob*
 URLRequestTestDelayedStartJob::list_head_ = NULL;
 
+// This class is a variation on URLRequestTestJob in that it
+// returns IO_pending errors before every read, not just the first one.
+class URLRequestTestDelayedCompletionJob : public net::URLRequestTestJob {
+ public:
+  explicit URLRequestTestDelayedCompletionJob(net::URLRequest* request)
+      : net::URLRequestTestJob(request) {}
+  URLRequestTestDelayedCompletionJob(net::URLRequest* request,
+                                     bool auto_advance)
+      : net::URLRequestTestJob(request, auto_advance) {}
+  URLRequestTestDelayedCompletionJob(net::URLRequest* request,
+                                   const std::string& response_headers,

[rvargas (doing something else), 2012/05/30 00:49:03]

nit: indent two more spaces

[Randy Smith (Not in Mondays), 2012/05/30 19:36:43]

Done.

+                                   const std::string& response_data,
+                                   bool auto_advance)
+      : net::URLRequestTestJob(request, response_headers,
+                               response_data, auto_advance) {}
+
+ private:
+  virtual bool NextReadAsync() OVERRIDE { return true; }
+};
+
+
+
 // Associated with an URLRequest to determine if the URLRequest gets deleted.
 class TestUserData : public base::SupportsUserData::Data {
  public:
   explicit TestUserData(bool* was_deleted)
       : was_deleted_(was_deleted) {
   }
 
   ~TestUserData() {
     *was_deleted_ = true;
   }
@@ skipping 93 matching lines @@
   // testing::Test
   virtual void SetUp() {
     DCHECK(!test_fixture_);
     test_fixture_ = this;
     ChildProcessSecurityPolicyImpl::GetInstance()->Add(0);
     net::URLRequest::Deprecated::RegisterProtocolFactory(
         "test",
         &ResourceDispatcherHostTest::Factory);
     EnsureTestSchemeIsAllowed();
     delay_start_ = false;
+    delay_complete_ = false;
   }
 
   virtual void TearDown() {
     net::URLRequest::Deprecated::RegisterProtocolFactory("test", NULL);
     if (!scheme_.empty())
       net::URLRequest::Deprecated::RegisterProtocolFactory(
           scheme_, old_factory_);
 
     EXPECT_TRUE(URLRequestTestDelayedStartJob::DelayedStartQueueEmpty());
     URLRequestTestDelayedStartJob::ClearQueue();
@@ skipping 57 matching lines @@
     old_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
         scheme_, &ResourceDispatcherHostTest::Factory);
   }
 
   // Our own net::URLRequestJob factory.
   static net::URLRequestJob* Factory(net::URLRequest* request,
                                      const std::string& scheme) {
     if (test_fixture_->response_headers_.empty()) {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(request);
+      } else if (delay_complete_) {
+        return new URLRequestTestDelayedCompletionJob(request);
       } else {
         return new net::URLRequestTestJob(request);
       }
     } else {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(
             request, test_fixture_->response_headers_,
             test_fixture_->response_data_, false);
+      } else if (delay_complete_) {
+        return new URLRequestTestDelayedCompletionJob(
+            request, test_fixture_->response_headers_,
+            test_fixture_->response_data_, false);
       } else {
         return new net::URLRequestTestJob(request,
                                           test_fixture_->response_headers_,
                                           test_fixture_->response_data_,
                                           false);
       }
     }
   }
 
   void SetDelayedStartJobGeneration(bool delay_job_start) {
     delay_start_ = delay_job_start;
   }
 
+  void SetDelayedCompleteJobGeneration(bool delay_job_complete) {
+    delay_complete_ = delay_job_complete;
+  }
+
   MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
   BrowserThreadImpl file_thread_;
   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_;
   static ResourceDispatcherHostTest* test_fixture_;
   static bool delay_start_;
+  static bool delay_complete_;
 };
 // Static.
 ResourceDispatcherHostTest* ResourceDispatcherHostTest::test_fixture_ = NULL;
 bool ResourceDispatcherHostTest::delay_start_ = false;
+bool ResourceDispatcherHostTest::delay_complete_ = false;
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
   MakeTestRequest(filter_.get(), render_view_id, request_id, url);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequest(
     ResourceMessageFilter* filter,
     int render_view_id,
@@ skipping 729 matching lines @@
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string response("HTTP\n"
                        "Content-disposition: attachment; filename=foo\n\n");
   std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
                                                             response.size()));
   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"));
   // 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(filter_->child_id(), request_id);
   bool msg_was_ok;
@@ skipping 12 matching lines @@
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string response("HTTP\n"
                        "Content-disposition: attachment; filename=foo\n\n");
   std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
                                                             response.size()));
   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"));
   // 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(filter_->child_id(), request_id);
   bool msg_was_ok;
@@ skipping 82 matching lines @@
   PickleIterator iter(msgs[0][0]);
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(net::URLRequestStatus::FAILED, status.status());
   EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, status.error());
 }
 
 }  // namespace content