AbstractSingleDiskAdaptor: Use std::unique_ptr for diskWriter_

src/AbstractSingleDiskAdaptor.cc

@@ -188,9 +188,9 @@ void AbstractSingleDiskAdaptor::cutTrailingGarbage()
 }
 
 void AbstractSingleDiskAdaptor::setDiskWriter
-(const std::shared_ptr<DiskWriter>& diskWriter)
+(std::unique_ptr<DiskWriter> diskWriter)
 {
-  diskWriter_ = diskWriter;
+  diskWriter_ = std::move(diskWriter);
 }
 
 void AbstractSingleDiskAdaptor::setTotalLength(int64_t totalLength)

src/AbstractSingleDiskAdaptor.h

@@ -44,7 +44,7 @@ class FileAllocationIterator;
 
 class AbstractSingleDiskAdaptor : public DiskAdaptor {
 private:
-  std::shared_ptr<DiskWriter> diskWriter_;
+  std::unique_ptr<DiskWriter> diskWriter_;
   int64_t totalLength_;
   bool readOnly_;
 public:
@@ -89,9 +89,9 @@ public:
 
   virtual const std::string& getFilePath() = 0;
 
-  void setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter);
+  void setDiskWriter(std::unique_ptr<DiskWriter> diskWriter);
 
-  const std::shared_ptr<DiskWriter>& getDiskWriter() const
+  const std::unique_ptr<DiskWriter>& getDiskWriter() const
   {
     return diskWriter_;
   }

src/BtPostDownloadHandler.cc

@@ -73,11 +73,10 @@ void BtPostDownloadHandler::getNextRequestGroups
                   requestGroup->getFirstFilePath().c_str()));
   std::shared_ptr<ValueBase> torrent;
   if(requestGroup->inMemoryDownload()) {
-    const std::shared_ptr<DiskWriter>& dw =
-      std::static_pointer_cast<AbstractSingleDiskAdaptor>
-      (requestGroup->getPieceStorage()->getDiskAdaptor())->getDiskWriter();
-    const std::shared_ptr<bittorrent::BencodeDiskWriter>& bdw =
-      std::static_pointer_cast<bittorrent::BencodeDiskWriter>(dw);
+    auto& dw = static_cast<AbstractSingleDiskAdaptor*>
+      (requestGroup->getPieceStorage()->getDiskAdaptor().get())
+      ->getDiskWriter();
+    auto bdw = static_cast<bittorrent::BencodeDiskWriter*>(dw.get());
     int error = bdw->finalize();
     if(error == 0) {
       torrent = bdw->getResult();

test/BtDependencyTest.cc

@@ -181,14 +181,16 @@ void BtDependencyTest::testResolve_metadata()
   std::shared_ptr<RequestGroup> dependee =
     createDependee(option_, "metadata", 0);
 
-  std::shared_ptr<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor());
-  std::shared_ptr<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter());
-  diskAdaptor->setDiskWriter(diskWriter);
-  diskWriter->setString
-    ("d4:name19:aria2-0.8.2.tar.bz26:lengthi384e12:piece lengthi128e"
-     "6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCC"
-     "e");
-  std::shared_ptr<MockPieceStorage> pieceStorage(new MockPieceStorage());
+  auto diskAdaptor = std::make_shared<DirectDiskAdaptor>();
+  {
+    auto diskWriter = make_unique<ByteArrayDiskWriter>();
+    diskWriter->setString
+      ("d4:name19:aria2-0.8.2.tar.bz26:lengthi384e12:piece lengthi128e"
+       "6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCC"
+       "e");
+    diskAdaptor->setDiskWriter(std::move(diskWriter));
+  }
+  auto pieceStorage = std::make_shared<MockPieceStorage>();
   pieceStorage->setDiskAdaptor(diskAdaptor);
   pieceStorage->setDownloadFinished(true);
   dependee->setPieceStorage(pieceStorage);
