Make ByteStream independent from DownloadInterruptReason

content/browser/download/download_file_impl.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/download/download_file_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_stats.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_destination_observer.h"
+#include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "net/base/io_buffer.h"
 
 namespace content {
 
 const int kUpdatePeriodMs = 500;
 const int kMaxTimeBlockingFileThreadMs = 1000;
 
 int DownloadFile::number_active_objects_ = 0;
 
 DownloadFileImpl::DownloadFileImpl(
     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)
         : file_(save_info->file_path,
                 url,
                 referrer_url,
                 save_info->offset,
                 calculate_hash,
                 save_info->hash_state,
                 save_info->file_stream.Pass(),
@@ skipping 152 matching lines @@
   return file_.GetHashState();
 }
 
 void DownloadFileImpl::StreamActive() {
   base::TimeTicks start(base::TimeTicks::Now());
   base::TimeTicks now;
   scoped_refptr<net::IOBuffer> incoming_data;
   size_t incoming_data_size = 0;
   size_t total_incoming_data_size = 0;
   size_t num_buffers = 0;
-  ByteStreamReader::StreamState state(ByteStreamReader::STREAM_EMPTY);
+  ByteStreamReader<DownloadInterruptReason>::StreamState state(
+      ByteStreamReader<DownloadInterruptReason>::STREAM_EMPTY);
   DownloadInterruptReason reason = DOWNLOAD_INTERRUPT_REASON_NONE;
   base::TimeDelta delta(
       base::TimeDelta::FromMilliseconds(kMaxTimeBlockingFileThreadMs));
 
   // Take care of any file local activity required.
   do {
     state = stream_reader_->Read(&incoming_data, &incoming_data_size);
 
     switch (state) {
-      case ByteStreamReader::STREAM_EMPTY:
+      case ByteStreamReader<DownloadInterruptReason>::STREAM_EMPTY:
         break;
-      case ByteStreamReader::STREAM_HAS_DATA:
+      case ByteStreamReader<DownloadInterruptReason>::STREAM_HAS_DATA:
         {
           ++num_buffers;
           base::TimeTicks write_start(base::TimeTicks::Now());
           reason = AppendDataToFile(
               incoming_data.get()->data(), incoming_data_size);
           disk_writes_time_ += (base::TimeTicks::Now() - write_start);
           bytes_seen_ += incoming_data_size;
           total_incoming_data_size += incoming_data_size;
         }
         break;
-      case ByteStreamReader::STREAM_COMPLETE:
+      case ByteStreamReader<DownloadInterruptReason>::STREAM_COMPLETE:
         {
-          reason = stream_reader_->GetStatus();
+          reason = static_cast<DownloadInterruptReason>(
+              stream_reader_->GetStatus());
           SendUpdate();
           base::TimeTicks close_start(base::TimeTicks::Now());
           file_.Finish();
           base::TimeTicks now(base::TimeTicks::Now());
           disk_writes_time_ += (now - close_start);
           RecordFileBandwidth(
               bytes_seen_, disk_writes_time_, now - download_start_);
           update_timer_.reset();
         }
         break;
       default:
         NOTREACHED();
         break;
     }
     now = base::TimeTicks::Now();
-  } while (state == ByteStreamReader::STREAM_HAS_DATA &&
+  } while (state ==
+           ByteStreamReader<DownloadInterruptReason>::STREAM_HAS_DATA &&
            reason == DOWNLOAD_INTERRUPT_REASON_NONE &&
            now - start <= delta);
 
   // If we're stopping to yield the thread, post a task so we come back.
-  if (state == ByteStreamReader::STREAM_HAS_DATA &&
+  if (state == ByteStreamReader<DownloadInterruptReason>::STREAM_HAS_DATA &&
       now - start > delta) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&DownloadFileImpl::StreamActive,
                    weak_factory_.GetWeakPtr()));
   }
 
   if (total_incoming_data_size)
     RecordFileThreadReceiveBuffers(num_buffers);
 
   RecordContiguousWriteTime(now - start);
 
   // Take care of communication with our observer.
   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
     // Error case for both upstream source and file write.
     // Shut down processing and signal an error to our observer.
     // Our observer will clean us up.
     stream_reader_->RegisterCallback(base::Closure());
     weak_factory_.InvalidateWeakPtrs();
     SendUpdate();                       // Make info up to date before error.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadDestinationObserver::DestinationError,
                    observer_, reason));
-  } else if (state == ByteStreamReader::STREAM_COMPLETE) {
+  } else if (state ==
+             ByteStreamReader<DownloadInterruptReason>::STREAM_COMPLETE) {
     // Signal successful completion and shut down processing.
     stream_reader_->RegisterCallback(base::Closure());
     weak_factory_.InvalidateWeakPtrs();
     std::string hash;
     if (!GetHash(&hash) || file_.IsEmptyHash(hash))
       hash.clear();
     SendUpdate();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
@@ skipping 15 matching lines @@
                  observer_, file_.bytes_so_far(), CurrentSpeed(),
                  GetHashState()));
 }
 
 // static
 int DownloadFile::GetNumberOfDownloadFiles() {
   return number_active_objects_;
 }
 
 }  // namespace content