Make ByteStream independent from DownloadInterruptReason

content/browser/download/download_file_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 "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_file_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/byte_stream.h"
@@ skipping 15 matching lines @@
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::StrictMock;
 
 namespace content {
 namespace {
 
-class MockByteStreamReader : public ByteStreamReader {
+class MockByteStreamReader : public ByteStreamReader<DownloadInterruptReason> {
  public:
   MockByteStreamReader() {}
   ~MockByteStreamReader() {}
 
   // ByteStream functions
-  MOCK_METHOD2(Read, ByteStreamReader::StreamState(
+  MOCK_METHOD2(Read, ByteStreamReader<DownloadInterruptReason>::StreamState(
       scoped_refptr<net::IOBuffer>*, size_t*));
   MOCK_CONST_METHOD0(GetStatus, DownloadInterruptReason());
   MOCK_METHOD1(RegisterCallback, void(const base::Closure&));
 };
 
 class MockDownloadDestinationObserver : public DownloadDestinationObserver {
  public:
   MOCK_METHOD3(DestinationUpdate, void(int64, int64, const std::string&));
   MOCK_METHOD1(DestinationError, void(DownloadInterruptReason));
   MOCK_METHOD1(DestinationCompleted, void(const std::string&));
@@ skipping 69 matching lines @@
     input_stream_ = new StrictMock<MockByteStreamReader>();
 
     // TODO: Need to actually create a function that'll set the variables
     // based on the inputs from the callback.
     EXPECT_CALL(*input_stream_, RegisterCallback(_))
         .WillOnce(Invoke(this, &DownloadFileTest::RegisterCallback))
         .RetiresOnSaturation();
 
     scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
     download_file_.reset(
-        new DownloadFileImpl(save_info.Pass(),
-                             base::FilePath(),
-                             GURL(),  // Source
-                             GURL(),  // Referrer
-                             calculate_hash,
-                             scoped_ptr<ByteStreamReader>(input_stream_),
-                             net::BoundNetLog(),
-                             scoped_ptr<PowerSaveBlocker>().Pass(),
-                             observer_factory_.GetWeakPtr()));
+        new DownloadFileImpl(
+            save_info.Pass(),
+            base::FilePath(),
+            GURL(),  // Source
+            GURL(),  // Referrer
+            calculate_hash,
+            scoped_ptr<ByteStreamReader<DownloadInterruptReason> >(
+                input_stream_),
+            net::BoundNetLog(),
+            scoped_ptr<PowerSaveBlocker>().Pass(),
+            observer_factory_.GetWeakPtr()));
 
     EXPECT_CALL(*input_stream_, Read(_, _))
-        .WillOnce(Return(ByteStreamReader::STREAM_EMPTY))
+        .WillOnce(Return(
+            ByteStreamReader<DownloadInterruptReason>::STREAM_EMPTY))
         .RetiresOnSaturation();
 
     base::WeakPtrFactory<DownloadFileTest> weak_ptr_factory(this);
     bool called = false;
     DownloadInterruptReason result;
     download_file_->Initialize(base::Bind(
         &DownloadFileTest::SetInterruptReasonCallback,
         weak_ptr_factory.GetWeakPtr(), &called, &result));
     loop_.RunUntilIdle();
     EXPECT_TRUE(called);
@@ skipping 23 matching lines @@
     DCHECK(input_stream_);
     for (size_t i = 0; i < num_chunks; i++) {
       const char *source_data = data_chunks[i];
       size_t length = strlen(source_data);
       scoped_refptr<net::IOBuffer> data = new net::IOBuffer(length);
       memcpy(data->data(), source_data, length);
       EXPECT_CALL(*input_stream_, Read(_, _))
           .InSequence(s)
           .WillOnce(DoAll(SetArgPointee<0>(data),
                           SetArgPointee<1>(length),
-                          Return(ByteStreamReader::STREAM_HAS_DATA)))
+                          Return(
+                              ByteStreamReader<DownloadInterruptReason>::
+                              STREAM_HAS_DATA)))
           .RetiresOnSaturation();
       expected_data_ += source_data;
     }
   }
 
   void VerifyStreamAndSize() {
     ::testing::Mock::VerifyAndClearExpectations(input_stream_);
     int64 size;
     EXPECT_TRUE(file_util::GetFileSize(download_file_->FullPath(), &size));
     EXPECT_EQ(expected_data_.size(), static_cast<size_t>(size));
   }
 
   // TODO(rdsmith): Manage full percentage issues properly.
   void AppendDataToFile(const char **data_chunks, size_t num_chunks) {
     ::testing::Sequence s1;
     SetupDataAppend(data_chunks, num_chunks, s1);
     EXPECT_CALL(*input_stream_, Read(_, _))
         .InSequence(s1)
-        .WillOnce(Return(ByteStreamReader::STREAM_EMPTY))
+        .WillOnce(Return(
+            ByteStreamReader<DownloadInterruptReason>::STREAM_EMPTY))
         .RetiresOnSaturation();
     sink_callback_.Run();
     VerifyStreamAndSize();
   }
 
   void SetupFinishStream(DownloadInterruptReason interrupt_reason,
                        ::testing::Sequence s) {
     EXPECT_CALL(*input_stream_, Read(_, _))
         .InSequence(s)
-        .WillOnce(Return(ByteStreamReader::STREAM_COMPLETE))
+        .WillOnce(Return(
+            ByteStreamReader<DownloadInterruptReason>::STREAM_COMPLETE))
         .RetiresOnSaturation();
     EXPECT_CALL(*input_stream_, GetStatus())
         .InSequence(s)
         .WillOnce(Return(interrupt_reason))
         .RetiresOnSaturation();
     EXPECT_CALL(*input_stream_, RegisterCallback(_))
         .RetiresOnSaturation();
   }
 
   void FinishStream(DownloadInterruptReason interrupt_reason,
@@ skipping 367 matching lines @@
 
   EXPECT_EQ(static_cast<int64>(strlen(kTestData1) + strlen(kTestData2)),
             bytes_);
   EXPECT_EQ(download_file_->GetHashState(), hash_state_);
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   DestroyDownloadFile(0);
 }
 
 }  // namespace content