@@ -206,9 +208,8 @@ void BtDependencyTest::testResolve_metadata()
 
 void BtDependencyTest::testResolve_loadError()
 {
-  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
-  std::shared_ptr<RequestGroup> dependee =
-    createDependee(option_, "notExist", 40);
+  auto dependant = createDependant(option_);
+  auto dependee = createDependee(option_, "notExist", 40);
   dependee->getPieceStorage()->markAllPiecesDone();
 
   BtDependency dep(dependant.get(), dependee);
@@ -222,8 +223,8 @@ void BtDependencyTest::testResolve_loadError()
 
 void BtDependencyTest::testResolve_dependeeFailure()
 {
-  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
-  std::shared_ptr<RequestGroup> dependee = createDependee(option_, "notExist", 40);
+  auto dependant = createDependant(option_);
+  auto dependee = createDependee(option_, "notExist", 40);
 
   BtDependency dep(dependant.get(), dependee);
   CPPUNIT_ASSERT(dep.resolve());
@@ -237,9 +238,8 @@ void BtDependencyTest::testResolve_dependeeFailure()
 void BtDependencyTest::testResolve_dependeeInProgress()
 {
   std::string filename = A2_TEST_DIR"/single.torrent";
-  std::shared_ptr<RequestGroup> dependant = createDependant(option_);
-  std::shared_ptr<RequestGroup> dependee =
-    createDependee(option_, filename, File(filename).size());
+  auto dependant = createDependant(option_);
+  auto dependee = createDependee(option_, filename, File(filename).size());
   dependee->increaseNumCommand();
 
   BtDependency dep(dependant.get(), dependee);

test/DirectDiskAdaptorTest.cc

@@ -33,17 +33,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DirectDiskAdaptorTest);
 void DirectDiskAdaptorTest::testCutTrailingGarbage()
 {
   std::string dir = A2_TEST_OUT_DIR;
-  std::shared_ptr<FileEntry> entry
-    (new FileEntry(dir+"/aria2_DirectDiskAdaptorTest_testCutTrailingGarbage",
-                   256, 0));
+  auto entry = std::make_shared<FileEntry>
+    (dir+"/aria2_DirectDiskAdaptorTest_testCutTrailingGarbage",
+     256, 0);
   createFile(entry->getPath(), entry->getLength()+100);
-
-  std::vector<std::shared_ptr<FileEntry> > fileEntries;
-  fileEntries.push_back(entry);
-
+  auto fileEntries = std::vector<std::shared_ptr<FileEntry>>{entry};
   DirectDiskAdaptor adaptor;
-  adaptor.setDiskWriter
-    (std::shared_ptr<DiskWriter>(new DefaultDiskWriter(entry->getPath())));
+  adaptor.setDiskWriter(make_unique<DefaultDiskWriter>(entry->getPath()));
   adaptor.setTotalLength(entry->getLength());
   adaptor.setFileEntries(fileEntries.begin(), fileEntries.end());
   adaptor.openFile();
@@ -56,10 +52,14 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
 
 void DirectDiskAdaptorTest::testWriteCache()
 {
-  std::shared_ptr<DirectDiskAdaptor> adaptor(new DirectDiskAdaptor());
-  std::shared_ptr<ByteArrayDiskWriter> dw(new ByteArrayDiskWriter());
-  adaptor->setDiskWriter(dw);
-  WrDiskCacheEntry cache(adaptor);
+  auto adaptor = std::make_shared<DirectDiskAdaptor>();
+  ByteArrayDiskWriter* dw;
+  {
+    auto sdw = make_unique<ByteArrayDiskWriter>();
+    dw = sdw.get();
+    adaptor->setDiskWriter(std::move(sdw));
+  }
+  WrDiskCacheEntry cache{adaptor};
   std::string data1(4096, '1'), data2(4094, '2');
   cache.cacheData(createDataCell(5, data1.c_str()));
   cache.cacheData(createDataCell(5+data1.size(), data2.c_str()));

test/PieceTest.cc

@@ -28,13 +28,14 @@ class PieceTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 private:
   std::shared_ptr<DirectDiskAdaptor> adaptor_;
-  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  ByteArrayDiskWriter* writer_;
 public:
   void setUp()
   {
-    adaptor_.reset(new DirectDiskAdaptor());
-    writer_.reset(new ByteArrayDiskWriter());
-    adaptor_->setDiskWriter(writer_);
+    adaptor_ = std::make_shared<DirectDiskAdaptor>();
+    auto dw = make_unique<ByteArrayDiskWriter>();
+    writer_ = dw.get();
+    adaptor_->setDiskWriter(std::move(dw));
   }
 
   void testCompleteBlock();

test/UTMetadataDataExtensionMessageTest.cc

@@ -66,8 +66,12 @@ void UTMetadataDataExtensionMessageTest::testToString()
 void UTMetadataDataExtensionMessageTest::testDoReceivedAction()
 {
   auto diskAdaptor = std::make_shared<DirectDiskAdaptor>();
-  auto diskWriter = std::make_shared<ByteArrayDiskWriter>();
-  diskAdaptor->setDiskWriter(diskWriter);
+  ByteArrayDiskWriter* diskWriter;
+  {
+    auto dw = make_unique<ByteArrayDiskWriter>();
+    diskWriter = dw.get();
+    diskAdaptor->setDiskWriter(std::move(dw));
+  }
   auto pieceStorage = make_unique<MockPieceStorage>();
   pieceStorage->setDiskAdaptor(diskAdaptor);
   auto tracker = make_unique<UTMetadataRequestTracker>();

test/WrDiskCacheEntryTest.cc

@@ -19,13 +19,14 @@ class WrDiskCacheEntryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 
   std::shared_ptr<DirectDiskAdaptor> adaptor_;
-  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  ByteArrayDiskWriter* writer_;
 public:
   void setUp()
   {
-    adaptor_.reset(new DirectDiskAdaptor());
-    writer_.reset(new ByteArrayDiskWriter());
-    adaptor_->setDiskWriter(writer_);
+    adaptor_ = std::make_shared<DirectDiskAdaptor>();
+    auto dw = make_unique<ByteArrayDiskWriter>();
+    writer_ = dw.get();
+    adaptor_->setDiskWriter(std::move(dw));
   }
 
   void testWriteToDisk();
@@ -48,7 +49,7 @@ void WrDiskCacheEntryTest::testWriteToDisk()
 void WrDiskCacheEntryTest::testAppend()
 {
   WrDiskCacheEntry e(adaptor_);
-  WrDiskCacheEntry::DataCell* cell = new WrDiskCacheEntry::DataCell();
+  auto cell = new WrDiskCacheEntry::DataCell{};
   cell->goff = 0;
   size_t capacity = 6;
   size_t offset = 2;

test/WrDiskCacheTest.cc

@@ -17,13 +17,14 @@ class WrDiskCacheTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 
   std::shared_ptr<DirectDiskAdaptor> adaptor_;
-  std::shared_ptr<ByteArrayDiskWriter> writer_;
+  ByteArrayDiskWriter* writer_;
 public:
   void setUp()
   {
-    adaptor_.reset(new DirectDiskAdaptor());
-    writer_.reset(new ByteArrayDiskWriter());
-    adaptor_->setDiskWriter(writer_);
+    adaptor_ = std::make_shared<DirectDiskAdaptor>();
+    auto dw = make_unique<ByteArrayDiskWriter>();
+    writer_ = dw.get();
+    adaptor_->setDiskWriter(std::move(dw));
   }
 
   void testAdd();