Make ByteStream independent from DownloadInterruptReason

content/browser/download/download_browsertest.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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/download_test_observer.h"
 #include "content/public/test/test_file_error_injector.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/shell.h"
 #include "content/shell/shell_browser_context.h"
 #include "content/shell/shell_download_manager_delegate.h"
 #include "content/test/content_browser_test.h"
@@ skipping 65 matching lines @@
 }
 
 class DownloadFileWithDelay : public DownloadFileImpl {
  public:
   DownloadFileWithDelay(
       scoped_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       const GURL& url,
       const GURL& referrer_url,
       bool calculate_hash,
-      scoped_ptr<ByteStreamReader> stream,
+      scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
       const net::BoundNetLog& bound_net_log,
       scoped_ptr<PowerSaveBlocker> power_save_blocker,
       base::WeakPtr<DownloadDestinationObserver> observer,
       base::WeakPtr<DownloadFileWithDelayFactory> owner);
 
   virtual ~DownloadFileWithDelay();
 
   // Wraps DownloadFileImpl::Rename* and intercepts the return callback,
   // storing it in the factory that produced this object for later
   // retrieval.
@@ skipping 27 matching lines @@
   DownloadFileWithDelayFactory();
   virtual ~DownloadFileWithDelayFactory();
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
       scoped_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       const GURL& url,
       const GURL& referrer_url,
       bool calculate_hash,
-      scoped_ptr<ByteStreamReader> stream,
+      scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
       const net::BoundNetLog& bound_net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE;
 
   void AddRenameCallback(base::Closure callback);
   void GetAllRenameCallbacks(std::vector<base::Closure>* results);
 
   // Do not return until GetAllRenameCallbacks() will return a non-empty list.
   void WaitForSomeCallback();
 
  private:
   base::WeakPtrFactory<DownloadFileWithDelayFactory> weak_ptr_factory_;
   std::vector<base::Closure> rename_callbacks_;
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileWithDelayFactory);
 };
 
 DownloadFileWithDelay::DownloadFileWithDelay(
     scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
-    scoped_ptr<ByteStreamReader> stream,
+    scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
     const net::BoundNetLog& bound_net_log,
     scoped_ptr<PowerSaveBlocker> power_save_blocker,
     base::WeakPtr<DownloadDestinationObserver> observer,
     base::WeakPtr<DownloadFileWithDelayFactory> owner)
     : DownloadFileImpl(
         save_info.Pass(), default_download_directory, url, referrer_url,
         calculate_hash, stream.Pass(), bound_net_log,
         power_save_blocker.Pass(), observer),
       owner_(owner) {}
 
@@ skipping 32 matching lines @@
     : weak_ptr_factory_(this),
       waiting_(false) {}
 DownloadFileWithDelayFactory::~DownloadFileWithDelayFactory() {}
 
 DownloadFile* DownloadFileWithDelayFactory::CreateFile(
     scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
-    scoped_ptr<ByteStreamReader> stream,
+    scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   scoped_ptr<PowerSaveBlocker> psb(
       PowerSaveBlocker::Create(
           PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
           "Download in progress"));
   return new DownloadFileWithDelay(
       save_info.Pass(), default_download_directory, url, referrer_url,
       calculate_hash, stream.Pass(), bound_net_log,
       psb.Pass(), observer, weak_ptr_factory_.GetWeakPtr());
@@ skipping 23 matching lines @@
 }
 
 class CountingDownloadFile : public DownloadFileImpl {
  public:
   CountingDownloadFile(
     scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_downloads_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
-    scoped_ptr<ByteStreamReader> stream,
+    scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
     const net::BoundNetLog& bound_net_log,
     scoped_ptr<PowerSaveBlocker> power_save_blocker,
     base::WeakPtr<DownloadDestinationObserver> observer)
       : DownloadFileImpl(save_info.Pass(), default_downloads_directory,
                          url, referrer_url, calculate_hash,
                          stream.Pass(), bound_net_log,
                          power_save_blocker.Pass(), observer) {}
 
   virtual ~CountingDownloadFile() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 36 matching lines @@
   CountingDownloadFileFactory() {}
   virtual ~CountingDownloadFileFactory() {}
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
     scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_downloads_directory,
     const GURL& url,
     const GURL& referrer_url,
     bool calculate_hash,
-    scoped_ptr<ByteStreamReader> stream,
+    scoped_ptr<ByteStreamReader<DownloadInterruptReason> > stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE {
     scoped_ptr<PowerSaveBlocker> psb(
         PowerSaveBlocker::Create(
             PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             "Download in progress"));
     return new CountingDownloadFile(
         save_info.Pass(), default_downloads_directory, url, referrer_url,
         calculate_hash, stream.Pass(), bound_net_log,
         psb.Pass(), observer);
@@ skipping 163 matching lines @@
 class DownloadContentTest : public ContentBrowserTest {
  protected:
   // An initial send from a website of at least this size will not be
   // help up by buffering in the underlying downloads ByteStream data
   // transfer.  This is important because on resumption tests we wait
   // until we've gotten the data we expect before allowing the test server
   // to send its reset, to get around hard close semantics on the Windows
   // socket layer implementation.
   int GetSafeBufferChunk() const {
     return (DownloadResourceHandler::kDownloadByteStreamSize /
-       ByteStreamWriter::kFractionBufferBeforeSending) + 1;
+            ByteStreamWriter<DownloadInterruptReason>::
+            kFractionBufferBeforeSending) + 1;
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 
     TestShellDownloadManagerDelegate* delegate =
         new TestShellDownloadManagerDelegate();
     delegate->SetDownloadBehaviorForTesting(downloads_directory_.path());
     DownloadManager* manager = DownloadManagerForShell(shell());
     manager->SetDelegate(delegate);
@@ skipping 1064 matching lines @@
   // Start the second download and wait until it's done. The test server is
   // single threaded. The response to this download request should follow the
   // response to the previous resumption request.
   GURL url2(test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
   DownloadAndWait(shell(), url2, DownloadItem::COMPLETE);
 
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 }  // namespace content