2010-02-28 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>

	Use vector instead of deque for containers which is used for
	mostly read-only purpose.

277 files changed, 1280 insertions, 1232 deletions

diff --git a/ChangeLog b/ChangeLog
index 53bf53f1..61133440 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,10 @@
 2010-02-28  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
 
+	Use vector instead of deque for containers which is used for
+	mostly read-only purpose.
+
+2010-02-28  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
+
 	Fixed typo
 	* test/Makefile.am
 
diff --git a/src/AbstractBtMessage.cc b/src/AbstractBtMessage.cc
index 7e6f84bc..793778e3 100644
--- a/src/AbstractBtMessage.cc
+++ b/src/AbstractBtMessage.cc
@@ -59,12 +59,10 @@ void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer)
   this->peer = peer;
 }
 
-bool AbstractBtMessage::validate(std::deque<std::string>& errors)
+void AbstractBtMessage::validate()
 {
   if(validator.get()) {
-    return validator->validate(errors);
-  } else {
-    return true;
+    validator->validate();
   }
 }
 
diff --git a/src/AbstractBtMessage.h b/src/AbstractBtMessage.h
index 059d2897..4a6a296d 100644
--- a/src/AbstractBtMessage.h
+++ b/src/AbstractBtMessage.h
@@ -37,8 +37,6 @@
 
 #include "BtMessage.h"
 
-#include <deque>
-
 namespace aria2 {
 
 class PieceStorage;
@@ -122,7 +120,7 @@ public:
 
   virtual void doReceivedAction() {}
 
-  virtual bool validate(std::deque<std::string>& errors);
+  virtual void validate();
   
   virtual void onQueued() {}
 
diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index 3294e50d..9e8841af 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -255,7 +255,7 @@ void AbstractCommand::tryReserved() {
   if(logger->debug()) {
     logger->debug("CUID#%d - Trying reserved/pooled request.", cuid);
   }
-  Commands commands;
+  std::vector<Command*> commands;
   _requestGroup->createNextCommand(commands, e, 1);
   e->setNoWait(true);
   e->addCommand(commands);
@@ -503,7 +503,7 @@ bool AbstractCommand::asyncResolveHostname()
   }
 }
 
-const std::deque<std::string>& AbstractCommand::getResolvedAddresses()
+const std::vector<std::string>& AbstractCommand::getResolvedAddresses()
 {
   return _asyncNameResolver->getResolvedAddresses();
 }
@@ -533,10 +533,10 @@ bool AbstractCommand::nameResolveFinished() const {
 
 void AbstractCommand::prepareForNextAction(Command* nextCommand)
 {
-  CheckIntegrityEntryHandle entry
+  SharedHandle<CheckIntegrityEntry> entry
     (new StreamCheckIntegrityEntry(_requestGroup, nextCommand));
 
-  std::deque<Command*> commands;
+  std::vector<Command*> commands;
   try {
     _requestGroup->processCheckIntegrityEntry(commands, entry, e);
   } catch(RecoverableException& e) {
diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h
index fcb49c2d..6028d1fe 100644
--- a/src/AbstractCommand.h
+++ b/src/AbstractCommand.h
@@ -63,7 +63,7 @@ protected:
   SharedHandle<FileEntry> _fileEntry;
   DownloadEngine* e;
   SharedHandle<SocketCore> socket;
-  std::deque<SharedHandle<Segment> > _segments;
+  std::vector<SharedHandle<Segment> > _segments;
 
 #ifdef ENABLE_ASYNC_DNS
   SharedHandle<AsyncNameResolver> _asyncNameResolver;
@@ -74,7 +74,7 @@ protected:
 
   bool asyncResolveHostname();
 
-  const std::deque<std::string>& getResolvedAddresses();
+  const std::vector<std::string>& getResolvedAddresses();
 #endif // ENABLE_ASYNC_DNS
 
   void tryReserved();
diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc
index df4e9c65..d870d241 100644
--- a/src/AbstractProxyRequestCommand.cc
+++ b/src/AbstractProxyRequestCommand.cc
@@ -51,7 +51,7 @@ namespace aria2 {
 
 AbstractProxyRequestCommand::AbstractProxyRequestCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
@@ -76,7 +76,7 @@ bool AbstractProxyRequestCommand::executeInternal() {
        (socket, _connectedHostname, _connectedAddr, _connectedPort)) {
       return true;
     }
-    HttpRequestHandle httpRequest(new HttpRequest());
+    SharedHandle<HttpRequest> httpRequest(new HttpRequest());
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
     httpRequest->setRequest(req);
     httpRequest->setProxyRequest(_proxyRequest);
diff --git a/src/AbstractProxyResponseCommand.cc b/src/AbstractProxyResponseCommand.cc
index b5e40cbe..e04dcc1d 100644
--- a/src/AbstractProxyResponseCommand.cc
+++ b/src/AbstractProxyResponseCommand.cc
@@ -51,7 +51,7 @@ namespace aria2 {
 
 AbstractProxyResponseCommand::AbstractProxyResponseCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
@@ -63,7 +63,7 @@ AbstractProxyResponseCommand::AbstractProxyResponseCommand
 AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {}
 
 bool AbstractProxyResponseCommand::executeInternal() {
-  HttpResponseHandle httpResponse = httpConnection->receiveResponse();
+  SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse();
   if(httpResponse.isNull()) {
     // the server has not responded our request yet.
     e->commands.push_back(this);
diff --git a/src/ActivePeerConnectionCommand.cc b/src/ActivePeerConnectionCommand.cc
index cb53e14a..b7a6585c 100644
--- a/src/ActivePeerConnectionCommand.cc
+++ b/src/ActivePeerConnectionCommand.cc
@@ -114,7 +114,7 @@ bool ActivePeerConnectionCommand::execute() {
 
       for(unsigned int numAdd = numConnection;
           numAdd > 0 && _peerStorage->isPeerAvailable(); --numAdd) {
-        PeerHandle peer = _peerStorage->getUnusedPeer();
+        SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
         connectToPeer(peer);
       }
       if(_btRuntime->getConnections() == 0 &&
@@ -127,7 +127,7 @@ bool ActivePeerConnectionCommand::execute() {
   return false;
 }
 
-void ActivePeerConnectionCommand::connectToPeer(const PeerHandle& peer)
+void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer)
 {
   if(peer.isNull()) {
     return;
diff --git a/src/AnnounceList.cc b/src/AnnounceList.cc
index d6f037db..3113a83f 100644
--- a/src/AnnounceList.cc
+++ b/src/AnnounceList.cc
@@ -54,7 +54,8 @@ AnnounceList::AnnounceList(const BDE& announceList):
   reconfigure(announceList);
 }
 
-AnnounceList::AnnounceList(const AnnounceTiers& announceTiers):
+AnnounceList::AnnounceList
+(const std::deque<SharedHandle<AnnounceTier> >& announceTiers):
   tiers(announceTiers), currentTrackerInitialized(false)  {
   resetIterator();
 }
@@ -77,7 +78,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
         }
       }
       if(!urls.empty()) {
-        AnnounceTierHandle tier(new AnnounceTier(urls));
+        SharedHandle<AnnounceTier> tier(new AnnounceTier(urls));
         tiers.push_back(tier);
       }
     }
@@ -88,7 +89,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
 void AnnounceList::reconfigure(const std::string& url) {
   std::deque<std::string> urls;
   urls.push_back(url);
-  tiers.push_back(AnnounceTierHandle(new AnnounceTier(urls)));
+  tiers.push_back(SharedHandle<AnnounceTier>(new AnnounceTier(urls)));
   resetIterator();
 }
 
@@ -171,7 +172,7 @@ std::string AnnounceList::getEventString() const {
 
 class FindStoppedAllowedTier {
 public:
-  bool operator()(const AnnounceTierHandle& tier) const {
+  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::STOPPED:
@@ -186,7 +187,7 @@ public:
 
 class FindCompletedAllowedTier {
 public:
-  bool operator()(const AnnounceTierHandle& tier) const {
+  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::COMPLETED:
@@ -205,7 +206,8 @@ size_t AnnounceList::countCompletedAllowedTier() const {
   return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier());
 }
 
-void AnnounceList::setCurrentTier(const AnnounceTiers::iterator& itr) {
+void AnnounceList::setCurrentTier
+(const std::deque<SharedHandle<AnnounceTier> >::iterator& itr) {
   if(itr != tiers.end()) {
     currentTier = itr;
     currentTracker = (*currentTier)->urls.begin();
@@ -224,21 +226,23 @@ find_wrap_if(InputIterator first, InputIterator last,
 }
 
 void AnnounceList::moveToStoppedAllowedTier() {
-  AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
-                                             currentTier,
-                                             FindStoppedAllowedTier());
+  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+    find_wrap_if(tiers.begin(), tiers.end(),
+                 currentTier,
+                 FindStoppedAllowedTier());
   setCurrentTier(itr);
 }
 
 void AnnounceList::moveToCompletedAllowedTier() {
-  AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
-                                             currentTier,
-                                             FindCompletedAllowedTier());
+  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+    find_wrap_if(tiers.begin(), tiers.end(),
+                 currentTier,
+                 FindCompletedAllowedTier());
   setCurrentTier(itr);
 }
 
 void AnnounceList::shuffle() {
-  for(AnnounceTiers::iterator itr = tiers.begin();
+  for(std::deque<SharedHandle<AnnounceTier> >::iterator itr = tiers.begin();
       itr != tiers.end(); ++itr) {
     std::deque<std::string>& urls = (*itr)->urls;
     std::random_shuffle(urls.begin(), urls.end(),
diff --git a/src/AnnounceTier.h b/src/AnnounceTier.h
index c45bf89c..0387e83c 100644
--- a/src/AnnounceTier.h
+++ b/src/AnnounceTier.h
@@ -93,9 +93,6 @@ public:
   }
 };
 
-typedef SharedHandle<AnnounceTier> AnnounceTierHandle;
-typedef std::deque<AnnounceTierHandle> AnnounceTiers;
-
 } // namespace aria2
 
 #endif // _D_ANNOUNCE_TIER_H_
diff --git a/src/AsyncNameResolver.h b/src/AsyncNameResolver.h
index bae2f769..ba643b9c 100644
--- a/src/AsyncNameResolver.h
+++ b/src/AsyncNameResolver.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include <ares.h>
 
@@ -65,7 +65,7 @@ private:
   STATUS status;
   ares_channel channel;
 
-  std::deque<std::string> _resolvedAddresses;
+  std::vector<std::string> _resolvedAddresses;
   std::string error;
   std::string _hostname;
 public:
@@ -75,7 +75,7 @@ public:
 
   void resolve(const std::string& name);
 
-  const std::deque<std::string>& getResolvedAddresses() const
+  const std::vector<std::string>& getResolvedAddresses() const
   {
     return _resolvedAddresses;
   }
diff --git a/src/AuthConfigFactory.cc b/src/AuthConfigFactory.cc
index 1f85f5bc..876405ba 100644
--- a/src/AuthConfigFactory.cc
+++ b/src/AuthConfigFactory.cc
@@ -162,7 +162,7 @@ AuthResolverHandle AuthConfigFactory::createFtpAuthResolver
   return resolver;
 }
 
-void AuthConfigFactory::setNetrc(const NetrcHandle& netrc)
+void AuthConfigFactory::setNetrc(const SharedHandle<Netrc>& netrc)
 {
   _netrc = netrc;
 }
diff --git a/src/BDE.h b/src/BDE.h
index 2f40a5a0..939a7237 100644
--- a/src/BDE.h
+++ b/src/BDE.h
@@ -39,7 +39,7 @@
 
 #include <map>
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "DlAbortEx.h"
@@ -51,7 +51,7 @@ class BDE;
 class BDE {
 public:
   typedef std::map<std::string, BDE> Dict;
-  typedef std::deque<BDE> List;
+  typedef std::vector<BDE> List;
   typedef int64_t Integer;
 private:
   enum TYPE{
diff --git a/src/BNode.cc b/src/BNode.cc
index 218b08e7..fdc3c436 100644
--- a/src/BNode.cc
+++ b/src/BNode.cc
@@ -33,11 +33,13 @@
  */
 /* copyright --> */
 #include "BNode.h"
-#include "DHTBucket.h"
-#include "DHTNode.h"
+
 #include <functional>
 #include <algorithm>
 
+#include "DHTBucket.h"
+#include "DHTNode.h"
+
 namespace aria2 {
 
 BNode::BNode(const SharedHandle<DHTBucket>& bucket):
@@ -114,7 +116,7 @@ SharedHandle<DHTBucket> BNode::findBucketFor(BNode* b, const unsigned char* key)
 }
 
 
-void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+void BNode::findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                               BNode* b, const unsigned char* key)
 {
   BNode* bnode = findBNodeFor(b, key);
@@ -128,7 +130,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
   if(nodes.size() >= DHTBucket::K) {
     return;
   }
-  std::deque<const BNode*> visited;
+  std::vector<const BNode*> visited;
   visited.push_back(bnode);
 
   BNode* up = bnode->getUp();
@@ -163,7 +165,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
     {
       SharedHandle<DHTBucket> bucket = bnode->getBucket();
       if(!bucket.isNull()) {
-        std::deque<SharedHandle<DHTNode> > goodNodes;
+        std::vector<SharedHandle<DHTNode> > goodNodes;
         bucket->getGoodNodes(goodNodes);
         size_t r = DHTBucket::K-nodes.size();
         if(goodNodes.size() <= r) {
@@ -176,10 +178,10 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
   }
 }
 
-void BNode::enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
+void BNode::enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
                             const BNode* b)
 {
-  std::deque<const BNode*> visited;
+  std::vector<const BNode*> visited;
   visited.push_back(b);
   while(1) {
     if(!b) {
diff --git a/src/BNode.h b/src/BNode.h
index 740d3a6d..dfcb601b 100644
--- a/src/BNode.h
+++ b/src/BNode.h
@@ -36,8 +36,10 @@
 #define _D_BNODE_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -93,10 +95,10 @@ public:
 
   static SharedHandle<DHTBucket> findBucketFor(BNode* b, const unsigned char* key);
 
-  static void findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+  static void findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                                 BNode* b, const unsigned char* key);
 
-  static void enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
+  static void enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
                               const BNode* b);
 };
 
diff --git a/src/BitfieldMan.h b/src/BitfieldMan.h
index 489cecba..5e8742ef 100644
--- a/src/BitfieldMan.h
+++ b/src/BitfieldMan.h
@@ -36,10 +36,11 @@
 #define _D_BITFIELD_MAN_H_
 
 #include "common.h"
-#include "SharedHandle.h"
-#include <deque>
+
 #include <vector>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class BitfieldMan {
diff --git a/src/BtBitfieldMessageValidator.h b/src/BtBitfieldMessageValidator.h
index 259cb1de..cc59fc7b 100644
--- a/src/BtBitfieldMessageValidator.h
+++ b/src/BtBitfieldMessageValidator.h
@@ -51,12 +51,11 @@ public:
     message(message),
     numPiece(numPiece) {}
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     bittorrent::checkBitfield(message->getBitfield(),
                               message->getBitfieldLength(),
                               numPiece);
-    return true;
   }
 };
 
diff --git a/src/BtCheckIntegrityEntry.cc b/src/BtCheckIntegrityEntry.cc
index a5d1bf64..dc712c07 100644
--- a/src/BtCheckIntegrityEntry.cc
+++ b/src/BtCheckIntegrityEntry.cc
@@ -49,8 +49,8 @@ BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup):
 
 BtCheckIntegrityEntry::~BtCheckIntegrityEntry() {}
 
-void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
-                                                 DownloadEngine* e)
+void BtCheckIntegrityEntry::onDownloadIncomplete
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   const SharedHandle<DiskAdaptor>& diskAdaptor =
     _requestGroup->getPieceStorage()->getDiskAdaptor();
@@ -65,8 +65,8 @@ void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
   proceedFileAllocation(commands, entry, e);
 }
 
-void BtCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
-                                               DownloadEngine* e)
+void BtCheckIntegrityEntry::onDownloadFinished
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   // TODO Currently,when all the checksums
   // are valid, then aira2 goes to seeding mode. Sometimes it is better
diff --git a/src/BtCheckIntegrityEntry.h b/src/BtCheckIntegrityEntry.h
index f3f40ef4..fb5d1829 100644
--- a/src/BtCheckIntegrityEntry.h
+++ b/src/BtCheckIntegrityEntry.h
@@ -45,10 +45,10 @@ public:
 
   virtual ~BtCheckIntegrityEntry();
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e);
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 
diff --git a/src/BtDependency.cc b/src/BtDependency.cc
index 3c70804c..ceb13e3a 100644
--- a/src/BtDependency.cc
+++ b/src/BtDependency.cc
@@ -51,8 +51,8 @@
 
 namespace aria2 {
 
-BtDependency::BtDependency(const RequestGroupWeakHandle& dependant,
-                           const RequestGroupHandle& dependee):
+BtDependency::BtDependency(const WeakHandle<RequestGroup>& dependant,
+                           const SharedHandle<RequestGroup>& dependee):
   _dependant(dependant),
   _dependee(dependee),
   _logger(LogFactory::getInstance()) {}
@@ -74,13 +74,13 @@ static void copyValues(const SharedHandle<FileEntry>& d,
 bool BtDependency::resolve()
 {
   if(_dependee->getNumCommand() == 0 && _dependee->downloadFinished()) {
-    RequestGroupHandle dependee = _dependee;
+    SharedHandle<RequestGroup> dependee = _dependee;
     // cut reference here
     _dependee.reset();
     SharedHandle<DownloadContext> context(new DownloadContext());
     context->setDir(_dependant->getDownloadContext()->getDir());
     try {
-      DiskAdaptorHandle diskAdaptor =
+      SharedHandle<DiskAdaptor> diskAdaptor =
         dependee->getPieceStorage()->getDiskAdaptor();
       diskAdaptor->openExistingFile();
       std::string content = util::toString(diskAdaptor);
diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc
index 465593d1..2f51068e 100644
--- a/src/BtExtendedMessage.cc
+++ b/src/BtExtendedMessage.cc
@@ -99,7 +99,7 @@ std::string BtExtendedMessage::toString() const {
 
 BtExtendedMessageHandle
 BtExtendedMessage::create(const SharedHandle<ExtensionMessageFactory>& factory,
-                          const PeerHandle& peer,
+                          const SharedHandle<Peer>& peer,
                           const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthGreater(1, dataLength, NAME);
diff --git a/src/BtFileAllocationEntry.cc b/src/BtFileAllocationEntry.cc
index d5f66308..a76dfbda 100644
--- a/src/BtFileAllocationEntry.cc
+++ b/src/BtFileAllocationEntry.cc
@@ -49,8 +49,8 @@ BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup):
 
 BtFileAllocationEntry::~BtFileAllocationEntry() {}
 
-void BtFileAllocationEntry::prepareForNextAction(std::deque<Command*>& commands,
-                                                 DownloadEngine* e)
+void BtFileAllocationEntry::prepareForNextAction
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   BtSetup().setup(commands, _requestGroup, e, _requestGroup->getOption().get());
   if(!_requestGroup->downloadFinished()) {
diff --git a/src/BtFileAllocationEntry.h b/src/BtFileAllocationEntry.h
index 61007219..252036f4 100644
--- a/src/BtFileAllocationEntry.h
+++ b/src/BtFileAllocationEntry.h
@@ -45,7 +45,7 @@ public:
 
   virtual ~BtFileAllocationEntry();
 
-  virtual void prepareForNextAction(std::deque<Command*>& commands,
+  virtual void prepareForNextAction(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 
diff --git a/src/BtHandshakeMessageValidator.h b/src/BtHandshakeMessageValidator.h
index a893d708..37a97631 100644
--- a/src/BtHandshakeMessageValidator.h
+++ b/src/BtHandshakeMessageValidator.h
@@ -57,8 +57,8 @@ public:
     memcpy(this->infoHash, infoHash, sizeof(this->infoHash));
   }
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     if(message->getPstrlen() != 19) {
       throw DL_ABORT_EX(StringFormat("invalid handshake pstrlen=%u",
                                      message->getPstrlen()).str());
@@ -74,7 +74,6 @@ public:
                       util::toHex(infoHash, 20).c_str(),
                       util::toHex(message->getInfoHash(), 20).c_str()).str());
     }
-    return true;
   }
 };
 
diff --git a/src/BtLeecherStateChoke.cc b/src/BtLeecherStateChoke.cc
index 1e780476..60297f4d 100644
--- a/src/BtLeecherStateChoke.cc
+++ b/src/BtLeecherStateChoke.cc
@@ -120,12 +120,12 @@ public:
 };
 
 void BtLeecherStateChoke::plannedOptimisticUnchoke
-(std::deque<PeerEntry>& peerEntries)
+(std::vector<PeerEntry>& peerEntries)
 {
   std::for_each(peerEntries.begin(), peerEntries.end(),
                 std::mem_fun_ref(&PeerEntry::disableOptUnchoking));
   
-  std::deque<PeerEntry>::iterator i =
+  std::vector<PeerEntry>::iterator i =
     std::partition(peerEntries.begin(), peerEntries.end(),
                    PeerFilter(true, true));
   if(i != peerEntries.begin()) {
@@ -136,9 +136,9 @@ void BtLeecherStateChoke::plannedOptimisticUnchoke
   }
 }
 
-void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
+void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries)
 {
-  std::deque<PeerEntry>::iterator rest =
+  std::vector<PeerEntry>::iterator rest =
     std::partition(peerEntries.begin(), peerEntries.end(),
                    std::mem_fun_ref(&PeerEntry::isRegularUnchoker));
   
@@ -151,7 +151,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
   int count = 3;
 
   bool fastOptUnchoker = false;
-  std::deque<PeerEntry>::iterator peerIter = peerEntries.begin();
+  std::vector<PeerEntry>::iterator peerIter = peerEntries.begin();
   for(;peerIter != rest && count; ++peerIter, --count) {
     (*peerIter).disableChokingRequired();
     _logger->info("RU: %s, dlspd=%u",
@@ -165,7 +165,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
   if(fastOptUnchoker) {
     std::random_shuffle(peerIter, peerEntries.end(),
                         *(SimpleRandomizer::getInstance().get()));
-    for(std::deque<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
+    for(std::vector<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
         ++i) {
       if((*i).getPeer()->peerInterested()) {
         (*i).enableOptUnchoking();
@@ -196,12 +196,13 @@ public:
 };
 
 void
-BtLeecherStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
+BtLeecherStateChoke::executeChoke
+(const std::vector<SharedHandle<Peer> >& peerSet)
 {
   _logger->info("Leecher state, %d choke round started", _round);
   _lastRound.reset();
 
-  std::deque<PeerEntry> peerEntries;
+  std::vector<PeerEntry> peerEntries;
   std::transform(peerSet.begin(), peerSet.end(),
                  std::back_inserter(peerEntries),
                  BtLeecherStateChokeGenPeerEntry());
diff --git a/src/BtLeecherStateChoke.h b/src/BtLeecherStateChoke.h
index 21b37540..06292b9b 100644
--- a/src/BtLeecherStateChoke.h
+++ b/src/BtLeecherStateChoke.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "TimeA2.h"
@@ -82,9 +82,9 @@ private:
     void disableOptUnchoking();
   };
 
-  void plannedOptimisticUnchoke(std::deque<PeerEntry>& peerEntries);
+  void plannedOptimisticUnchoke(std::vector<PeerEntry>& peerEntries);
 
-  void regularUnchoke(std::deque<PeerEntry>& peerEntries);
+  void regularUnchoke(std::vector<PeerEntry>& peerEntries);
 
   friend class PeerFilter;
   friend class BtLeecherStateChokeGenPeerEntry;
@@ -93,7 +93,7 @@ public:
 
   ~BtLeecherStateChoke();
 
-  void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
+  void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
 
   const Time& getLastRound() const;
 };
diff --git a/src/BtMessage.h b/src/BtMessage.h
index 1ac37429..970e7514 100644
--- a/src/BtMessage.h
+++ b/src/BtMessage.h
@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 
 #include "SharedHandle.h"
 #include "BtAbortOutstandingRequestEvent.h"
@@ -69,7 +68,7 @@ public:
 
   virtual void send() = 0;
 
-  virtual bool validate(std::deque<std::string>& errors) = 0;
+  virtual void validate() = 0;
 
   virtual void onAbortOutstandingRequestEvent
   (const BtAbortOutstandingRequestEvent& event) = 0;
@@ -86,7 +85,6 @@ public:
 };
 
 typedef SharedHandle<BtMessage> BtMessageHandle;
-typedef std::deque<BtMessageHandle> BtMessages;
 
 } // namespace aria2
 
diff --git a/src/BtMessageDispatcher.h b/src/BtMessageDispatcher.h
index ccd8d762..7d231be0 100644
--- a/src/BtMessageDispatcher.h
+++ b/src/BtMessageDispatcher.h
@@ -36,9 +36,11 @@
 #define _D_BT_MESSAGE_DISPATCHER_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
 #include "RequestSlot.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -52,7 +54,7 @@ public:
   virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) = 0;
 
   virtual void
-  addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) = 0;
+  addMessageToQueue(const std::vector<SharedHandle<BtMessage> >& btMessages) =0;
 
   virtual void sendMessages() = 0;
 
diff --git a/src/BtMessageValidator.h b/src/BtMessageValidator.h
index e95c6cee..e865f627 100644
--- a/src/BtMessageValidator.h
+++ b/src/BtMessageValidator.h
@@ -36,19 +36,19 @@
 #define _D_BT_MESSAGE_VALIDATOR_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
-#include <deque>
 
-namespace aria2 {
+#include "SharedHandle.h"
 
-typedef std::deque<std::string> Errors;
+namespace aria2 {
 
 class BtMessageValidator {
 public:
   virtual ~BtMessageValidator() {}
 
-  virtual bool validate(Errors& errors) = 0;
+  // Throws RecoverableException on error.
+  virtual void validate() = 0;
 };
 
 typedef SharedHandle<BtMessageValidator> BtMessageValidatorHandle;
diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc
index 93520f7e..264c1155 100644
--- a/src/BtPieceMessage.cc
+++ b/src/BtPieceMessage.cc
@@ -86,7 +86,7 @@ void BtPieceMessage::doReceivedAction() {
   peer->updateDownloadLength(blockLength);
   if(!RequestSlot::isNull(slot)) {
     peer->snubbing(false);
-    PieceHandle piece = pieceStorage->getPiece(index);
+    SharedHandle<Piece> piece = pieceStorage->getPiece(index);
     off_t offset = (off_t)index*_downloadContext->getPieceLength()+begin;
     if(logger->debug()) {
       logger->debug(MSG_PIECE_RECEIVED,
@@ -183,7 +183,7 @@ std::string BtPieceMessage::toString() const {
                    util::itos(begin), ", length=", util::itos(blockLength));
 }
 
-bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
+bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece) {
   if(piece->isHashCalculated()) {
     if(logger->debug()) {
       logger->debug("Hash is available!! index=%lu",
@@ -199,13 +199,13 @@ bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
   }
 }
 
-void BtPieceMessage::onNewPiece(const PieceHandle& piece) {
+void BtPieceMessage::onNewPiece(const SharedHandle<Piece>& piece) {
   logger->info(MSG_GOT_NEW_PIECE, cuid, piece->getIndex());
   pieceStorage->completePiece(piece);
   pieceStorage->advertisePiece(cuid, piece->getIndex());
 }
 
-void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
+void BtPieceMessage::onWrongPiece(const SharedHandle<Piece>& piece) {
   logger->info(MSG_GOT_WRONG_PIECE, cuid, piece->getIndex());
   erasePieceOnDisk(piece);
   piece->clearAllBlock();
@@ -213,7 +213,7 @@ void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
   requestFactory->removeTargetPiece(piece);
 }
 
-void BtPieceMessage::erasePieceOnDisk(const PieceHandle& piece) {
+void BtPieceMessage::erasePieceOnDisk(const SharedHandle<Piece>& piece) {
   size_t BUFSIZE = 4096;
   unsigned char buf[BUFSIZE];
   memset(buf, 0, BUFSIZE);
diff --git a/src/BtPieceMessageValidator.h b/src/BtPieceMessageValidator.h
index dd3afd45..7813d834 100644
--- a/src/BtPieceMessageValidator.h
+++ b/src/BtPieceMessageValidator.h
@@ -54,11 +54,10 @@ public:
     numPiece(numPiece),
     pieceLength(pieceLength) {}
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     bittorrent::checkIndex(message->getIndex(), numPiece);
     bittorrent::checkBegin(message->getBegin(), pieceLength);
-    return true;
   }
 };
 
diff --git a/src/BtPostDownloadHandler.cc b/src/BtPostDownloadHandler.cc
index dcd86da6..0281e9f6 100644
--- a/src/BtPostDownloadHandler.cc
+++ b/src/BtPostDownloadHandler.cc
@@ -63,7 +63,7 @@ BtPostDownloadHandler::BtPostDownloadHandler()
 BtPostDownloadHandler::~BtPostDownloadHandler() {}
 
 void BtPostDownloadHandler::getNextRequestGroups
-(std::deque<SharedHandle<RequestGroup> >& groups,
+(std::vector<SharedHandle<RequestGroup> >& groups,
  RequestGroup* requestGroup)
 {
   _logger->info("Generating RequestGroups for Torrent file %s",
@@ -77,9 +77,9 @@ void BtPostDownloadHandler::getNextRequestGroups
     requestGroup->getPieceStorage()->getDiskAdaptor()->closeFile();
     throw;
   }
-  std::deque<SharedHandle<RequestGroup> > newRgs;
+  std::vector<SharedHandle<RequestGroup> > newRgs;
   createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
-                                  std::deque<std::string>(),
+                                  std::vector<std::string>(),
                                   content);
   requestGroup->followedBy(newRgs.begin(), newRgs.end());
   groups.insert(groups.end(), newRgs.begin(), newRgs.end());
diff --git a/src/BtPostDownloadHandler.h b/src/BtPostDownloadHandler.h
index b76374d1..c767da28 100644
--- a/src/BtPostDownloadHandler.h
+++ b/src/BtPostDownloadHandler.h
@@ -47,12 +47,10 @@ public:
   virtual ~BtPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
-typedef SharedHandle<BtPostDownloadHandler> BtPostDownloadHandlerHandle;
-
 } // namespace aria2
 
 #endif // _D_BT_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h
index 0c1163fb..51f0df6a 100644
--- a/src/BtRequestFactory.h
+++ b/src/BtRequestFactory.h
@@ -36,8 +36,10 @@
 #define _D_BT_REQUEST_FACTORY_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -68,20 +70,20 @@ public:
    * The number of objects returned is capped by max.
    */
   virtual void createRequestMessages
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Use this method in end game mode.
    *
    */
   virtual void createRequestMessagesOnEndGame
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Stores the list of index of pieces added using addTargetPiece() into
    * indexes.
    */
-  virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const = 0;
+  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const = 0;
 
 };
 
diff --git a/src/BtSeederStateChoke.cc b/src/BtSeederStateChoke.cc
index 1af79eca..d5886339 100644
--- a/src/BtSeederStateChoke.cc
+++ b/src/BtSeederStateChoke.cc
@@ -83,13 +83,13 @@ void BtSeederStateChoke::PeerEntry::disableOptUnchoking()
 }
 
 void BtSeederStateChoke::unchoke
-(std::deque<BtSeederStateChoke::PeerEntry>& peers)
+(std::vector<BtSeederStateChoke::PeerEntry>& peers)
 {
   int count = (_round == 2) ? 4 : 3;
 
   std::sort(peers.begin(), peers.end());
 
-  std::deque<PeerEntry>::iterator r = peers.begin();
+  std::vector<PeerEntry>::iterator r = peers.begin();
   for(; r != peers.end() && count; ++r, --count) {
     (*r).getPeer()->chokingRequired(false);
     _logger->info("RU: %s, ulspd=%u", (*r).getPeer()->ipaddr.c_str(),
@@ -140,12 +140,13 @@ public:
 };
 
 void
-BtSeederStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
+BtSeederStateChoke::executeChoke
+(const std::vector<SharedHandle<Peer> >& peerSet)
 {
   _logger->info("Seeder state, %d choke round started", _round);
   _lastRound.reset();
 
-  std::deque<PeerEntry> peerEntries;
+  std::vector<PeerEntry> peerEntries;
 
   std::for_each(peerSet.begin(), peerSet.end(), ChokingRequired());
 
diff --git a/src/BtSeederStateChoke.h b/src/BtSeederStateChoke.h
index edf7e04f..8acc8833 100644
--- a/src/BtSeederStateChoke.h
+++ b/src/BtSeederStateChoke.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "TimeA2.h"
@@ -76,7 +76,7 @@ private:
     void disableOptUnchoking();
   };
 
-  void unchoke(std::deque<PeerEntry>& peers);
+  void unchoke(std::vector<PeerEntry>& peers);
 
   friend class GenPeerEntry;
   friend class NotInterestedPeer;
@@ -85,7 +85,7 @@ public:
 
   ~BtSeederStateChoke();
 
-  void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
+  void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
 
   const Time& getLastRound() const { return _lastRound; }
 };
diff --git a/src/BtSetup.cc b/src/BtSetup.cc
index b6799b73..d34e7d8b 100644
--- a/src/BtSetup.cc
+++ b/src/BtSetup.cc
@@ -74,7 +74,7 @@ namespace aria2 {
 
 BtSetup::BtSetup():_logger(LogFactory::getInstance()) {}
 
-void BtSetup::setup(std::deque<Command*>& commands,
+void BtSetup::setup(std::vector<Command*>& commands,
                     RequestGroup* requestGroup,
                     DownloadEngine* e,
                     const Option* option)
diff --git a/src/BtSetup.h b/src/BtSetup.h
index 4bf79524..2d22fcc9 100644
--- a/src/BtSetup.h
+++ b/src/BtSetup.h
@@ -36,7 +36,7 @@
 #define _D_BT_SETUP_H_
 
 #include "common.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
@@ -52,7 +52,7 @@ private:
 public:
   BtSetup();
 
-  void setup(std::deque<Command*>& commands,
+  void setup(std::vector<Command*>& commands,
              RequestGroup* requestGroup,
              DownloadEngine* e,
              const Option* option);
diff --git a/src/CheckIntegrityCommand.cc b/src/CheckIntegrityCommand.cc
index dc9d155f..00d8c354 100644
--- a/src/CheckIntegrityCommand.cc
+++ b/src/CheckIntegrityCommand.cc
@@ -47,7 +47,7 @@ namespace aria2 {
 
 CheckIntegrityCommand::CheckIntegrityCommand
 (int32_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
- const CheckIntegrityEntryHandle& entry):
+ const SharedHandle<CheckIntegrityEntry>& entry):
   RealtimeCommand(cuid, requestGroup, e),
   _entry(entry)
 {}
@@ -69,7 +69,7 @@ bool CheckIntegrityCommand::executeInternal()
     if(_requestGroup->downloadFinished()) {
       logger->notice(MSG_VERIFICATION_SUCCESSFUL,
                      _requestGroup->getDownloadContext()->getBasePath().c_str());
-      std::deque<Command*> commands;
+      std::vector<Command*> commands;
       try {
         _entry->onDownloadFinished(commands, _e);
       } catch(RecoverableException& e) {
@@ -80,7 +80,7 @@ bool CheckIntegrityCommand::executeInternal()
     } else {
       logger->error(MSG_VERIFICATION_FAILED,
                     _requestGroup->getDownloadContext()->getBasePath().c_str());
-      std::deque<Command*> commands;
+      std::vector<Command*> commands;
       try {
         _entry->onDownloadIncomplete(commands,_e);
       } catch(RecoverableException& e) {
diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc
index 34413ffb..a5cc9ff6 100644
--- a/src/CheckIntegrityEntry.cc
+++ b/src/CheckIntegrityEntry.cc
@@ -86,7 +86,7 @@ void CheckIntegrityEntry::cutTrailingGarbage()
 }
 
 void CheckIntegrityEntry::proceedFileAllocation
-(std::deque<Command*>& commands,
+(std::vector<Command*>& commands,
  const SharedHandle<FileAllocationEntry>& entry,
  DownloadEngine* e)
 {
diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h
index 899d1728..6c7110cb 100644
--- a/src/CheckIntegrityEntry.h
+++ b/src/CheckIntegrityEntry.h
@@ -37,7 +37,8 @@
 
 #include "RequestGroupEntry.h"
 #include "ProgressAwareEntry.h"
-#include <deque>
+
+#include <vector>
 
 namespace aria2 {
 
@@ -50,7 +51,7 @@ class CheckIntegrityEntry : public RequestGroupEntry,
 protected:
   SharedHandle<IteratableValidator> _validator;
 
-  void proceedFileAllocation(std::deque<Command*>& commands,
+  void proceedFileAllocation(std::vector<Command*>& commands,
                              const SharedHandle<FileAllocationEntry>& entry,
                              DownloadEngine* e);
 public:
@@ -70,18 +71,15 @@ public:
 
   virtual void initValidator() = 0;
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e) = 0;
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e) = 0;
 
   void cutTrailingGarbage();
 };
 
-typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
-typedef std::deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
-
 } // namespace aria2
 
 #endif // _D_CHECK_INTEGRITY_ENTRY_H_
diff --git a/src/ChecksumCheckIntegrityEntry.cc b/src/ChecksumCheckIntegrityEntry.cc
index 64cf72a2..482b00da 100644
--- a/src/ChecksumCheckIntegrityEntry.cc
+++ b/src/ChecksumCheckIntegrityEntry.cc
@@ -62,13 +62,13 @@ void ChecksumCheckIntegrityEntry::initValidator()
 }
 
 void
-ChecksumCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
-                                                DownloadEngine* e)
+ChecksumCheckIntegrityEntry::onDownloadFinished
+(std::vector<Command*>& commands, DownloadEngine* e)
 {}
 
 void
-ChecksumCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
-                                                  DownloadEngine* e)
+ChecksumCheckIntegrityEntry::onDownloadIncomplete
+(std::vector<Command*>& commands, DownloadEngine* e)
 {}
 
 } // namespace aria2
diff --git a/src/ChecksumCheckIntegrityEntry.h b/src/ChecksumCheckIntegrityEntry.h
index ae30b206..41a8d475 100644
--- a/src/ChecksumCheckIntegrityEntry.h
+++ b/src/ChecksumCheckIntegrityEntry.h
@@ -50,10 +50,10 @@ public:
 
   virtual void initValidator();
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e);
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 
diff --git a/src/Command.h b/src/Command.h
index e4bd42a9..34647ada 100644
--- a/src/Command.h
+++ b/src/Command.h
@@ -37,7 +37,6 @@
 
 #include "common.h"
 #include <stdint.h>
-#include <deque>
 
 namespace aria2 {
 
@@ -105,8 +104,6 @@ public:
   void clearIOEvents();
 };
 
-typedef std::deque<Command*> Commands;
-
 } // namespace aria2
 
 #endif // _D_COMMAND_H_
diff --git a/src/ConsoleStatCalc.cc b/src/ConsoleStatCalc.cc
index 4ea7e976..b2d959fa 100644
--- a/src/ConsoleStatCalc.cc
+++ b/src/ConsoleStatCalc.cc
@@ -120,7 +120,7 @@ static void printProgress
   SharedHandle<PeerStorage> ps =
     e->getBtRegistry()->get(rg->getGID())._peerStorage;
   if(!ps.isNull()) {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     ps->getActivePeers(peers);
     o << " " << "SEED:"
       << countSeeder(peers.begin(), peers.end());
@@ -250,7 +250,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
       std::cout << "\n";
     }
 
-    RequestGroupHandle firstRequestGroup = e->_requestGroupMan->getRequestGroup(0);
+    SharedHandle<RequestGroup> firstRequestGroup =
+      e->_requestGroupMan->getRequestGroup(0);
 
     printProgress(o, firstRequestGroup, e, sizeFormatter);
 
@@ -297,7 +298,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
   }
 #ifdef ENABLE_MESSAGE_DIGEST
   {
-    CheckIntegrityEntryHandle entry = e->_checkIntegrityMan->getPickedEntry();
+    SharedHandle<CheckIntegrityEntry> entry =
+      e->_checkIntegrityMan->getPickedEntry();
     if(!entry.isNull()) {
       o << " "
         << "[Checksum:"
diff --git a/src/Cookie.h b/src/Cookie.h
index 3b667273..04acc8de 100644
--- a/src/Cookie.h
+++ b/src/Cookie.h
@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 
 #include "a2time.h"
 
@@ -155,8 +154,6 @@ public:
   static std::string normalizeDomain(const std::string& domain);
 };
 
-typedef std::deque<Cookie> Cookies;
-
 } // namespace aria2
 
 #endif // _D_COOKIE_H_
diff --git a/src/CookieStorage.cc b/src/CookieStorage.cc
index 8d99bf89..2e584f0b 100644
--- a/src/CookieStorage.cc
+++ b/src/CookieStorage.cc
@@ -140,14 +140,6 @@ bool CookieStorage::store(const Cookie& cookie)
   return added;
 }
 
-void CookieStorage::storeCookies(const std::deque<Cookie>& cookies)
-{
-  for(std::deque<Cookie>::const_iterator i = cookies.begin();
-      i != cookies.end(); ++i) {
-    store(*i);
-  }
-}
-
 bool CookieStorage::parseAndStore(const std::string& setCookieString,
                                   const std::string& requestHost,
                                   const std::string& requestPath)
@@ -240,11 +232,11 @@ bool CookieStorage::contains(const Cookie& cookie) const
   }
 }
 
-std::deque<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
+std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
                                                const std::string& requestPath,
                                                time_t date, bool secure)
 {
-  std::deque<Cookie> res;
+  std::vector<Cookie> res;
   bool numericHost = util::isNumericHost(requestHost);
   searchCookieByDomainSuffix
     ((!numericHost && requestHost.find(A2STR::DOT_C) == std::string::npos)?
@@ -307,14 +299,16 @@ bool CookieStorage::load(const std::string& filename)
   try {
     if(std::string(header) == "SQLite format 3") {
 #ifdef HAVE_SQLITE3
-      storeCookies(Sqlite3MozCookieParser().parse(filename));
+      std::vector<Cookie> cookies = Sqlite3MozCookieParser().parse(filename);
+      storeCookies(cookies.begin(), cookies.end());
 #else // !HAVE_SQLITE3
       throw DL_ABORT_EX
         ("Cannot read SQLite3 database because SQLite3 support is disabled by"
          " configuration.");
 #endif // !HAVE_SQLITE3
     } else {
-      storeCookies(NsCookieParser().parse(filename));
+      std::vector<Cookie> cookies = NsCookieParser().parse(filename);
+      storeCookies(cookies.begin(), cookies.end());
     }
     return true;
   } catch(RecoverableException& e) {
diff --git a/src/CookieStorage.h b/src/CookieStorage.h
index 1d343725..eaac2bce 100644
--- a/src/CookieStorage.h
+++ b/src/CookieStorage.h
@@ -39,6 +39,7 @@
 
 #include <string>
 #include <deque>
+#include <vector>
 #include <algorithm>
 
 #include "a2time.h"
@@ -122,7 +123,13 @@ private:
 
   Logger* _logger;
 
-  void storeCookies(const std::deque<Cookie>& cookies);
+  template<typename InputIterator>
+  void storeCookies(InputIterator first, InputIterator last)
+  {
+    for(; first != last; ++first) {
+      store(*first);
+    }
+  }
 public:
   CookieStorage();
 
@@ -140,9 +147,9 @@ public:
 
   // Finds cookies matched with given criteria and returns them.
   // Matched cookies' _lastAccess property is updated.
-  std::deque<Cookie> criteriaFind(const std::string& requestHost,
-                                  const std::string& requestPath,
-                                  time_t date, bool secure);
+  std::vector<Cookie> criteriaFind(const std::string& requestHost,
+                                   const std::string& requestPath,
+                                   time_t date, bool secure);
 
   // Loads Cookies from file denoted by filename.  If compiled with
   // libsqlite3, this method automatically detects the specified file
diff --git a/src/DHTAbstractNodeLookupTask.cc b/src/DHTAbstractNodeLookupTask.cc
index f828c4dc..fd96618a 100644
--- a/src/DHTAbstractNodeLookupTask.cc
+++ b/src/DHTAbstractNodeLookupTask.cc
@@ -38,7 +38,6 @@
 #include "DHTMessageFactory.h"
 #include "DHTMessage.h"
 #include "DHTNode.h"
-#include "DHTNodeLookupEntry.h"
 #include "DHTMessageCallbackImpl.h"
 #include "DHTBucket.h"
 #include "LogFactory.h"
@@ -60,13 +59,13 @@ void DHTAbstractNodeLookupTask::onReceived(const SharedHandle<DHTMessage>& messa
 {
   --_inFlightMessage;
   onReceivedInternal(message);
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   getNodesFromMessage(nodes, message);
-  std::deque<SharedHandle<DHTNodeLookupEntry> > newEntries;
+  std::vector<SharedHandle<DHTNodeLookupEntry> > newEntries;
   toEntries(newEntries, nodes);
 
   size_t count = 0;
-  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
+  for(std::vector<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
         newEntries.begin(); i != newEntries.end(); ++i) {
     if(memcmp(_localNode->getID(), (*i)->_node->getID(), DHT_ID_LENGTH) != 0) {
       _entries.push_front(*i);
@@ -132,7 +131,9 @@ void DHTAbstractNodeLookupTask::sendMessageAndCheckFinish()
 
 void DHTAbstractNodeLookupTask::sendMessage()
 {
-  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = _entries.begin(); i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
+  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+        _entries.begin();
+      i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
     if((*i)->_used == false) {
       ++_inFlightMessage;
       (*i)->_used = true;
@@ -151,7 +152,7 @@ void DHTAbstractNodeLookupTask::updateBucket()
 
 void DHTAbstractNodeLookupTask::startup()
 {
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   _routingTable->getClosestKNodes(nodes, _targetID);
   _entries.clear();
   toEntries(_entries, nodes);
@@ -170,14 +171,4 @@ void DHTAbstractNodeLookupTask::startup()
   }
 }
 
-void DHTAbstractNodeLookupTask::toEntries
-(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
- const std::deque<SharedHandle<DHTNode> >& nodes) const
-{
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
-    SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
-    entries.push_back(e);
-  }
-}
-
 } // namespace aria2
diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h
index 8b53f9bc..30fbf86c 100644
--- a/src/DHTAbstractNodeLookupTask.h
+++ b/src/DHTAbstractNodeLookupTask.h
@@ -36,14 +36,17 @@
 #define _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_
 
 #include "DHTAbstractTask.h"
+
+#include <deque>
+#include <vector>
+
 #include "DHTMessageCallbackListener.h"
 #include "DHTConstants.h"
-#include <deque>
+#include "DHTNodeLookupEntry.h"
 
 namespace aria2 {
 
 class DHTNode;
-class DHTNodeLookupEntry;
 class DHTMessage;
 
 class DHTAbstractNodeLookupTask:public DHTAbstractTask, public DHTMessageCallbackListener {
@@ -54,8 +57,16 @@ protected:
   
   size_t _inFlightMessage;
   
-  void toEntries(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
-                 const std::deque<SharedHandle<DHTNode> >& nodes) const;
+  template<typename Container>
+  void toEntries
+  (Container& entries, const std::vector<SharedHandle<DHTNode> >& nodes) const
+  {
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes.begin();
+        i != nodes.end(); ++i) {
+      SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
+      entries.push_back(e);
+    }
+  }
 
   void sendMessage();
 
@@ -73,7 +84,7 @@ public:
 
   virtual void onTimeout(const SharedHandle<DHTNode>& node);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message) = 0;
   
   virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message) {}
diff --git a/src/DHTAutoSaveCommand.cc b/src/DHTAutoSaveCommand.cc
index bbd222a3..f8a5509e 100644
--- a/src/DHTAutoSaveCommand.cc
+++ b/src/DHTAutoSaveCommand.cc
@@ -98,13 +98,13 @@ void DHTAutoSaveCommand::save()
       }
     }
   }
-  std::deque<SharedHandle<DHTNode> > nodes;
-  std::deque<SharedHandle<DHTBucket> > buckets;
+  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTBucket> > buckets;
   _routingTable->getBuckets(buckets);
-  for(std::deque<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(); i != buckets.end(); ++i) {
-
+  for(std::vector<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin();
+      i != buckets.end(); ++i) {
     const SharedHandle<DHTBucket>& bucket = *i;
-    std::deque<SharedHandle<DHTNode> > goodNodes;
+    std::vector<SharedHandle<DHTNode> > goodNodes;
     bucket->getGoodNodes(goodNodes);
     nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
   }
diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc
index 724a14e7..1b4d52cb 100644
--- a/src/DHTBucket.cc
+++ b/src/DHTBucket.cc
@@ -214,9 +214,10 @@ SharedHandle<DHTBucket> DHTBucket::split()
   return rBucket;
 }
 
-void DHTBucket::getGoodNodes(std::deque<SharedHandle<DHTNode> >& goodNodes) const
+void DHTBucket::getGoodNodes
+(std::vector<SharedHandle<DHTNode> >& goodNodes) const
 {
-  goodNodes = _nodes;
+  goodNodes.insert(goodNodes.end(), _nodes.begin(), _nodes.end());  
   goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
                                  mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
 }
diff --git a/src/DHTBucket.h b/src/DHTBucket.h
index bd38e9fa..4b036862 100644
--- a/src/DHTBucket.h
+++ b/src/DHTBucket.h
@@ -36,11 +36,14 @@
 #define _D_DHT_BUCKET_H_
 
 #include "common.h"
+
+#include <string>
+#include <deque>
+#include <vector>
+
 #include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "TimeA2.h"
-#include <string>
-#include <deque>
 
 namespace aria2 {
 
@@ -123,7 +126,7 @@ public:
     return _nodes;
   }
 
-  void getGoodNodes(std::deque<SharedHandle<DHTNode> >& nodes) const;
+  void getGoodNodes(std::vector<SharedHandle<DHTNode> >& nodes) const;
 
   void dropNode(const SharedHandle<DHTNode>& node);
 
diff --git a/src/DHTBucketRefreshTask.cc b/src/DHTBucketRefreshTask.cc
index 31071e8c..c8d520ac 100644
--- a/src/DHTBucketRefreshTask.cc
+++ b/src/DHTBucketRefreshTask.cc
@@ -51,9 +51,10 @@ DHTBucketRefreshTask::~DHTBucketRefreshTask() {}
 
 void DHTBucketRefreshTask::startup()
 {
-  std::deque<SharedHandle<DHTBucket> > buckets;
+  std::vector<SharedHandle<DHTBucket> > buckets;
   _routingTable->getBuckets(buckets);
-  for(std::deque<SharedHandle<DHTBucket> >::iterator i = buckets.begin(); i != buckets.end(); ++i) {
+  for(std::vector<SharedHandle<DHTBucket> >::iterator i = buckets.begin();
+      i != buckets.end(); ++i) {
     if(_forceRefresh || (*i)->needsRefresh()) {
       (*i)->notifyUpdate();
       unsigned char targetID[DHT_ID_LENGTH];
diff --git a/src/DHTConnectionImpl.cc b/src/DHTConnectionImpl.cc
index 8a882078..7dabdffc 100644
--- a/src/DHTConnectionImpl.cc
+++ b/src/DHTConnectionImpl.cc
@@ -35,7 +35,6 @@
 #include "DHTConnectionImpl.h"
 
 #include <utility>
-#include <deque>
 #include <algorithm>
 
 #include "LogFactory.h"
@@ -54,11 +53,11 @@ DHTConnectionImpl::~DHTConnectionImpl() {}
 
 bool DHTConnectionImpl::bind(uint16_t& port, IntSequence& ports)
 {
-  std::deque<int32_t> randPorts = ports.flush();
+  std::vector<int32_t> randPorts = ports.flush();
   std::random_shuffle(randPorts.begin(), randPorts.end(),
                       *SimpleRandomizer::getInstance().get());
   
-  for(std::deque<int32_t>::const_iterator portItr = randPorts.begin();
+  for(std::vector<int32_t>::const_iterator portItr = randPorts.begin();
       portItr != randPorts.end(); ++portItr) {
     if(!(0 < (*portItr) && (*portItr) <= 65535)) {
       continue;
diff --git a/src/DHTEntryPointNameResolveCommand.cc b/src/DHTEntryPointNameResolveCommand.cc
index f00f55b6..c4c5be8c 100644
--- a/src/DHTEntryPointNameResolveCommand.cc
+++ b/src/DHTEntryPointNameResolveCommand.cc
@@ -55,10 +55,12 @@
 
 namespace aria2 {
 
-DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e, const std::deque<std::pair<std::string, uint16_t> >& entryPoints):
+DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand
+(int32_t cuid, DownloadEngine* e,
+ const std::vector<std::pair<std::string, uint16_t> >& entryPoints):
   Command(cuid),
   _e(e),
-  _entryPoints(entryPoints),
+  _entryPoints(entryPoints.begin(), entryPoints.end()),
   _bootstrapEnabled(false)
 {}
 
@@ -82,7 +84,7 @@ bool DHTEntryPointNameResolveCommand::execute()
   try {
 #ifdef ENABLE_ASYNC_DNS
     if(_e->option->getAsBool(PREF_ASYNC_DNS)) {
-      while(_entryPoints.size()) {
+      while(!_entryPoints.empty()) {
         std::string hostname = _entryPoints.front().first;
         try {
           if(resolveHostname(hostname, _resolver)) {
@@ -99,17 +101,17 @@ bool DHTEntryPointNameResolveCommand::execute()
           logger->error(EX_EXCEPTION_CAUGHT, e);
         }
         _resolver->reset();
-        _entryPoints.erase(_entryPoints.begin());
+        _entryPoints.pop_front();
       }
     } else
 #endif // ENABLE_ASYNC_DNS
       {
         NameResolver res;
         res.setSocktype(SOCK_DGRAM);
-        while(_entryPoints.size()) {
+        while(!_entryPoints.empty()) {
           std::string hostname = _entryPoints.front().first;
           try {
-            std::deque<std::string> addrs;
+            std::vector<std::string> addrs;
             res.resolve(addrs, hostname);
           
             std::pair<std::string, uint16_t> p(addrs.front(),
@@ -119,7 +121,7 @@ bool DHTEntryPointNameResolveCommand::execute()
           } catch(RecoverableException& e) {
             logger->error(EX_EXCEPTION_CAUGHT, e);
           }
-          _entryPoints.erase(_entryPoints.begin());
+          _entryPoints.pop_front();
         }
       }
     if(_bootstrapEnabled && _resolvedEntryPoints.size()) {
diff --git a/src/DHTEntryPointNameResolveCommand.h b/src/DHTEntryPointNameResolveCommand.h
index dadf2993..85c9c92a 100644
--- a/src/DHTEntryPointNameResolveCommand.h
+++ b/src/DHTEntryPointNameResolveCommand.h
@@ -36,10 +36,13 @@
 #define _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_
 
 #include "Command.h"
-#include "SharedHandle.h"
+
 #include <utility>
+#include <vector>
 #include <deque>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class DHTTaskQueue;
@@ -69,7 +72,7 @@ private:
 
   std::deque<std::pair<std::string, uint16_t> > _entryPoints;
 
-  std::deque<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
+  std::vector<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
 
   bool _bootstrapEnabled;
 
@@ -85,8 +88,9 @@ private:
 #endif // ENABLE_ASYNC_DNS
 
 public:
-  DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e,
-                                  const std::deque<std::pair<std:: string, uint16_t> >& entryPoints);
+  DHTEntryPointNameResolveCommand
+  (int32_t cuid, DownloadEngine* e,
+   const std::vector<std::pair<std:: string, uint16_t> >& entryPoints);
 
   virtual ~DHTEntryPointNameResolveCommand();
 
diff --git a/src/DHTFindNodeMessage.cc b/src/DHTFindNodeMessage.cc
index 26630b42..571be287 100644
--- a/src/DHTFindNodeMessage.cc
+++ b/src/DHTFindNodeMessage.cc
@@ -63,7 +63,7 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {}
 
 void DHTFindNodeMessage::doReceivedAction()
 {
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   _routingTable->getClosestKNodes(nodes, _targetNodeID);
   SharedHandle<DHTMessage> reply =
     _factory->createFindNodeReplyMessage(_remoteNode, nodes, _transactionID);
diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc
index ee08d6d1..269b0a62 100644
--- a/src/DHTFindNodeReplyMessage.cc
+++ b/src/DHTFindNodeReplyMessage.cc
@@ -61,7 +61,8 @@ DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {}
 
 void DHTFindNodeReplyMessage::doReceivedAction()
 {
-  for(std::deque<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+  for(std::vector<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin();
+      i != _closestKNodes.end(); ++i) {
     if(memcmp((*i)->getID(), _localNode->getID(), DHT_ID_LENGTH) != 0) {
       _routingTable->addNode(*i);
     }
@@ -75,7 +76,7 @@ BDE DHTFindNodeReplyMessage::getResponse()
   size_t offset = 0;
   unsigned char buffer[DHTBucket::K*26];
   // TODO if _closestKNodes.size() > DHTBucket::K ??
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+  for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
         _closestKNodes.begin();
       i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
     SharedHandle<DHTNode> node = *i;
@@ -96,7 +97,8 @@ std::string DHTFindNodeReplyMessage::getMessageType() const
 
 void DHTFindNodeReplyMessage::validate() const {}
 
-void DHTFindNodeReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
+void DHTFindNodeReplyMessage::setClosestKNodes
+(const std::vector<SharedHandle<DHTNode> >& closestKNodes)
 {
   _closestKNodes = closestKNodes;
 }
diff --git a/src/DHTFindNodeReplyMessage.h b/src/DHTFindNodeReplyMessage.h
index 58d952c3..600b1591 100644
--- a/src/DHTFindNodeReplyMessage.h
+++ b/src/DHTFindNodeReplyMessage.h
@@ -36,13 +36,13 @@
 #define _D_DHT_FIND_NODE_REPLY_MESSAGE_H_
 
 #include "DHTResponseMessage.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
 class DHTFindNodeReplyMessage:public DHTResponseMessage {
 private:
-  std::deque<SharedHandle<DHTNode> > _closestKNodes;
+  std::vector<SharedHandle<DHTNode> > _closestKNodes;
 protected:
   virtual std::string toStringOptional() const;
 public:
@@ -60,12 +60,13 @@ public:
 
   virtual void validate() const;
 
-  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
   {
     return _closestKNodes;
   }
 
-  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
+  void setClosestKNodes
+  (const std::vector<SharedHandle<DHTNode> >& closestKNodes);
 
   static const std::string FIND_NODE;
   
diff --git a/src/DHTGetPeersMessage.cc b/src/DHTGetPeersMessage.cc
index 66f1b845..adab269e 100644
--- a/src/DHTGetPeersMessage.cc
+++ b/src/DHTGetPeersMessage.cc
@@ -70,11 +70,11 @@ void DHTGetPeersMessage::doReceivedAction()
                                                    _remoteNode->getIPAddress(),
                                                    _remoteNode->getPort());
   // Check to see localhost has the contents which has same infohash
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   _peerAnnounceStorage->getPeers(peers, _infoHash);
   SharedHandle<DHTMessage> reply;
   if(peers.empty()) {
-    std::deque<SharedHandle<DHTNode> > nodes;
+    std::vector<SharedHandle<DHTNode> > nodes;
     _routingTable->getClosestKNodes(nodes, _infoHash);
     reply =
       _factory->createGetPeersReplyMessage(_remoteNode, nodes, token,
diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc
index 39368ad9..3b7f72c2 100644
--- a/src/DHTGetPeersReplyMessage.cc
+++ b/src/DHTGetPeersReplyMessage.cc
@@ -58,10 +58,11 @@ const std::string DHTGetPeersReplyMessage::VALUES("values");
 
 const std::string DHTGetPeersReplyMessage::NODES("nodes");
 
-DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const SharedHandle<DHTNode>& localNode,
-                                                 const SharedHandle<DHTNode>& remoteNode,
-                                                 const std::string& token,
-                                                 const std::string& transactionID):
+DHTGetPeersReplyMessage::DHTGetPeersReplyMessage
+(const SharedHandle<DHTNode>& localNode,
+ const SharedHandle<DHTNode>& remoteNode,
+ const std::string& token,
+ const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID),
   _token(token) {}
 
@@ -80,7 +81,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
   if(_values.empty()) {
     size_t offset = 0;
     unsigned char buffer[DHTBucket::K*26];
-    for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
           _closestKNodes.begin();
         i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
       SharedHandle<DHTNode> node = *i;
@@ -113,7 +114,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
     // number of peer info that a message can carry.
     static const size_t MAX_VALUES_SIZE = 100;
     BDE valuesList = BDE::list();
-    for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin();
+    for(std::vector<SharedHandle<Peer> >::const_iterator i = _values.begin();
         i != _values.end() && valuesList.size() < MAX_VALUES_SIZE; ++i) {
       const SharedHandle<Peer>& peer = *i;
       unsigned char buffer[6];
@@ -133,16 +134,6 @@ std::string DHTGetPeersReplyMessage::getMessageType() const
 
 void DHTGetPeersReplyMessage::validate() const {}
 
-void DHTGetPeersReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
-{
-  _closestKNodes = closestKNodes;
-}
-
-void DHTGetPeersReplyMessage::setValues(const std::deque<SharedHandle<Peer> >& peers)
-{
-  _values = peers;
-}
-
 std::string DHTGetPeersReplyMessage::toStringOptional() const
 {
   return strconcat("token=", util::toHex(_token),
diff --git a/src/DHTGetPeersReplyMessage.h b/src/DHTGetPeersReplyMessage.h
index fb66e9af..eb6f493e 100644
--- a/src/DHTGetPeersReplyMessage.h
+++ b/src/DHTGetPeersReplyMessage.h
@@ -37,7 +37,7 @@
 
 #include "DHTResponseMessage.h"
 
-#include <deque>
+#include <vector>
 
 #include "DHTConstants.h"
 
@@ -49,9 +49,9 @@ class DHTGetPeersReplyMessage:public DHTResponseMessage {
 private:
   std::string _token;
 
-  std::deque<SharedHandle<DHTNode> > _closestKNodes;
+  std::vector<SharedHandle<DHTNode> > _closestKNodes;
 
-  std::deque<SharedHandle<Peer> > _values;
+  std::vector<SharedHandle<Peer> > _values;
 protected:
   virtual std::string toStringOptional() const;
 public:
@@ -70,19 +70,26 @@ public:
 
   virtual void validate() const;
 
-  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
   {
     return _closestKNodes;
   }
 
-  const std::deque<SharedHandle<Peer> >& getValues() const
+  const std::vector<SharedHandle<Peer> >& getValues() const
   {
     return _values;
   }
 
-  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
+  void setClosestKNodes
+  (const std::vector<SharedHandle<DHTNode> >& closestKNodes)
+  {
+    _closestKNodes = closestKNodes;
+  }
 
-  void setValues(const std::deque<SharedHandle<Peer> >& peers);
+  void setValues(const std::vector<SharedHandle<Peer> >& peers)
+  {
+    _values = peers;
+  }
   
   const std::string& getToken() const
   {
diff --git a/src/DHTMessageFactory.h b/src/DHTMessageFactory.h
index 2a823ceb..be00f2cd 100644
--- a/src/DHTMessageFactory.h
+++ b/src/DHTMessageFactory.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "A2STR.h"
@@ -78,9 +78,10 @@ public:
                         const std::string& transactionID = A2STR::NIL) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& transactionID) = 0;
+  createFindNodeReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
   createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@@ -88,16 +89,18 @@ public:
                         const std::string& transactionID = A2STR::NIL) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& token,
-                             const std::string& transactionID) = 0;
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& token,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<Peer> >& peers,
-                             const std::string& token,
-                             const std::string& transactionID) = 0;
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<Peer> >& peers,
+   const std::string& token,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
   createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc
index 6e3c69ae..cd0eb8e0 100644
--- a/src/DHTMessageFactoryImpl.cc
+++ b/src/DHTMessageFactoryImpl.cc
@@ -314,23 +314,25 @@ DHTMessageFactoryImpl::createFindNodeMessage(const SharedHandle<DHTNode>& remote
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createFindNodeReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+ const std::string& transactionID)
 {
-  SharedHandle<DHTFindNodeReplyMessage> m(new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
+  SharedHandle<DHTFindNodeReplyMessage> m
+    (new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
   m->setClosestKNodes(closestKNodes);
   setCommonProperty(m);
   return m;
 }
 
-std::deque<SharedHandle<DHTNode> >
+std::vector<SharedHandle<DHTNode> >
 DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
 {
   if(length%26 != 0) {
     throw DL_ABORT_EX("Nodes length is not multiple of 26");
   }
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   for(size_t offset = 0; offset < length; offset += 26) {
     SharedHandle<DHTNode> node(new DHTNode(src+offset));
     std::pair<std::string, uint16_t> addr =
@@ -354,8 +356,8 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage
   const BDE& nodesData =
     getString(getDictionary(dict, DHTResponseMessage::R),
               DHTFindNodeReplyMessage::NODES);
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
-                                                          nodesData.s().size());
+  std::vector<SharedHandle<DHTNode> > nodes =
+    extractNodes(nodesData.uc(), nodesData.s().size());
   return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
 }
 
@@ -383,18 +385,19 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes
   const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
   const BDE& nodesData = getString(rDict,
                                    DHTGetPeersReplyMessage::NODES);
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
-                                                          nodesData.s().size());
+  std::vector<SharedHandle<DHTNode> > nodes =
+    extractNodes(nodesData.uc(), nodesData.s().size());
   const BDE& token = getString(rDict, DHTGetPeersReplyMessage::TOKEN);
   return createGetPeersReplyMessage(remoteNode, nodes, token.s(),
                                     transactionID);
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                                                  const std::string& token,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createGetPeersReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+ const std::string& token,
+ const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersReplyMessage> m
     (new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
@@ -412,14 +415,14 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
   const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
   const BDE& valuesList = getList(rDict,
                                   DHTGetPeersReplyMessage::VALUES);
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   for(BDE::List::const_iterator i = valuesList.listBegin();
       i != valuesList.listEnd(); ++i) {
     const BDE& data = *i;
     if(data.isString() && data.s().size() == 6) {
       std::pair<std::string, uint16_t> addr =
         bittorrent::unpackcompact(data.uc());
-      PeerHandle peer(new Peer(addr.first, addr.second));
+      SharedHandle<Peer> peer(new Peer(addr.first, addr.second));
       peers.push_back(peer);
     }
   }
@@ -429,10 +432,11 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<Peer> >& values,
-                                                  const std::string& token,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createGetPeersReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<Peer> >& values,
+ const std::string& token,
+ const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersReplyMessage> m(new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
   m->setValues(values);
diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h
index 5c026ca9..ce29af08 100644
--- a/src/DHTMessageFactoryImpl.h
+++ b/src/DHTMessageFactoryImpl.h
@@ -72,7 +72,8 @@ private:
 
   void validatePort(const BDE& i) const;
 
-  std::deque<SharedHandle<DHTNode> > extractNodes(const unsigned char* src, size_t length);
+  std::vector<SharedHandle<DHTNode> >
+  extractNodes(const unsigned char* src, size_t length);
 
   void setCommonProperty(const SharedHandle<DHTAbstractMessage>& m);
 
@@ -111,9 +112,10 @@ public:
 
 
   virtual SharedHandle<DHTMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& transactionID);
+  createFindNodeReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
   createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@@ -121,10 +123,11 @@ public:
                         const std::string& transactionID = A2STR::NIL);
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& token,
-                             const std::string& transactionID);
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& token,
+   const std::string& transactionID);
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
@@ -132,10 +135,11 @@ public:
                                       const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<Peer> >& peers,
-                             const std::string& token,
-                             const std::string& transactionID);
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<Peer> >& peers,
+   const std::string& token,
+   const std::string& transactionID);
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,
diff --git a/src/DHTNodeLookupTask.cc b/src/DHTNodeLookupTask.cc
index 33802457..ae816c90 100644
--- a/src/DHTNodeLookupTask.cc
+++ b/src/DHTNodeLookupTask.cc
@@ -39,7 +39,6 @@
 #include "DHTNodeLookupEntry.h"
 #include "LogFactory.h"
 #include "util.h"
-#include <cassert>
 
 namespace aria2 {
 
@@ -48,13 +47,14 @@ DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID):
 {}
 
 void
-DHTNodeLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const SharedHandle<DHTMessage>& message)
+DHTNodeLookupTask::getNodesFromMessage
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const SharedHandle<DHTMessage>& message)
 {
   SharedHandle<DHTFindNodeReplyMessage> m
     (dynamic_pointer_cast<DHTFindNodeReplyMessage>(message));
   if(!m.isNull()) {
-    const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
+    const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
     nodes.insert(nodes.end(), knodes.begin(), knodes.end());
   }
 }
diff --git a/src/DHTNodeLookupTask.h b/src/DHTNodeLookupTask.h
index 988b5046..e0f59edf 100644
--- a/src/DHTNodeLookupTask.h
+++ b/src/DHTNodeLookupTask.h
@@ -43,7 +43,7 @@ class DHTNodeLookupTask:public DHTAbstractNodeLookupTask {
 public:
   DHTNodeLookupTask(const unsigned char* targetNodeID);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message);
 
   virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode);
diff --git a/src/DHTPeerAnnounceEntry.cc b/src/DHTPeerAnnounceEntry.cc
index 5710982c..6620c05b 100644
--- a/src/DHTPeerAnnounceEntry.cc
+++ b/src/DHTPeerAnnounceEntry.cc
@@ -50,7 +50,8 @@ DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {}
 
 void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry)
 {
-  std::deque<PeerAddrEntry>::iterator i = std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
+  std::vector<PeerAddrEntry>::iterator i =
+    std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
   if(i == _peerAddrEntries.end()) {
     _peerAddrEntries.push_back(entry);
   } else {
@@ -91,9 +92,10 @@ bool DHTPeerAnnounceEntry::empty() const
   return _peerAddrEntries.empty();
 }
 
-void DHTPeerAnnounceEntry::getPeers(std::deque<SharedHandle<Peer> >& peers) const
+void DHTPeerAnnounceEntry::getPeers
+(std::vector<SharedHandle<Peer> >& peers) const
 {
-  for(std::deque<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
+  for(std::vector<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
       i != _peerAddrEntries.end(); ++i) {
     SharedHandle<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort()));
     peers.push_back(peer);
diff --git a/src/DHTPeerAnnounceEntry.h b/src/DHTPeerAnnounceEntry.h
index fee6197a..f957ba59 100644
--- a/src/DHTPeerAnnounceEntry.h
+++ b/src/DHTPeerAnnounceEntry.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "DHTConstants.h"
@@ -52,7 +52,7 @@ class DHTPeerAnnounceEntry {
 private:
   unsigned char _infoHash[DHT_ID_LENGTH];
 
-  std::deque<PeerAddrEntry> _peerAddrEntries;
+  std::vector<PeerAddrEntry> _peerAddrEntries;
 
   Time _lastUpdated;
 public:
@@ -66,7 +66,7 @@ public:
 
   size_t countPeerAddrEntry() const;
 
-  const std::deque<PeerAddrEntry>& getPeerAddrEntries() const
+  const std::vector<PeerAddrEntry>& getPeerAddrEntries() const
   {
     return _peerAddrEntries;
   }
@@ -87,7 +87,7 @@ public:
     return _infoHash;
   }
 
-  void getPeers(std::deque<SharedHandle<Peer> >& peers) const;
+  void getPeers(std::vector<SharedHandle<Peer> >& peers) const;
 
 };
 
diff --git a/src/DHTPeerAnnounceStorage.cc b/src/DHTPeerAnnounceStorage.cc
index e8153869..b6390c44 100644
--- a/src/DHTPeerAnnounceStorage.cc
+++ b/src/DHTPeerAnnounceStorage.cc
@@ -101,7 +101,7 @@ bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const
     std::binary_search(_entries.begin(), _entries.end(), entry, InfoHashLess());
 }
 
-void DHTPeerAnnounceStorage::getPeers(std::deque<SharedHandle<Peer> >& peers,
+void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers,
                                       const unsigned char* infoHash)
 {
   SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));
diff --git a/src/DHTPeerAnnounceStorage.h b/src/DHTPeerAnnounceStorage.h
index fec036dc..29d5ecba 100644
--- a/src/DHTPeerAnnounceStorage.h
+++ b/src/DHTPeerAnnounceStorage.h
@@ -36,8 +36,11 @@
 #define _D_DHT_PEER_ANNOUNCE_STORAGE_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <deque>
+#include <vector>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -68,7 +71,7 @@ public:
 
   bool contains(const unsigned char* infoHash) const;
 
-  void getPeers(std::deque<SharedHandle<Peer> >& peers,
+  void getPeers(std::vector<SharedHandle<Peer> >& peers,
                 const unsigned char* infoHash);
 
   // drop peer announce entry which is not updated in the past
diff --git a/src/DHTPeerLookupTask.cc b/src/DHTPeerLookupTask.cc
index 0fa6402c..c7064bad 100644
--- a/src/DHTPeerLookupTask.cc
+++ b/src/DHTPeerLookupTask.cc
@@ -54,12 +54,14 @@ DHTPeerLookupTask::DHTPeerLookupTask
   DHTAbstractNodeLookupTask(bittorrent::getInfoHash(downloadContext)) {}
 
 void
-DHTPeerLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const SharedHandle<DHTMessage>& message)
+DHTPeerLookupTask::getNodesFromMessage
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const SharedHandle<DHTMessage>& message)
 {
-  SharedHandle<DHTGetPeersReplyMessage> m(dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
+  SharedHandle<DHTGetPeersReplyMessage> m
+    (dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
   if(!m.isNull()) {
-    const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
+    const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
     nodes.insert(nodes.end(), knodes.begin(), knodes.end());
   }
 }
diff --git a/src/DHTPeerLookupTask.h b/src/DHTPeerLookupTask.h
index bec9d322..c80c0e67 100644
--- a/src/DHTPeerLookupTask.h
+++ b/src/DHTPeerLookupTask.h
@@ -49,7 +49,7 @@ class DHTPeerLookupTask:public DHTAbstractNodeLookupTask {
 private:
   std::map<std::string, std::string> _tokenStorage;
 
-  std::deque<SharedHandle<Peer> > _peers;
+  std::vector<SharedHandle<Peer> > _peers;
 
   SharedHandle<PeerStorage> _peerStorage;
 
@@ -57,7 +57,7 @@ private:
 public:
   DHTPeerLookupTask(const SharedHandle<DownloadContext>& downloadContext);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message);
   
   virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message);
@@ -66,7 +66,7 @@ public:
 
   virtual void onFinish();
   
-  const std::deque<SharedHandle<Peer> >& getPeers() const
+  const std::vector<SharedHandle<Peer> >& getPeers() const
   {
     return _peers;
   }
diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc
index 20ed75d7..f996698e 100644
--- a/src/DHTRoutingTable.cc
+++ b/src/DHTRoutingTable.cc
@@ -126,8 +126,9 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
   return false;
 }
 
-void DHTRoutingTable::getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const unsigned char* key) const
+void DHTRoutingTable::getClosestKNodes
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const unsigned char* key) const
 {
   BNode::findClosestKNodes(nodes, _root, key);
 }
@@ -177,7 +178,8 @@ void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node)
   getBucketFor(node)->moveToTail(node);
 }
 
-void DHTRoutingTable::getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const
+void DHTRoutingTable::getBuckets
+(std::vector<SharedHandle<DHTBucket> >& buckets) const
 {
   BNode::enumerateBucket(buckets, _root);
 }
diff --git a/src/DHTRoutingTable.h b/src/DHTRoutingTable.h
index fc7d94d3..e9c4ae73 100644
--- a/src/DHTRoutingTable.h
+++ b/src/DHTRoutingTable.h
@@ -36,9 +36,11 @@
 #define _D_DHT_ROUTING_TABLE_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
-#include <deque>
+#include <vector>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -73,7 +75,7 @@ public:
 
   bool addGoodNode(const SharedHandle<DHTNode>& node);
 
-  void getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+  void getClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                         const unsigned char* key) const;
 
   size_t countBucket() const;
@@ -92,7 +94,7 @@ public:
 
   SharedHandle<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
   
-  void getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const;
+  void getBuckets(std::vector<SharedHandle<DHTBucket> >& buckets) const;
 
   void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc
index 51691b82..fe52e911 100644
--- a/src/DHTRoutingTableDeserializer.cc
+++ b/src/DHTRoutingTableDeserializer.cc
@@ -157,7 +157,7 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
   readBytes(buf, buf.size(), in, 4);
   CHECK_STREAM(in, 4);
 
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   // nodes
   for(size_t i = 0; i < numNodes; ++i) {
     // Currently, only IPv4 addresses are supported.
diff --git a/src/DHTRoutingTableDeserializer.h b/src/DHTRoutingTableDeserializer.h
index 4c9a67be..b0ceae07 100644
--- a/src/DHTRoutingTableDeserializer.h
+++ b/src/DHTRoutingTableDeserializer.h
@@ -36,10 +36,12 @@
 #define _D_DHT_ROUTING_TABLE_DESERIALIZER_H_
 
 #include "common.h"
+
+#include <vector>
+#include <iosfwd>
+
 #include "SharedHandle.h"
 #include "TimeA2.h"
-#include <deque>
-#include <iosfwd>
 
 namespace aria2 {
 
@@ -49,7 +51,7 @@ class DHTRoutingTableDeserializer {
 private:
   SharedHandle<DHTNode> _localNode;
 
-  std::deque<SharedHandle<DHTNode> > _nodes;
+  std::vector<SharedHandle<DHTNode> > _nodes;
 
   Time _serializedTime;
 public:
@@ -62,7 +64,7 @@ public:
     return _localNode;
   }
 
-  const std::deque<SharedHandle<DHTNode> >& getNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getNodes() const
   {
     return _nodes;
   }
diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc
index 61b2ea83..fcd569ce 100644
--- a/src/DHTRoutingTableSerializer.cc
+++ b/src/DHTRoutingTableSerializer.cc
@@ -53,12 +53,14 @@ DHTRoutingTableSerializer::DHTRoutingTableSerializer() {}
 
 DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {}
 
-void DHTRoutingTableSerializer::setLocalNode(const SharedHandle<DHTNode>& localNode)
+void DHTRoutingTableSerializer::setLocalNode
+(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
 
-void DHTRoutingTableSerializer::setNodes(const std::deque<SharedHandle<DHTNode> >& nodes)
+void DHTRoutingTableSerializer::setNodes
+(const std::vector<SharedHandle<DHTNode> >& nodes)
 {
   _nodes = nodes;
 }
@@ -99,7 +101,8 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
   o.write(zero, 4);
 
   // nodes
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) {
+  for(std::vector<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin();
+      i != _nodes.end(); ++i) {
     const SharedHandle<DHTNode>& node = *i;
     // Currently, only IPv4 address and IPv4-mapped address are saved.
     // 6bytes: write IP address + port in Compact IP-address/port info form.
diff --git a/src/DHTRoutingTableSerializer.h b/src/DHTRoutingTableSerializer.h
index a0b60f91..bcc44d61 100644
--- a/src/DHTRoutingTableSerializer.h
+++ b/src/DHTRoutingTableSerializer.h
@@ -36,10 +36,12 @@
 #define _D_DHT_ROUTING_TABLE_SERIALIZER_H_
 
 #include "common.h"
-#include "SharedHandle.h"
-#include <deque>
+
+#include <vector>
 #include <iosfwd>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class DHTNode;
@@ -48,7 +50,7 @@ class DHTRoutingTableSerializer {
 private:
   SharedHandle<DHTNode> _localNode;
 
-  std::deque<SharedHandle<DHTNode> > _nodes;
+  std::vector<SharedHandle<DHTNode> > _nodes;
 public:
   DHTRoutingTableSerializer();
 
@@ -56,7 +58,7 @@ public:
 
   void setLocalNode(const SharedHandle<DHTNode>& localNode);
 
-  void setNodes(const std::deque<SharedHandle<DHTNode> >& nodes);
+  void setNodes(const std::vector<SharedHandle<DHTNode> >& nodes);
 
   void serialize(std::ostream& o);
 };
diff --git a/src/DHTSetup.cc b/src/DHTSetup.cc
index 788b7a2f..038c4d92 100644
--- a/src/DHTSetup.cc
+++ b/src/DHTSetup.cc
@@ -80,13 +80,13 @@ DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {}
 
 DHTSetup::~DHTSetup() {}
 
-void DHTSetup::setup(std::deque<Command*>& commands,
+void DHTSetup::setup(std::vector<Command*>& commands,
                      DownloadEngine* e, const Option* option)
 {
   if(_initialized) {
     return;
   }
-  std::deque<Command*> tempCommands;
+  std::vector<Command*> tempCommands;
   try {
     // load routing table and localnode id here
 
@@ -179,8 +179,10 @@ void DHTSetup::setup(std::deque<Command*>& commands,
     DHTRegistry::_messageFactory = factory;
 
     // add deserialized nodes to routing table
-    const std::deque<SharedHandle<DHTNode> >& desnodes = deserializer.getNodes();
-    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) {
+    const std::vector<SharedHandle<DHTNode> >& desnodes =
+      deserializer.getNodes();
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
+          desnodes.begin(); i != desnodes.end(); ++i) {
       routingTable->addNode(*i);
     }
     if(!desnodes.empty() && deserializer.getSerializedTime().elapsed(DHT_BUCKET_REFRESH_INTERVAL)) {
@@ -194,7 +196,7 @@ void DHTSetup::setup(std::deque<Command*>& commands,
       {
         std::pair<std::string, uint16_t> addr(option->get(PREF_DHT_ENTRY_POINT_HOST),
                                               option->getAsInt(PREF_DHT_ENTRY_POINT_PORT));
-        std::deque<std::pair<std::string, uint16_t> > entryPoints;
+        std::vector<std::pair<std::string, uint16_t> > entryPoints;
         entryPoints.push_back(addr);
         DHTEntryPointNameResolveCommand* command =
           new DHTEntryPointNameResolveCommand(e->newCUID(), e, entryPoints);
diff --git a/src/DHTSetup.h b/src/DHTSetup.h
index 6bddaec5..a1e517e2 100644
--- a/src/DHTSetup.h
+++ b/src/DHTSetup.h
@@ -36,7 +36,7 @@
 #define _D_DHT_SETUP_H_
 
 #include "common.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 class Logger;
@@ -55,7 +55,7 @@ public:
 
   ~DHTSetup();
 
-  void setup(std::deque<Command*>& commands,
+  void setup(std::vector<Command*>& commands,
              DownloadEngine* e, const Option* option);
 
   static bool initialized();
diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc
index 3f2465d5..c8dcaa9c 100644
--- a/src/DefaultBtAnnounce.cc
+++ b/src/DefaultBtAnnounce.cc
@@ -274,7 +274,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
     logger->info(MSG_NO_PEER_LIST_RECEIVED);
   } else {
     if(!btRuntime->isHalt() && btRuntime->lessThanMinPeers()) {
-      std::deque<SharedHandle<Peer> > peers;
+      std::vector<SharedHandle<Peer> > peers;
       PeerListProcessor().extractPeer(peerData, std::back_inserter(peers));
       peerStorage->addPeer(peers);
     }
diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc
index 83ec725c..6de0ea4f 100644
--- a/src/DefaultBtInteractive.cc
+++ b/src/DefaultBtInteractive.cc
@@ -35,6 +35,7 @@
 #include "DefaultBtInteractive.h"
 
 #include <cstring>
+#include <vector>
 
 #include "prefs.h"
 #include "message.h"
@@ -226,7 +227,7 @@ void DefaultBtInteractive::decideChoking() {
 }
 
 void DefaultBtInteractive::checkHave() {
-  std::deque<size_t> indexes;
+  std::vector<size_t> indexes;
   _pieceStorage->getAdvertisedPieceIndexes(indexes, cuid, haveCheckPoint);
   haveCheckPoint.reset();
   if(indexes.size() >= 20) {
@@ -236,7 +237,7 @@ void DefaultBtInteractive::checkHave() {
       dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
     }
   } else {
-    for(std::deque<size_t>::iterator itr = indexes.begin();
+    for(std::vector<size_t>::iterator itr = indexes.begin();
         itr != indexes.end(); ++itr) {
       dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
     }
@@ -326,7 +327,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
 
     if(peer->peerChoking()) {
       if(peer->isFastExtensionEnabled()) {
-        std::deque<size_t> excludedIndexes;
+        std::vector<size_t> excludedIndexes;
         btRequestFactory->getTargetPieceIndexes(excludedIndexes);
         while(numMissingBlock < maxMissingBlock) {
           SharedHandle<Piece> piece =
@@ -341,7 +342,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
         }
       }
     } else {
-      std::deque<size_t> excludedIndexes;
+      std::vector<size_t> excludedIndexes;
       btRequestFactory->getTargetPieceIndexes(excludedIndexes);
       while(numMissingBlock < maxMissingBlock) {
         SharedHandle<Piece> piece =
@@ -364,7 +365,7 @@ void DefaultBtInteractive::addRequests() {
     _maxOutstandingRequest <= dispatcher->countOutstandingRequest() ?
     0 : _maxOutstandingRequest-dispatcher->countOutstandingRequest();
   if(reqNumToCreate > 0) {
-    BtMessages requests;
+    std::vector<SharedHandle<BtMessage> > requests;
     if(_pieceStorage->isEndGame()) {
       btRequestFactory->createRequestMessagesOnEndGame(requests,reqNumToCreate);
     } else {
@@ -437,7 +438,7 @@ void DefaultBtInteractive::addPeerExchangeMessage()
   if(_pexCheckPoint.elapsed(UTPexExtensionMessage::DEFAULT_INTERVAL)) {
     UTPexExtensionMessageHandle m
       (new UTPexExtensionMessage(peer->getExtensionMessageID("ut_pex")));
-    const Peers& peers = _peerStorage->getPeers();
+    const std::deque<SharedHandle<Peer> >& peers = _peerStorage->getPeers();
     {
       for(std::deque<SharedHandle<Peer> >::const_iterator i =
             peers.begin(); i != peers.end() && !m->freshPeersAreFull(); ++i) {
@@ -474,7 +475,7 @@ void DefaultBtInteractive::doInteractionProcessing() {
        _downloadContext->getTotalLength() > 0) {
       size_t num = _utMetadataRequestTracker->avail();
       if(num > 0) {
-        std::deque<SharedHandle<BtMessage> > requests;
+        std::vector<SharedHandle<BtMessage> > requests;
         _utMetadataRequestFactory->create(requests, num, _pieceStorage);
         dispatcher->addMessageToQueue(requests);
       }
diff --git a/src/DefaultBtMessageDispatcher.cc b/src/DefaultBtMessageDispatcher.cc
index d3e96244..58aff2bd 100644
--- a/src/DefaultBtMessageDispatcher.cc
+++ b/src/DefaultBtMessageDispatcher.cc
@@ -75,15 +75,17 @@ void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessageHandle& btMess
   messageQueue.push_back(btMessage);
 }
 
-void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessages& btMessages)
+void DefaultBtMessageDispatcher::addMessageToQueue
+(const std::vector<SharedHandle<BtMessage> >& btMessages)
 {
-  for(BtMessages::const_iterator itr = btMessages.begin(); itr != btMessages.end(); itr++) {
+  for(std::vector<SharedHandle<BtMessage> >::const_iterator itr =
+        btMessages.begin(); itr != btMessages.end(); ++itr) {
     addMessageToQueue(*itr);
   }
 }
 
 void DefaultBtMessageDispatcher::sendMessages() {
-  BtMessages tempQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue;
   while(!messageQueue.empty()) {
     BtMessageHandle msg = messageQueue.front();
     messageQueue.pop_front();
@@ -121,7 +123,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
 {
   BtCancelSendingPieceEvent event(index, begin, length);
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
 
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onCancelSendingPieceEvent, event);
@@ -129,7 +132,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
 
 // Cancel sending piece message to peer.
 // TODO Is this method really necessary?
-void DefaultBtMessageDispatcher::doCancelSendingPieceAction(const PieceHandle& piece)
+void DefaultBtMessageDispatcher::doCancelSendingPieceAction
+(const SharedHandle<Piece>& piece)
 {
 }
 
@@ -158,7 +162,8 @@ public:
 };
 
 // localhost cancels outstanding download requests to the peer.
-void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHandle& piece) {
+void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
+(const SharedHandle<Piece>& piece) {
   RequestSlot rs(piece->getIndex(), 0, 0, 0);
   std::deque<RequestSlot>::iterator first =
     std::lower_bound(requestSlots.begin(), requestSlots.end(), rs);
@@ -172,7 +177,8 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHand
 
   BtAbortOutstandingRequestEvent event(piece);
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onAbortOutstandingRequestEvent, event);
 }
@@ -238,7 +244,8 @@ void DefaultBtMessageDispatcher::doChokingAction()
 {
   BtChokingEvent event;
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onChokingEvent, event);
 }
@@ -351,11 +358,6 @@ bool DefaultBtMessageDispatcher::isSendingInProgress()
   }
 }
 
-size_t DefaultBtMessageDispatcher::countOutstandingRequest()
-{
-  return requestSlots.size();
-}
-
 class BlockIndexLess {
 public:
   bool operator()(const RequestSlot& lhs, const RequestSlot& rhs) const
diff --git a/src/DefaultBtMessageDispatcher.h b/src/DefaultBtMessageDispatcher.h
index 7805c143..861f8b1e 100644
--- a/src/DefaultBtMessageDispatcher.h
+++ b/src/DefaultBtMessageDispatcher.h
@@ -36,6 +36,9 @@
 #define _D_DEFAULT_BT_MESSAGE_DISPATCHER_H_
 
 #include "BtMessageDispatcher.h"
+
+#include <deque>
+
 #include "a2time.h"
 
 namespace aria2 {
@@ -70,7 +73,8 @@ public:
   
   virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
 
-  virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages);
+  virtual void addMessageToQueue
+  (const std::vector<SharedHandle<BtMessage> >& btMessages);
 
   virtual void sendMessages();
 
@@ -92,8 +96,11 @@ public:
     return messageQueue.size();
   }
 
-  virtual size_t countOutstandingRequest();
-
+  virtual size_t countOutstandingRequest()
+  {
+    return requestSlots.size();
+  }
+  
   virtual bool isOutstandingRequest(size_t index, size_t blockIndex);
 
   virtual RequestSlot getOutstandingRequest(size_t index, uint32_t begin, size_t length);
@@ -109,7 +116,7 @@ public:
     return messageQueue;
   }
 
-  const RequestSlots& getRequestSlots() const
+  const std::deque<RequestSlot>& getRequestSlots() const
   {
     return requestSlots;
   }
diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc
index 1635979f..e59be8b2 100644
--- a/src/DefaultBtMessageFactory.cc
+++ b/src/DefaultBtMessageFactory.cc
@@ -278,7 +278,8 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
 }
 
 BtMessageHandle
-DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, size_t blockIndex)
+DefaultBtMessageFactory::createRequestMessage
+(const SharedHandle<Piece>& piece, size_t blockIndex)
 {
   BtRequestMessageHandle msg
     (new BtRequestMessage(piece->getIndex(),
diff --git a/src/DefaultBtMessageReceiver.cc b/src/DefaultBtMessageReceiver.cc
index 88c8a121..19cca8e9 100644
--- a/src/DefaultBtMessageReceiver.cc
+++ b/src/DefaultBtMessageReceiver.cc
@@ -85,8 +85,7 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
     return SharedHandle<BtHandshakeMessage>();
   }
   SharedHandle<BtHandshakeMessage> msg = messageFactory->createHandshakeMessage(data, dataLength);
-  std::deque<std::string> errors;
-  msg->validate(errors);
+  msg->validate();
   return msg;
 }
 
@@ -111,13 +110,8 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
     return SharedHandle<BtMessage>();
   }
   BtMessageHandle msg = messageFactory->createBtMessage(data, dataLength);
-  std::deque<std::string> errors;
-  if(msg->validate(errors)) {
-    return msg;
-  } else {
-    // TODO throw exception here based on errors;
-    return SharedHandle<BtMessage>();
-  }
+  msg->validate();
+  return msg;
 }
 
 void DefaultBtMessageReceiver::setDownloadContext
diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc
index 60558cc0..ca872546 100644
--- a/src/DefaultBtProgressInfoFile.cc
+++ b/src/DefaultBtProgressInfoFile.cc
@@ -179,9 +179,10 @@ void DefaultBtProgressInfoFile::save()
     uint32_t numInFlightPieceNL = htonl(_pieceStorage->countInFlightPiece());
     o.write(reinterpret_cast<const char*>(&numInFlightPieceNL),
             sizeof(numInFlightPieceNL));
-    Pieces inFlightPieces;
+    std::vector<SharedHandle<Piece> > inFlightPieces;
     _pieceStorage->getInFlightPieces(inFlightPieces);
-    for(Pieces::const_iterator itr = inFlightPieces.begin();
+    for(std::vector<SharedHandle<Piece> >::const_iterator itr =
+          inFlightPieces.begin();
         itr != inFlightPieces.end(); ++itr) {
       uint32_t indexNL = htonl((*itr)->getIndex());
       o.write(reinterpret_cast<const char*>(&indexNL), sizeof(indexNL));
@@ -343,7 +344,7 @@ void DefaultBtProgressInfoFile::load()
     if(version >= 1) {
       numInFlightPiece = ntohl(numInFlightPiece);
     }
-    Pieces inFlightPieces;
+    std::vector<SharedHandle<Piece> > inFlightPieces;
     while(numInFlightPiece--) {
       uint32_t index;
       in.read(reinterpret_cast<char*>(&index), sizeof(index));
@@ -365,7 +366,7 @@ void DefaultBtProgressInfoFile::load()
         throw DL_ABORT_EX
           (StringFormat("piece length out of range: %u", length).str());
       }
-      PieceHandle piece(new Piece(index, length));
+      SharedHandle<Piece> piece(new Piece(index, length));
       uint32_t bitfieldLength;
       in.read(reinterpret_cast<char*>(&bitfieldLength),
               sizeof(bitfieldLength));
diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc
index 3e55ddb2..e2285380 100644
--- a/src/DefaultBtRequestFactory.cc
+++ b/src/DefaultBtRequestFactory.cc
@@ -66,7 +66,7 @@ DefaultBtRequestFactory::~DefaultBtRequestFactory()
   }
 }
 
-void DefaultBtRequestFactory::addTargetPiece(const PieceHandle& piece)
+void DefaultBtRequestFactory::addTargetPiece(const SharedHandle<Piece>& piece)
 {
   pieces.push_back(piece);
 }
@@ -95,7 +95,7 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
                pieces.end());
 }
 
-void DefaultBtRequestFactory::removeTargetPiece(const PieceHandle& piece) {
+void DefaultBtRequestFactory::removeTargetPiece(const SharedHandle<Piece>& piece) {
   pieces.erase(std::remove(pieces.begin(), pieces.end(), piece),
                pieces.end());
   dispatcher->doAbortOutstandingRequestAction(piece);
@@ -142,7 +142,8 @@ void DefaultBtRequestFactory::doChokedAction()
 }
 
 void DefaultBtRequestFactory::removeAllTargetPiece() {
-  for(Pieces::iterator itr = pieces.begin(); itr != pieces.end(); ++itr) {
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
+      itr != pieces.end(); ++itr) {
     dispatcher->doAbortOutstandingRequestAction(*itr);
     _pieceStorage->cancelPiece(*itr);
   }
@@ -150,7 +151,7 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
 }
 
 void DefaultBtRequestFactory::createRequestMessages
-(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
 {
   if(requests.size() >= max) {
     return;
@@ -158,7 +159,7 @@ void DefaultBtRequestFactory::createRequestMessages
   size_t getnum = max-requests.size();
   std::vector<size_t> blockIndexes;
   blockIndexes.reserve(getnum);
-  for(Pieces::iterator itr = pieces.begin();
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
       itr != pieces.end() && getnum; ++itr) {
     SharedHandle<Piece>& piece = *itr;
     if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) {
@@ -181,17 +182,17 @@ void DefaultBtRequestFactory::createRequestMessages
 }
 
 void DefaultBtRequestFactory::createRequestMessagesOnEndGame
-(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
 {
-  for(Pieces::iterator itr = pieces.begin();
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
       itr != pieces.end() && requests.size() < max; ++itr) {
-    PieceHandle& piece = *itr;
+    SharedHandle<Piece>& piece = *itr;
     const size_t mislen = piece->getBitfieldLength();
     array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
 
     piece->getAllMissingBlockIndexes(misbitfield, mislen);
 
-    std::deque<size_t> missingBlockIndexes;
+    std::vector<size_t> missingBlockIndexes;
     size_t blockIndex = 0;
     for(size_t i = 0; i < mislen; ++i) {
       unsigned char bits = misbitfield[i];
@@ -204,7 +205,7 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame
     }
     std::random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end(),
                         *(SimpleRandomizer::getInstance().get()));
-    for(std::deque<size_t>::const_iterator bitr = missingBlockIndexes.begin();
+    for(std::vector<size_t>::const_iterator bitr = missingBlockIndexes.begin();
         bitr != missingBlockIndexes.end() && requests.size() < max; bitr++) {
       const size_t& blockIndex = *bitr;
       if(!dispatcher->isOutstandingRequest(piece->getIndex(),
@@ -247,7 +248,7 @@ size_t DefaultBtRequestFactory::countMissingBlock()
 }
 
 void DefaultBtRequestFactory::getTargetPieceIndexes
-(std::deque<size_t>& indexes) const
+(std::vector<size_t>& indexes) const
 {
   std::transform(pieces.begin(), pieces.end(), std::back_inserter(indexes),
                  mem_fun_sh(&Piece::getIndex));
diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h
index 3df8146d..7be2bf01 100644
--- a/src/DefaultBtRequestFactory.h
+++ b/src/DefaultBtRequestFactory.h
@@ -37,6 +37,8 @@
 
 #include "BtRequestFactory.h"
 
+#include <deque>
+
 namespace aria2 {
 
 class PieceStorage;
@@ -77,12 +79,12 @@ public:
   virtual void doChokedAction();
 
   virtual void createRequestMessages
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
 
   virtual void createRequestMessagesOnEndGame
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
 
-  virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const;
+  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
 
   std::deque<SharedHandle<Piece> >& getTargetPieces()
   {
diff --git a/src/DefaultExtensionMessageFactory.cc b/src/DefaultExtensionMessageFactory.cc
index d9f87aef..6ce8de84 100644
--- a/src/DefaultExtensionMessageFactory.cc
+++ b/src/DefaultExtensionMessageFactory.cc
@@ -60,7 +60,7 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory():
   _logger(LogFactory::getInstance()) {}
 
 DefaultExtensionMessageFactory::DefaultExtensionMessageFactory
-(const PeerHandle& peer,
+(const SharedHandle<Peer>& peer,
  const SharedHandle<ExtensionMessageRegistry>& registry):
   _peer(peer),
   _registry(registry),
@@ -163,7 +163,7 @@ void DefaultExtensionMessageFactory::setPeerStorage
   _peerStorage = peerStorage;
 }
 
-void DefaultExtensionMessageFactory::setPeer(const PeerHandle& peer)
+void DefaultExtensionMessageFactory::setPeer(const SharedHandle<Peer>& peer)
 {
   _peer = peer;
 }
diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc
index 95868501..fc1a3314 100644
--- a/src/DefaultPeerStorage.cc
+++ b/src/DefaultPeerStorage.cc
@@ -68,19 +68,20 @@ DefaultPeerStorage::~DefaultPeerStorage()
 
 class FindIdenticalPeer {
 private:
-  PeerHandle _peer;
+  SharedHandle<Peer> _peer;
 public:
-  FindIdenticalPeer(const PeerHandle& peer):_peer(peer) {}
+  FindIdenticalPeer(const SharedHandle<Peer>& peer):_peer(peer) {}
 
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return (_peer == peer) ||
       ((_peer->ipaddr == peer->ipaddr) && (_peer->port == peer->port));
   }
 };
 
-bool DefaultPeerStorage::isPeerAlreadyAdded(const PeerHandle& peer)
+bool DefaultPeerStorage::isPeerAlreadyAdded(const SharedHandle<Peer>& peer)
 {
-  return std::find_if(peers.begin(), peers.end(), FindIdenticalPeer(peer)) != peers.end();
+  return std::find_if(peers.begin(), peers.end(),
+                      FindIdenticalPeer(peer)) != peers.end();
 }
 
 static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
@@ -93,7 +94,7 @@ static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
     btRuntime->getMaxPeers()+(btRuntime->getMaxPeers() >> 2);
 }
 
-bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
+bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer) {
   if(isPeerAlreadyAdded(peer)) {
     if(logger->debug()) {
       logger->debug("Adding %s:%u is rejected because it has been already"
@@ -109,10 +110,11 @@ bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
   return true;
 }
 
-void DefaultPeerStorage::addPeer(const Peers& peers) {
-  for(Peers::const_iterator itr = peers.begin();
+void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers)
+{
+  for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin();
       itr != peers.end(); ++itr) {
-    const PeerHandle& peer = *itr;
+    const SharedHandle<Peer>& peer = *itr;
     if(addPeer(peer)) {
       if(logger->debug()) {
         logger->debug(MSG_ADDING_PEER, peer->ipaddr.c_str(), peer->port);
@@ -121,20 +123,21 @@ void DefaultPeerStorage::addPeer(const Peers& peers) {
   }  
 }
 
-const Peers& DefaultPeerStorage::getPeers() {
+const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getPeers()
+{
   return peers;
 }
 
 class FindFinePeer {
 public:
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return peer->unused() && peer->isGood();
   }
 };
 
-PeerHandle DefaultPeerStorage::getUnusedPeer() {
-  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
-                                           FindFinePeer());
+SharedHandle<Peer> DefaultPeerStorage::getUnusedPeer() {
+  std::deque<SharedHandle<Peer> >::const_iterator itr =
+    std::find_if(peers.begin(), peers.end(), FindFinePeer());
   if(itr == peers.end()) {
     return SharedHandle<Peer>();
   } else {
@@ -147,17 +150,18 @@ private:
   std::string ipaddr;
   uint16_t port;
 public:
-  FindPeer(const std::string& ipaddr, uint16_t port):ipaddr(ipaddr), port(port) {}
+  FindPeer(const std::string& ipaddr, uint16_t port):
+    ipaddr(ipaddr), port(port) {}
 
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return ipaddr == peer->ipaddr && port == peer->port;
   }
 };
 
-PeerHandle DefaultPeerStorage::getPeer(const std::string& ipaddr,
-                                       uint16_t port) const {
-  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
-                                           FindPeer(ipaddr, port));
+SharedHandle<Peer> DefaultPeerStorage::getPeer(const std::string& ipaddr,
+                                               uint16_t port) const {
+  std::deque<SharedHandle<Peer> >::const_iterator itr =
+    std::find_if(peers.begin(), peers.end(), FindPeer(ipaddr, port));
   if(itr == peers.end()) {
     return SharedHandle<Peer>();
   } else {
@@ -175,9 +179,9 @@ bool DefaultPeerStorage::isPeerAvailable() {
 
 class CollectActivePeer {
 private:
-  std::deque<SharedHandle<Peer> >& _activePeers;
+  std::vector<SharedHandle<Peer> >& _activePeers;
 public:
-  CollectActivePeer(std::deque<SharedHandle<Peer> >& activePeers):
+  CollectActivePeer(std::vector<SharedHandle<Peer> >& activePeers):
     _activePeers(activePeers) {}
 
   void operator()(const SharedHandle<Peer>& peer)
@@ -188,7 +192,8 @@ public:
   }
 };
 
-void DefaultPeerStorage::getActivePeers(std::deque<SharedHandle<Peer> >& activePeers)
+void DefaultPeerStorage::getActivePeers
+(std::vector<SharedHandle<Peer> >& activePeers)
 {
   std::for_each(peers.begin(), peers.end(), CollectActivePeer(activePeers));
 }
@@ -214,12 +219,12 @@ TransferStat DefaultPeerStorage::calculateStat()
     }
     _lastTransferStatMapUpdated.reset();
     _peerTransferStatMap.clear();
-    std::deque<SharedHandle<Peer> > activePeers;
+    std::vector<SharedHandle<Peer> > activePeers;
     getActivePeers(activePeers);
     struct timeval now;
     gettimeofday(&now, 0);
-    for(std::deque<SharedHandle<Peer> >::const_iterator i = activePeers.begin();
-        i != activePeers.end(); ++i) {
+    for(std::vector<SharedHandle<Peer> >::const_iterator i =
+          activePeers.begin(); i != activePeers.end(); ++i) {
       TransferStat s;
       s.downloadSpeed = (*i)->calculateDownloadSpeed(now);
       s.uploadSpeed = (*i)->calculateUploadSpeed(now);
@@ -261,10 +266,10 @@ TransferStat DefaultPeerStorage::getTransferStatFor
 }
 
 void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) {
-  Peers temp;
-  for(Peers::reverse_iterator itr = peers.rbegin();
+  std::deque<SharedHandle<Peer> > temp;
+  for(std::deque<SharedHandle<Peer> >::reverse_iterator itr = peers.rbegin();
       itr != peers.rend(); ++itr) {
-    const PeerHandle& p = *itr;
+    const SharedHandle<Peer>& p = *itr;
     if(p->unused() && delSize > 0) {
       onErasingPeer(p);
       delSize--;
@@ -293,9 +298,10 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
   }
 }
 
-void DefaultPeerStorage::returnPeer(const PeerHandle& peer)
+void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer)
 {
-  Peers::iterator itr = std::find(peers.begin(), peers.end(), peer);
+  std::deque<SharedHandle<Peer> >::iterator itr =
+    std::find(peers.begin(), peers.end(), peer);
   if(itr == peers.end()) {
     if(logger->debug()) {
       logger->debug("Cannot find peer %s:%u in PeerStorage.",
@@ -321,7 +327,7 @@ bool DefaultPeerStorage::chokeRoundIntervalElapsed()
 
 void DefaultPeerStorage::executeChoke()
 {
-  std::deque<SharedHandle<Peer> > activePeers;
+  std::vector<SharedHandle<Peer> > activePeers;
   getActivePeers(activePeers);
   if(_pieceStorage->downloadFinished()) {
     return _seederStateChoke->executeChoke(activePeers);
diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h
index 184d6a56..62bb6ad5 100644
--- a/src/DefaultPeerStorage.h
+++ b/src/DefaultPeerStorage.h
@@ -83,13 +83,13 @@ public:
 
   SharedHandle<Peer> getPeer(const std::string& ipaddr, uint16_t port) const;
 
-  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers);
+  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers);
 
   virtual const std::deque<SharedHandle<Peer> >& getPeers();
 
   virtual bool isPeerAvailable();
 
-  virtual void getActivePeers(std::deque<SharedHandle<Peer> >& peers);
+  virtual void getActivePeers(std::vector<SharedHandle<Peer> >& peers);
 
   virtual TransferStat calculateStat();
 
diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc
index df7d62c7..b141528f 100644
--- a/src/DefaultPieceStorage.cc
+++ b/src/DefaultPieceStorage.cc
@@ -105,11 +105,11 @@ bool DefaultPieceStorage::getMissingPieceIndex(size_t& index,
   }
 }
 
-PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index)
 {
   bitfieldMan->setUseBit(index);
 
-  PieceHandle piece = findUsedPiece(index);
+  SharedHandle<Piece> piece = findUsedPiece(index);
   if(piece.isNull()) {
     piece.reset(new Piece(index, bitfieldMan->getBlockLength(index)));
 
@@ -130,9 +130,9 @@ PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
  * Newly instantiated piece is not added to usedPieces.
  * Because it is waste of memory and there is no chance to use them later.
  */
-PieceHandle DefaultPieceStorage::getPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
 {
-  PieceHandle piece;
+  SharedHandle<Piece> piece;
   if(0 <= index && index <= bitfieldMan->getMaxIndex()) {
     piece = findUsedPiece(index);
     if(piece.isNull()) {
@@ -145,7 +145,7 @@ PieceHandle DefaultPieceStorage::getPiece(size_t index)
   return piece;
 }
 
-void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
+void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
 {
   std::deque<SharedHandle<Piece> >::iterator i =
     std::lower_bound(usedPieces.begin(), usedPieces.end(), piece);
@@ -156,7 +156,7 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
   }
 }
 
-PieceHandle DefaultPieceStorage::findUsedPiece(size_t index) const
+SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
 {
   SharedHandle<Piece> p(new Piece());
   p->setIndex(index);
@@ -190,13 +190,14 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
 
 #ifdef ENABLE_BITTORRENT
 
-bool DefaultPieceStorage::hasMissingPiece(const PeerHandle& peer)
+bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
 {
   return bitfieldMan->hasMissingPiece(peer->getBitfield(),
                                       peer->getBitfieldLength());
 }
 
-PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
+SharedHandle<Piece>
+DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
 {
   return getMissingPiece(peer->getBitfield(), peer->getBitfieldLength());
 }
@@ -204,7 +205,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
 void DefaultPieceStorage::createFastIndexBitfield
 (BitfieldMan& bitfield, const SharedHandle<Peer>& peer)
 {
-  for(std::deque<size_t>::const_iterator itr =
+  for(std::vector<size_t>::const_iterator itr =
         peer->getPeerAllowedIndexSet().begin();
       itr != peer->getPeerAllowedIndexSet().end(); ++itr) {
     if(!bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) {
@@ -213,7 +214,7 @@ void DefaultPieceStorage::createFastIndexBitfield
   }
 }
 
-PieceHandle DefaultPieceStorage::getMissingFastPiece
+SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
 (const SharedHandle<Peer>& peer)
 {
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
@@ -227,16 +228,14 @@ PieceHandle DefaultPieceStorage::getMissingFastPiece
 }
 
 static void unsetExcludedIndexes(BitfieldMan& bitfield,
-                                 const std::deque<size_t>& excludedIndexes)
+                                 const std::vector<size_t>& excludedIndexes)
 {
-  for(std::deque<size_t>::const_iterator i = excludedIndexes.begin();
-      i != excludedIndexes.end(); ++i) {
-    bitfield.unsetBit(*i);
-  }
+  std::for_each(excludedIndexes.begin(), excludedIndexes.end(),
+                std::bind1st(std::mem_fun(&BitfieldMan::unsetBit), &bitfield));
 }
 
 SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
                            bitfieldMan->getTotalLength());
@@ -246,7 +245,7 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
 }
 
 SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
     BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
@@ -267,7 +266,7 @@ bool DefaultPieceStorage::hasMissingUnusedPiece()
   return bitfieldMan->getFirstMissingUnusedIndex(index);
 }
 
-PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
+SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece
 (const unsigned char* ignoreBitfield, size_t length)
 {
   size_t index;
@@ -278,7 +277,7 @@ PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
   }
 }
 
-PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::getMissingPiece(size_t index)
 {
   if(hasPiece(index) || isPieceUsed(index)) {
     return SharedHandle<Piece>();
@@ -287,7 +286,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
   }
 }
 
-void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
+void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -319,7 +318,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
 //   size_t deleted = 0;
 //   for(Pieces::iterator itr = usedPieces.begin();
 //       itr != usedPieces.end() && deleted < delNum;) {
-//     PieceHandle& piece = *itr;
+//     SharedHandle<Piece>& piece = *itr;
 //     if(!bitfieldMan->isUseBitSet(piece->getIndex()) &&
 //        piece->countCompleteBlock() <= piece->countBlock()*(fillRate/100.0)) {
 //       logger->info(MSG_DELETING_USED_PIECE,
@@ -335,7 +334,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
 //   return deleted;
 // }
 
-void DefaultPieceStorage::completePiece(const PieceHandle& piece)
+void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -369,7 +368,7 @@ bool DefaultPieceStorage::isSelectiveDownloadingMode()
 }
 
 // not unittested
-void DefaultPieceStorage::cancelPiece(const PieceHandle& piece)
+void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -541,12 +540,13 @@ void DefaultPieceStorage::advertisePiece(int32_t cuid, size_t index)
 }
 
 void
-DefaultPieceStorage::getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+DefaultPieceStorage::getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                                                int32_t myCuid,
                                                const Time& lastCheckTime)
 {
-  for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
-    const Haves::value_type& have = *itr;
+  for(std::deque<HaveEntry>::const_iterator itr = haves.begin();
+      itr != haves.end(); ++itr) {
+    const HaveEntry& have = *itr;
     if(have.getCuid() == myCuid) {
       continue;
     }
@@ -575,7 +575,7 @@ public:
   
 void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
 {
-  Haves::iterator itr =
+  std::deque<HaveEntry>::iterator itr =
     std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
   if(itr != haves.end()) {
     if(logger->debug()) {
@@ -601,7 +601,8 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length)
     }
     size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
     if(r > 0) {
-      PieceHandle p(new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
+      SharedHandle<Piece> p
+        (new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
       
       for(size_t i = 0; i < r; ++i) {
         p->completeBlock(i);
@@ -623,7 +624,8 @@ void DefaultPieceStorage::markPieceMissing(size_t index)
   bitfieldMan->unsetBit(index);
 }
 
-void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
+void DefaultPieceStorage::addInFlightPiece
+(const std::vector<SharedHandle<Piece> >& pieces)
 {
   usedPieces.insert(usedPieces.end(), pieces.begin(), pieces.end());
   std::sort(usedPieces.begin(), usedPieces.end());
@@ -634,7 +636,8 @@ size_t DefaultPieceStorage::countInFlightPiece()
   return usedPieces.size();
 }
 
-void DefaultPieceStorage::getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces)
+void DefaultPieceStorage::getInFlightPieces
+(std::vector<SharedHandle<Piece> >& pieces)
 {
   pieces.insert(pieces.end(), usedPieces.begin(), usedPieces.end());
 }
diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h
index 4f6b32b1..d759758c 100644
--- a/src/DefaultPieceStorage.h
+++ b/src/DefaultPieceStorage.h
@@ -37,6 +37,8 @@
 
 #include "PieceStorage.h"
 
+#include <deque>
+
 namespace aria2 {
 
 class DownloadContext;
@@ -67,8 +69,6 @@ public:
   const Time& getRegisteredTime() const { return registeredTime; }
 };
 
-typedef std::deque<HaveEntry> Haves;
-
 class DefaultPieceStorage : public PieceStorage {
 private:
   SharedHandle<DownloadContext> downloadContext;
@@ -80,7 +80,7 @@ private:
   size_t endGamePieceNum;
   Logger* logger;
   const Option* option;
-  Haves haves;
+  std::deque<HaveEntry> haves;
 
   SharedHandle<PieceStatMan> _pieceStatMan;
 
@@ -126,10 +126,10 @@ public:
   virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer);
 
   virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
   virtual SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
 #endif // ENABLE_BITTORRENT
 
@@ -194,7 +194,7 @@ public:
   virtual void advertisePiece(int32_t cuid, size_t index);
 
   virtual void
-  getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+  getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                             int32_t myCuid, const Time& lastCheckTime);
 
   virtual void removeAdvertisedPiece(time_t elapsed);
@@ -205,11 +205,13 @@ public:
 
   virtual void markPieceMissing(size_t index);
 
-  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
+  virtual void addInFlightPiece
+  (const std::vector<SharedHandle<Piece> >& pieces);
 
   virtual size_t countInFlightPiece();
 
-  virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces);
+  virtual void getInFlightPieces
+  (std::vector<SharedHandle<Piece> >& pieces);
 
   virtual void addPieceStats(size_t index);
 
diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc
index 68e333f1..189eb2e5 100644
--- a/src/DownloadCommand.cc
+++ b/src/DownloadCommand.cc
@@ -67,7 +67,7 @@ namespace aria2 {
 static const size_t BUFSIZE = 16*1024;
 
 DownloadCommand::DownloadCommand(int cuid,
-                                 const RequestHandle& req,
+                                 const SharedHandle<Request>& req,
                                  const SharedHandle<FileEntry>& fileEntry,
                                  RequestGroup* requestGroup,
                                  DownloadEngine* e,
@@ -112,7 +112,7 @@ bool DownloadCommand::executeInternal() {
     return false;
   }
   setReadCheckSocket(socket);
-  SegmentHandle segment = _segments.front();
+  SharedHandle<Segment> segment = _segments.front();
 
   size_t bufSize;
   if(segment->getLength() > 0) {
@@ -279,7 +279,8 @@ bool DownloadCommand::prepareForNextSegment() {
       }
     }
 #ifdef ENABLE_MESSAGE_DIGEST
-    CheckIntegrityEntryHandle entry(new ChecksumCheckIntegrityEntry(_requestGroup));
+    SharedHandle<CheckIntegrityEntry> entry
+      (new ChecksumCheckIntegrityEntry(_requestGroup));
     if(entry->isValidationReady()) {
       entry->initValidator();
       // TODO do we need cuttrailinggarbage here?
@@ -293,11 +294,11 @@ bool DownloadCommand::prepareForNextSegment() {
     // The number of segments should be 1 in order to pass through the next
     // segment.
     if(_segments.size() == 1) {
-      SegmentHandle tempSegment = _segments.front();
+      SharedHandle<Segment> tempSegment = _segments.front();
       if(!tempSegment->complete()) {
         return prepareForRetry(0);
       }
-      SegmentHandle nextSegment =
+      SharedHandle<Segment> nextSegment =
         _requestGroup->getSegmentMan()->getSegment(cuid,
                                                    tempSegment->getIndex()+1);
       if(!nextSegment.isNull() && nextSegment->getWrittenLength() == 0) {
diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc
index a88fa1ee..21fc6b1d 100644
--- a/src/DownloadContext.cc
+++ b/src/DownloadContext.cc
@@ -120,7 +120,7 @@ void DownloadContext::setFilePathWithIndex
 
 void DownloadContext::setFileFilter(IntSequence seq)
 {
-  std::deque<int32_t> fileIndexes = seq.flush();
+  std::vector<int32_t> fileIndexes = seq.flush();
   std::sort(fileIndexes.begin(), fileIndexes.end());
   fileIndexes.erase(std::unique(fileIndexes.begin(), fileIndexes.end()),
                     fileIndexes.end());
diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc
index 6c9b5091..57db8d0a 100644
--- a/src/DownloadEngine.cc
+++ b/src/DownloadEngine.cc
@@ -237,7 +237,7 @@ void DownloadEngine::setStatCalc(const StatCalcHandle& statCalc)
   _statCalc = statCalc;
 }
 
-void DownloadEngine::addCommand(const Commands& commands)
+void DownloadEngine::addCommand(const std::vector<Command*>& commands)
 {
   this->commands.insert(this->commands.end(), commands.begin(), commands.end());
 }
@@ -398,10 +398,10 @@ DownloadEngine::popPooledSocket(std::map<std::string, std::string>& options,
 
 SharedHandle<SocketCore>
 DownloadEngine::popPooledSocket
-(const std::deque<std::string>& ipaddrs, uint16_t port)
+(const std::vector<std::string>& ipaddrs, uint16_t port)
 {
   SharedHandle<SocketCore> s;
-  for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
+  for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
       i != ipaddrs.end(); ++i) {
     s = popPooledSocket(*i, port);
     if(!s.isNull()) {
@@ -414,10 +414,10 @@ DownloadEngine::popPooledSocket
 SharedHandle<SocketCore>
 DownloadEngine::popPooledSocket
 (std::map<std::string, std::string>& options,
- const std::deque<std::string>& ipaddrs, uint16_t port)
+ const std::vector<std::string>& ipaddrs, uint16_t port)
 {
   SharedHandle<SocketCore> s;
-  for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
+  for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
       i != ipaddrs.end(); ++i) {
     s = popPooledSocket(options, *i, port);
     if(!s.isNull()) {
diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h
index fc282bf3..3adfe31c 100644
--- a/src/DownloadEngine.h
+++ b/src/DownloadEngine.h
@@ -40,6 +40,7 @@
 #include <string>
 #include <deque>
 #include <map>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "a2netcompat.h"
@@ -184,7 +185,7 @@ public:
                                Command* command);
 #endif // ENABLE_ASYNC_DNS
 
-  void addCommand(const std::deque<Command*>& commands);
+  void addCommand(const std::vector<Command*>& commands);
 
   void setStatCalc(const SharedHandle<StatCalc>& statCalc);
 
@@ -228,12 +229,12 @@ public:
    uint16_t port);
 
   SharedHandle<SocketCore>
-  popPooledSocket(const std::deque<std::string>& ipaddrs, uint16_t port);
+  popPooledSocket(const std::vector<std::string>& ipaddrs, uint16_t port);
 
   SharedHandle<SocketCore>
   popPooledSocket
   (std::map<std::string, std::string>& options,
-   const std::deque<std::string>& ipaddrs,
+   const std::vector<std::string>& ipaddrs,
    uint16_t port);
 
   const SharedHandle<CookieStorage>& getCookieStorage() const
diff --git a/src/DownloadEngineFactory.cc b/src/DownloadEngineFactory.cc
index 19556adc..d855f5af 100644
--- a/src/DownloadEngineFactory.cc
+++ b/src/DownloadEngineFactory.cc
@@ -75,7 +75,7 @@ DownloadEngineFactory::DownloadEngineFactory():
 
 DownloadEngineHandle
 DownloadEngineFactory::newDownloadEngine
-(Option* op, const RequestGroups& requestGroups)
+(Option* op, const std::vector<SharedHandle<RequestGroup> >& requestGroups)
 {
   const size_t MAX_CONCURRENT_DOWNLOADS =
     op->getAsInt(PREF_MAX_CONCURRENT_DOWNLOADS);
diff --git a/src/DownloadEngineFactory.h b/src/DownloadEngineFactory.h
index cbbbf335..c26d96f4 100644
--- a/src/DownloadEngineFactory.h
+++ b/src/DownloadEngineFactory.h
@@ -36,8 +36,10 @@
 #define _D_DOWNLOAD_ENGINE_FACTORY_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -53,8 +55,8 @@ public:
   DownloadEngineFactory();
 
   SharedHandle<DownloadEngine>
-  newDownloadEngine(Option* op,
-                    const std::deque<SharedHandle<RequestGroup> >& requestGroups);
+  newDownloadEngine
+  (Option* op, const std::vector<SharedHandle<RequestGroup> >& requestGroups);
 };
 
 } // namespace aria2
diff --git a/src/DownloadHandler.h b/src/DownloadHandler.h
index e7db61ff..0f508d7a 100644
--- a/src/DownloadHandler.h
+++ b/src/DownloadHandler.h
@@ -36,9 +36,10 @@
 #define _D_DOWNLOAD_HANDLER_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
-#include <deque>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
diff --git a/src/DownloadHandlerFactory.cc b/src/DownloadHandlerFactory.cc
index 0a3712dc..6c5ec97e 100644
--- a/src/DownloadHandlerFactory.cc
+++ b/src/DownloadHandlerFactory.cc
@@ -44,20 +44,20 @@ namespace aria2 {
 
 #ifdef ENABLE_METALINK
 
-MemoryBufferPreDownloadHandlerHandle
+SharedHandle<MemoryBufferPreDownloadHandler>
 DownloadHandlerFactory::_metalinkPreDownloadHandler;
 
-MetalinkPostDownloadHandlerHandle
+SharedHandle<MetalinkPostDownloadHandler>
 DownloadHandlerFactory::_metalinkPostDownloadHandler;
 
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
 
-MemoryBufferPreDownloadHandlerHandle
+SharedHandle<MemoryBufferPreDownloadHandler>
 DownloadHandlerFactory::_btPreDownloadHandler;
 
-BtPostDownloadHandlerHandle
+SharedHandle<BtPostDownloadHandler>
 DownloadHandlerFactory::_btPostDownloadHandler;
 
 SharedHandle<UTMetadataPostDownloadHandler>
@@ -66,7 +66,7 @@ DownloadHandlerFactory::_btMetadataPostDownloadHandler;
 
 #ifdef ENABLE_METALINK
 
-MemoryBufferPreDownloadHandlerHandle
+SharedHandle<MemoryBufferPreDownloadHandler>
 DownloadHandlerFactory::getMetalinkPreDownloadHandler()
 {
   if(_metalinkPreDownloadHandler.isNull()) {
@@ -83,7 +83,7 @@ DownloadHandlerFactory::getMetalinkPreDownloadHandler()
   return _metalinkPreDownloadHandler;
 }
 
-MetalinkPostDownloadHandlerHandle
+SharedHandle<MetalinkPostDownloadHandler>
 DownloadHandlerFactory::getMetalinkPostDownloadHandler()
 {
   if(_metalinkPostDownloadHandler.isNull()) {
@@ -96,7 +96,7 @@ DownloadHandlerFactory::getMetalinkPostDownloadHandler()
 
 #ifdef ENABLE_BITTORRENT
 
-MemoryBufferPreDownloadHandlerHandle
+SharedHandle<MemoryBufferPreDownloadHandler>
 DownloadHandlerFactory::getBtPreDownloadHandler()
 {
   if(_btPreDownloadHandler.isNull()) {
@@ -113,7 +113,8 @@ DownloadHandlerFactory::getBtPreDownloadHandler()
   return _btPreDownloadHandler;
 }
 
-BtPostDownloadHandlerHandle DownloadHandlerFactory::getBtPostDownloadHandler()
+SharedHandle<BtPostDownloadHandler>
+DownloadHandlerFactory::getBtPostDownloadHandler()
 {
   if(_btPostDownloadHandler.isNull()) {
     _btPostDownloadHandler.reset(new BtPostDownloadHandler());
diff --git a/src/FileAllocationCommand.cc b/src/FileAllocationCommand.cc
index 48615624..94260f34 100644
--- a/src/FileAllocationCommand.cc
+++ b/src/FileAllocationCommand.cc
@@ -48,7 +48,9 @@
 
 namespace aria2 {
 
-FileAllocationCommand::FileAllocationCommand(int cuid, RequestGroup* requestGroup, DownloadEngine* e, const FileAllocationEntryHandle& fileAllocationEntry):
+FileAllocationCommand::FileAllocationCommand
+(int cuid, RequestGroup* requestGroup, DownloadEngine* e,
+ const SharedHandle<FileAllocationEntry>& fileAllocationEntry):
   RealtimeCommand(cuid, requestGroup, e),
   _fileAllocationEntry(fileAllocationEntry) {}
 
@@ -68,7 +70,7 @@ bool FileAllocationCommand::executeInternal()
     }
     _e->_fileAllocationMan->dropPickedEntry();
     
-    std::deque<Command*> commands;
+    std::vector<Command*> commands;
     try {
       _fileAllocationEntry->prepareForNextAction(commands, _e);
     } catch(RecoverableException& e) {
diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h
index 811ade92..7d423da2 100644
--- a/src/FileAllocationEntry.h
+++ b/src/FileAllocationEntry.h
@@ -37,7 +37,8 @@
 
 #include "RequestGroupEntry.h"
 #include "ProgressAwareEntry.h"
-#include <deque>
+
+#include <vector>
 
 namespace aria2 {
 
@@ -61,15 +62,12 @@ public:
 
   void allocateChunk();
 
-  virtual void prepareForNextAction(std::deque<Command*>& commands,
+  virtual void prepareForNextAction(std::vector<Command*>& commands,
                                     DownloadEngine* e) = 0;
 
   void disableDirectIO();
 };
 
-typedef SharedHandle<FileAllocationEntry> FileAllocationEntryHandle;
-typedef std::deque<FileAllocationEntryHandle> FileAllocationEntries;
-
 } // namespace aria2
 
 #endif // _D_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/FileEntry.cc b/src/FileEntry.cc
index 53924e64..e1d4591e 100644
--- a/src/FileEntry.cc
+++ b/src/FileEntry.cc
@@ -46,8 +46,8 @@ namespace aria2 {
 FileEntry::FileEntry(const std::string& path,
                      uint64_t length,
                      off_t offset,
-                     const std::deque<std::string>& uris):
-  path(path), _uris(uris), length(length), offset(offset),
+                     const std::vector<std::string>& uris):
+  path(path), _uris(uris.begin(), uris.end()), length(length), offset(offset),
   extracted(false), requested(true),
   _singleHostMultiConnection(true),
   _logger(LogFactory::getInstance()) {}
@@ -92,7 +92,7 @@ off_t FileEntry::gtoloff(off_t goff) const
   return goff-offset;
 }
 
-void FileEntry::getUris(std::deque<std::string>& uris) const
+void FileEntry::getUris(std::vector<std::string>& uris) const
 {
   uris.insert(uris.end(), _spentUris.begin(), _spentUris.end());
   uris.insert(uris.end(), _uris.begin(), _uris.end());
@@ -125,7 +125,7 @@ FileEntry::getRequest
 {
   SharedHandle<Request> req;
   if(_requestPool.empty()) {
-    std::deque<std::string> pending;
+    std::vector<std::string> pending;
     while(1) {
       std::string uri = selector->select(this);
       if(uri.empty()) {
@@ -287,14 +287,14 @@ void FileEntry::reuseUri(size_t num)
   std::sort(uris.begin(), uris.end());
   uris.erase(std::unique(uris.begin(), uris.end()), uris.end());
 
-  std::deque<std::string> errorUris(_uriResults.size());
+  std::vector<std::string> errorUris(_uriResults.size());
   std::transform(_uriResults.begin(), _uriResults.end(),
                  errorUris.begin(), std::mem_fun_ref(&URIResult::getURI));
   std::sort(errorUris.begin(), errorUris.end());
   errorUris.erase(std::unique(errorUris.begin(), errorUris.end()),
                   errorUris.end());
      
-  std::deque<std::string> reusableURIs;
+  std::vector<std::string> reusableURIs;
   std::set_difference(uris.begin(), uris.end(),
                       errorUris.begin(), errorUris.end(),
                       std::back_inserter(reusableURIs));
diff --git a/src/FileEntry.h b/src/FileEntry.h
index 0199ba28..2faa8bfa 100644
--- a/src/FileEntry.h
+++ b/src/FileEntry.h
@@ -39,6 +39,7 @@
 
 #include <string>
 #include <deque>
+#include <vector>
 #include <ostream>
 
 #include "SharedHandle.h"
@@ -78,7 +79,7 @@ public:
   FileEntry();
 
   FileEntry(const std::string& path, uint64_t length, off_t offset,
-            const std::deque<std::string>& uris = std::deque<std::string>());
+            const std::vector<std::string>& uris = std::vector<std::string>());
 
   ~FileEntry();
 
@@ -133,9 +134,9 @@ public:
     return _spentUris;
   }
 
-  void setUris(const std::deque<std::string>& uris)
+  void setUris(const std::vector<std::string>& uris)
   {
-    _uris = uris;
+    _uris = std::deque<std::string>(uris.begin(), uris.end());
   }
 
   template<typename InputIterator>
@@ -145,7 +146,7 @@ public:
   }
 
   // Inserts _uris and _spentUris into uris.
-  void getUris(std::deque<std::string>& uris) const;
+  void getUris(std::vector<std::string>& uris) const;
 
   void setContentType(const std::string& contentType)
   {
@@ -240,9 +241,6 @@ public:
   }
 };
 
-typedef SharedHandle<FileEntry> FileEntryHandle;
-typedef std::deque<FileEntryHandle> FileEntries;
-
 // Returns the first FileEntry which isRequested() method returns
 // true.  If no such FileEntry exists, then returns
 // SharedHandle<FileEntry>().
@@ -298,7 +296,7 @@ void writeFilePath
     o << "n/a";
   } else {
     if(e->getPath().empty()) {
-      std::deque<std::string> uris;
+      std::vector<std::string> uris;
       e->getUris(uris);
       if(uris.empty()) {
         o << "n/a";
diff --git a/src/FillRequestGroupCommand.h b/src/FillRequestGroupCommand.h
index 409fbd77..262b8f7b 100644
--- a/src/FillRequestGroupCommand.h
+++ b/src/FillRequestGroupCommand.h
@@ -38,7 +38,6 @@
 #include "Command.h"
 #include "SharedHandle.h"
 #include "TimeA2.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -47,7 +46,6 @@ class DownloadEngine;
 
 class FillRequestGroupCommand : public Command {
 private:
-  std::deque<SharedHandle<RequestGroup> > _reservedRequestGroups;
   DownloadEngine* _e;
   time_t _interval;
   Time _checkPoint;
diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc
index 5a2a2ffd..5580888e 100644
--- a/src/FtpConnection.cc
+++ b/src/FtpConnection.cc
@@ -63,7 +63,7 @@ const std::string FtpConnection::A("A");
 const std::string FtpConnection::I("I");
 
 FtpConnection::FtpConnection(int32_t cuid, const SocketHandle& socket,
-                             const RequestHandle& req,
+                             const SharedHandle<Request>& req,
                              const SharedHandle<AuthConfig>& authConfig,
                              const Option* op):
   cuid(cuid), socket(socket), req(req),
@@ -223,7 +223,7 @@ bool FtpConnection::sendPort(const SharedHandle<SocketCore>& serverSocket)
   return _socketBuffer.sendBufferIsEmpty();
 }
 
-bool FtpConnection::sendRest(const SegmentHandle& segment)
+bool FtpConnection::sendRest(const SharedHandle<Segment>& segment)
 {
   if(_socketBuffer.sendBufferIsEmpty()) {
     std::string request = "REST ";
diff --git a/src/FtpDownloadCommand.cc b/src/FtpDownloadCommand.cc
index 6d3020d6..a1a9ec45 100644
--- a/src/FtpDownloadCommand.cc
+++ b/src/FtpDownloadCommand.cc
@@ -49,7 +49,7 @@ namespace aria2 {
 
 FtpDownloadCommand::FtpDownloadCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const SharedHandle<FtpConnection>& ftpConnection,
diff --git a/src/FtpFinishDownloadCommand.cc b/src/FtpFinishDownloadCommand.cc
index 6c54e63b..22f61bc5 100644
--- a/src/FtpFinishDownloadCommand.cc
+++ b/src/FtpFinishDownloadCommand.cc
@@ -53,7 +53,7 @@ namespace aria2 {
 
 FtpFinishDownloadCommand::FtpFinishDownloadCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const SharedHandle<FtpConnection>& ftpConnection,
diff --git a/src/FtpInitiateConnectionCommand.cc b/src/FtpInitiateConnectionCommand.cc
index 8ef6fc67..2ec6720d 100644
--- a/src/FtpInitiateConnectionCommand.cc
+++ b/src/FtpInitiateConnectionCommand.cc
@@ -56,7 +56,7 @@ namespace aria2 {
 
 FtpInitiateConnectionCommand::FtpInitiateConnectionCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
@@ -66,7 +66,7 @@ FtpInitiateConnectionCommand::~FtpInitiateConnectionCommand() {}
 
 Command* FtpInitiateConnectionCommand::createNextCommand
 (const std::string& hostname, const std::string& addr, uint16_t port,
- const std::deque<std::string>& resolvedAddresses,
+ const std::vector<std::string>& resolvedAddresses,
  const SharedHandle<Request>& proxyRequest)
 {
   Command* command;
diff --git a/src/FtpInitiateConnectionCommand.h b/src/FtpInitiateConnectionCommand.h
index f6bbd7c9..ecc086d1 100644
--- a/src/FtpInitiateConnectionCommand.h
+++ b/src/FtpInitiateConnectionCommand.h
@@ -43,7 +43,7 @@ class FtpInitiateConnectionCommand : public InitiateConnectionCommand {
 protected:
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
-   const std::deque<std::string>& resolvedAddresses,
+   const std::vector<std::string>& resolvedAddresses,
    const SharedHandle<Request>& proxyRequest);
 public:
   FtpInitiateConnectionCommand(int cuid, const SharedHandle<Request>& req,
diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc
index 23e1b4ae..32f532d8 100644
--- a/src/FtpNegotiationCommand.cc
+++ b/src/FtpNegotiationCommand.cc
@@ -70,7 +70,7 @@ namespace aria2 {
 
 FtpNegotiationCommand::FtpNegotiationCommand
 (int32_t cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
@@ -540,14 +540,14 @@ bool FtpNegotiationCommand::recvPasv() {
   return false;
 }
 
-bool FtpNegotiationCommand::sendRestPasv(const SegmentHandle& segment) {
+bool FtpNegotiationCommand::sendRestPasv(const SharedHandle<Segment>& segment) {
   //dataSocket->setBlockingMode();
   setReadCheckSocket(socket);
   disableWriteCheckSocket();
   return sendRest(segment);
 }
 
-bool FtpNegotiationCommand::sendRest(const SegmentHandle& segment) {
+bool FtpNegotiationCommand::sendRest(const SharedHandle<Segment>& segment) {
   if(ftp->sendRest(segment)) {
     disableWriteCheckSocket();
     sequence = SEQ_RECV_REST;
@@ -617,7 +617,8 @@ bool FtpNegotiationCommand::waitConnection()
   return false;
 }
 
-bool FtpNegotiationCommand::processSequence(const SegmentHandle& segment) {
+bool FtpNegotiationCommand::processSequence
+(const SharedHandle<Segment>& segment) {
   bool doNextSequence = true;
   switch(sequence) {
   case SEQ_RECV_GREETING:
diff --git a/src/FtpTunnelRequestCommand.cc b/src/FtpTunnelRequestCommand.cc
index 6ec8890f..ae5f5c62 100644
--- a/src/FtpTunnelRequestCommand.cc
+++ b/src/FtpTunnelRequestCommand.cc
@@ -42,7 +42,7 @@ namespace aria2 {
 
 FtpTunnelRequestCommand::FtpTunnelRequestCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
diff --git a/src/FtpTunnelResponseCommand.cc b/src/FtpTunnelResponseCommand.cc
index 1cf96a8e..950f1510 100644
--- a/src/FtpTunnelResponseCommand.cc
+++ b/src/FtpTunnelResponseCommand.cc
@@ -45,7 +45,7 @@ namespace aria2 {
 
 FtpTunnelResponseCommand::FtpTunnelResponseCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc
index 3bf180d7..518498e7 100644
--- a/src/GrowSegment.cc
+++ b/src/GrowSegment.cc
@@ -38,7 +38,7 @@
 
 namespace aria2 {
 
-GrowSegment::GrowSegment(const PieceHandle& piece):
+GrowSegment::GrowSegment(const SharedHandle<Piece>& piece):
   _piece(piece), _writtenLength(0) {}
 
 GrowSegment::~GrowSegment() {}
@@ -65,7 +65,7 @@ void GrowSegment::clear()
   _piece->clearAllBlock();
 }
 
-PieceHandle GrowSegment::getPiece() const
+SharedHandle<Piece> GrowSegment::getPiece() const
 {
   return _piece;
 }
diff --git a/src/GrowSegment.h b/src/GrowSegment.h
index 2e6dc80e..6fa519a5 100644
--- a/src/GrowSegment.h
+++ b/src/GrowSegment.h
@@ -112,8 +112,6 @@ public:
   virtual SharedHandle<Piece> getPiece() const;
 };
 
-typedef SharedHandle<GrowSegment> GrowSegmentHandle;
-
 } // namespace aria2
 
 #endif // _D_GROW_SEGMENT_H_
diff --git a/src/HandleRegistry.h b/src/HandleRegistry.h
index a6cfc514..91a0646b 100644
--- a/src/HandleRegistry.h
+++ b/src/HandleRegistry.h
@@ -36,9 +36,11 @@
 #define _D_HANDLE_REGISTRY_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <map>
-#include <deque>
+#include <vector>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -67,10 +69,11 @@ public:
     }
   }
 
-  std::deque<SharedHandle<T> > getAll()
+  std::vector<SharedHandle<T> > getAll()
   {
-    std::deque<SharedHandle<T> > l;
-    for(typename HandleMap::const_iterator itr = handleMap.begin(); itr != handleMap.end(); ++itr) {
+    std::vector<SharedHandle<T> > l;
+    for(typename HandleMap::const_iterator itr = handleMap.begin();
+        itr != handleMap.end(); ++itr) {
       const typename HandleMap::value_type& p = *itr;
       l.push_back(p.second);
     }
diff --git a/src/HandshakeExtensionMessage.cc b/src/HandshakeExtensionMessage.cc
index 1f303bc9..a2d0484b 100644
--- a/src/HandshakeExtensionMessage.cc
+++ b/src/HandshakeExtensionMessage.cc
@@ -139,7 +139,7 @@ void HandshakeExtensionMessage::doReceivedAction()
   }
 }
 
-void HandshakeExtensionMessage::setPeer(const PeerHandle& peer)
+void HandshakeExtensionMessage::setPeer(const SharedHandle<Peer>& peer)
 {
   _peer = peer;
 }
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index 93e8056c..7e723fab 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -58,7 +58,8 @@
 
 namespace aria2 {
 
-HttpRequestEntry::HttpRequestEntry(const HttpRequestHandle& httpRequest):
+HttpRequestEntry::HttpRequestEntry
+(const SharedHandle<HttpRequest>& httpRequest):
   _httpRequest(httpRequest),
   _proc(new HttpHeaderProcessor()) {}
 
@@ -91,7 +92,7 @@ std::string HttpConnection::eraseConfidentialInfo(const std::string& request)
   return result;
 }
 
-void HttpConnection::sendRequest(const HttpRequestHandle& httpRequest)
+void HttpConnection::sendRequest(const SharedHandle<HttpRequest>& httpRequest)
 {
   std::string request = httpRequest->createRequest();
   logger->info(MSG_SENDING_REQUEST, cuid, eraseConfidentialInfo(request).c_str());
@@ -100,7 +101,8 @@ void HttpConnection::sendRequest(const HttpRequestHandle& httpRequest)
   outstandingHttpRequests.push_back(entry);
 }
 
-void HttpConnection::sendProxyRequest(const HttpRequestHandle& httpRequest)
+void HttpConnection::sendProxyRequest
+(const SharedHandle<HttpRequest>& httpRequest)
 {
   std::string request = httpRequest->createProxyRequest();
   logger->info(MSG_SENDING_REQUEST, cuid, eraseConfidentialInfo(request).c_str());
@@ -109,7 +111,7 @@ void HttpConnection::sendProxyRequest(const HttpRequestHandle& httpRequest)
   outstandingHttpRequests.push_back(entry);
 }
 
-HttpResponseHandle HttpConnection::receiveResponse()
+SharedHandle<HttpResponse> HttpConnection::receiveResponse()
 {
   if(outstandingHttpRequests.empty()) {
     throw DL_ABORT_EX(EX_NO_HTTP_REQUEST_ENTRY_FOUND);
@@ -138,7 +140,7 @@ HttpResponseHandle HttpConnection::receiveResponse()
 
   logger->info(MSG_RECEIVE_RESPONSE, cuid, proc->getHeaderString().c_str());
   SharedHandle<HttpHeader> httpHeader = proc->getHttpResponseHeader();
-  HttpResponseHandle httpResponse(new HttpResponse());
+  SharedHandle<HttpResponse> httpResponse(new HttpResponse());
   httpResponse->setCuid(cuid);
   httpResponse->setHttpHeader(httpHeader);
   httpResponse->setHttpRequest(entry->getHttpRequest());
@@ -148,11 +150,11 @@ HttpResponseHandle HttpConnection::receiveResponse()
   return httpResponse;
 }
 
-bool HttpConnection::isIssued(const SegmentHandle& segment) const
+bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const
 {
   for(HttpRequestEntries::const_iterator itr = outstandingHttpRequests.begin();
       itr != outstandingHttpRequests.end(); ++itr) {
-    HttpRequestHandle httpRequest = (*itr)->getHttpRequest();
+    SharedHandle<HttpRequest> httpRequest = (*itr)->getHttpRequest();
     if(httpRequest->getSegment() == segment) {
       return true;
     }
diff --git a/src/HttpDownloadCommand.cc b/src/HttpDownloadCommand.cc
index fe29e9d2..74865327 100644
--- a/src/HttpDownloadCommand.cc
+++ b/src/HttpDownloadCommand.cc
@@ -53,7 +53,7 @@ namespace aria2 {
 
 HttpDownloadCommand::HttpDownloadCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const SharedHandle<HttpResponse>& httpResponse,
diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc
index 635cca5c..f103f5e3 100644
--- a/src/HttpHeader.cc
+++ b/src/HttpHeader.cc
@@ -104,17 +104,15 @@ const std::string& HttpHeader::getFirst(const std::string& name) const {
   }
 }
 
-std::deque<std::string> HttpHeader::get(const std::string& name) const {
-  std::deque<std::string> v;
-
+std::vector<std::string> HttpHeader::get(const std::string& name) const
+{
+  std::vector<std::string> v;
   std::string n(util::toLower(name));
-
-  std::multimap<std::string, std::string>::const_iterator first =
-    table.lower_bound(n);
-  std::multimap<std::string, std::string>::const_iterator last =
-    table.upper_bound(n);
-
-  while(first != last) {
+  std::pair<std::multimap<std::string, std::string>::const_iterator,
+    std::multimap<std::string, std::string>::const_iterator> itrpair =
+    table.equal_range(n);
+  std::multimap<std::string, std::string>::const_iterator first = itrpair.first;
+  while(first != itrpair.second) {
     v.push_back((*first).second);
     ++first;
   }
diff --git a/src/HttpHeader.h b/src/HttpHeader.h
index 1a42ff4b..e1b19643 100644
--- a/src/HttpHeader.h
+++ b/src/HttpHeader.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <map>
-#include <deque>
+#include <vector>
 #include <string>
 #include <iosfwd>
 
@@ -71,7 +71,7 @@ public:
   void put(const std::string& name, const std::string& value);
   bool defined(const std::string& name) const;
   const std::string& getFirst(const std::string& name) const;
-  std::deque<std::string> get(const std::string& name) const;
+  std::vector<std::string> get(const std::string& name) const;
   unsigned int getFirstAsUInt(const std::string& name) const;
   uint64_t getFirstAsULLInt(const std::string& name) const;
 
diff --git a/src/HttpInitiateConnectionCommand.cc b/src/HttpInitiateConnectionCommand.cc
index 80758027..9f39ac8c 100644
--- a/src/HttpInitiateConnectionCommand.cc
+++ b/src/HttpInitiateConnectionCommand.cc
@@ -53,7 +53,7 @@ namespace aria2 {
 
 HttpInitiateConnectionCommand::HttpInitiateConnectionCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e):
@@ -63,7 +63,7 @@ HttpInitiateConnectionCommand::~HttpInitiateConnectionCommand() {}
 
 Command* HttpInitiateConnectionCommand::createNextCommand
 (const std::string& hostname, const std::string& addr, uint16_t port,
- const std::deque<std::string>& resolvedAddresses,
+ const std::vector<std::string>& resolvedAddresses,
  const SharedHandle<Request>& proxyRequest)
 {
   Command* command;
diff --git a/src/HttpInitiateConnectionCommand.h b/src/HttpInitiateConnectionCommand.h
index 6d16a7da..6c8c400d 100644
--- a/src/HttpInitiateConnectionCommand.h
+++ b/src/HttpInitiateConnectionCommand.h
@@ -43,7 +43,7 @@ class HttpInitiateConnectionCommand : public InitiateConnectionCommand {
 protected:
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
-   const std::deque<std::string>& resolvedAddresses,
+   const std::vector<std::string>& resolvedAddresses,
    const SharedHandle<Request>& proxyRequest);
 public:
   HttpInitiateConnectionCommand(int cuid, const SharedHandle<Request>& req,
diff --git a/src/HttpProxyRequestCommand.cc b/src/HttpProxyRequestCommand.cc
index f32974f7..92bf3d29 100644
--- a/src/HttpProxyRequestCommand.cc
+++ b/src/HttpProxyRequestCommand.cc
@@ -42,7 +42,7 @@ namespace aria2 {
 
 HttpProxyRequestCommand::HttpProxyRequestCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
diff --git a/src/HttpProxyResponseCommand.cc b/src/HttpProxyResponseCommand.cc
index 281520dd..eb842f98 100644
--- a/src/HttpProxyResponseCommand.cc
+++ b/src/HttpProxyResponseCommand.cc
@@ -45,7 +45,7 @@ namespace aria2 {
 
 HttpProxyResponseCommand::HttpProxyResponseCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc
index 27f27382..d897df76 100644
--- a/src/HttpRequest.cc
+++ b/src/HttpRequest.cc
@@ -161,7 +161,7 @@ std::string HttpRequest::createRequest()
   builtinHds.reserve(20);
   builtinHds.push_back(std::make_pair("User-Agent:", userAgent));
   std::string acceptTypes = "*/*";
-  for(std::deque<std::string>::const_iterator i = _acceptTypes.begin(),
+  for(std::vector<std::string>::const_iterator i = _acceptTypes.begin(),
         end = _acceptTypes.end(); i != end; ++i) {
     strappend(acceptTypes, ",", (*i));
   }
@@ -216,13 +216,13 @@ std::string HttpRequest::createRequest()
   }
   if(!_cookieStorage.isNull()) {
     std::string cookiesValue;
-    std::deque<Cookie> cookies =
+    std::vector<Cookie> cookies =
       _cookieStorage->criteriaFind(getHost(),
                                    getDir(),
                                    Time().getTime(),
                                    getProtocol() == Request::PROTO_HTTPS ?
                                    true : false);
-    for(std::deque<Cookie>::const_iterator itr = cookies.begin(),
+    for(std::vector<Cookie>::const_iterator itr = cookies.begin(),
           end = cookies.end(); itr != end; ++itr) {
       strappend(cookiesValue, (*itr).toString(), ";");
     }
diff --git a/src/HttpRequest.h b/src/HttpRequest.h
index 56e9d245..c8a3c9e5 100644
--- a/src/HttpRequest.h
+++ b/src/HttpRequest.h
@@ -39,7 +39,6 @@
 
 #include <cassert>
 #include <string>
-#include <deque>
 #include <vector>
 
 #include "SharedHandle.h"
@@ -72,7 +71,7 @@ private:
 
   std::vector<std::string> _headers;
 
-  std::deque<std::string> _acceptTypes;
+  std::vector<std::string> _acceptTypes;
 
   SharedHandle<CookieStorage> _cookieStorage;
 
@@ -258,9 +257,6 @@ public:
   }
 };
 
-typedef SharedHandle<HttpRequest> HttpRequestHandle;
-typedef std::deque<HttpRequestHandle> HttpRequests;
-
 } // namespace aria2
 
 #endif // _D_HTTP_REQUEST_H_
diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc
index c6148e39..5bf996bd 100644
--- a/src/HttpRequestCommand.cc
+++ b/src/HttpRequestCommand.cc
@@ -58,7 +58,7 @@ namespace aria2 {
 
 HttpRequestCommand::HttpRequestCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
@@ -85,7 +85,7 @@ createHttpRequest(const SharedHandle<Request>& req,
                   const SharedHandle<AuthConfigFactory>& authConfigFactory,
                   const SharedHandle<Request>& proxyRequest)
 {
-  HttpRequestHandle httpRequest(new HttpRequest());
+  SharedHandle<HttpRequest> httpRequest(new HttpRequest());
   httpRequest->setUserAgent(option->get(PREF_USER_AGENT));
   httpRequest->setRequest(req);
   httpRequest->setFileEntry(fileEntry);
@@ -122,7 +122,7 @@ bool HttpRequestCommand::executeInternal() {
     }
 
     if(_segments.empty()) {
-      HttpRequestHandle httpRequest
+      SharedHandle<HttpRequest> httpRequest
         (createHttpRequest(req,
                            _fileEntry,
                            SharedHandle<Segment>(),
@@ -134,10 +134,11 @@ bool HttpRequestCommand::executeInternal() {
                            _proxyRequest));
       _httpConnection->sendRequest(httpRequest);
     } else {
-      for(Segments::iterator itr = _segments.begin(); itr != _segments.end(); ++itr) {
-        const SegmentHandle& segment = *itr;
+      for(std::vector<SharedHandle<Segment> >::iterator itr = _segments.begin();
+          itr != _segments.end(); ++itr) {
+        const SharedHandle<Segment>& segment = *itr;
         if(!_httpConnection->isIssued(segment)) {
-          HttpRequestHandle httpRequest
+          SharedHandle<HttpRequest> httpRequest
             (createHttpRequest(req,
                                _fileEntry,
                                segment,
diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc
index e59b853c..2fec4f40 100644
--- a/src/HttpResponse.cc
+++ b/src/HttpResponse.cc
@@ -33,9 +33,6 @@
  */
 /* copyright --> */
 #include "HttpResponse.h"
-
-#include <deque>
-
 #include "Request.h"
 #include "Segment.h"
 #include "HttpRequest.h"
@@ -116,8 +113,8 @@ std::string HttpResponse::determinFilename() const
 
 void HttpResponse::retrieveCookie()
 {
-  std::deque<std::string> v = httpHeader->get(HttpHeader::SET_COOKIE);
-  for(std::deque<std::string>::const_iterator itr = v.begin(); itr != v.end();
+  std::vector<std::string> v = httpHeader->get(HttpHeader::SET_COOKIE);
+  for(std::vector<std::string>::const_iterator itr = v.begin(); itr != v.end();
       ++itr) {
     httpRequest->getCookieStorage()->parseAndStore(*itr,
                                                    httpRequest->getHost(),
diff --git a/src/HttpResponse.h b/src/HttpResponse.h
index 8d754c9f..693a332b 100644
--- a/src/HttpResponse.h
+++ b/src/HttpResponse.h
@@ -130,8 +130,6 @@ public:
   bool supportsPersistentConnection() const;
 };
 
-typedef SharedHandle<HttpResponse> HttpResponseHandle;
-
 } // namespace aria2
 
 #endif // _D_HTTP_RESPONSE_H_
diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc
index 207c86e7..c6c8f5ac 100644
--- a/src/HttpResponseCommand.cc
+++ b/src/HttpResponseCommand.cc
@@ -77,7 +77,7 @@ static SharedHandle<Decoder> getContentEncodingDecoder
 
 HttpResponseCommand::HttpResponseCommand
 (int32_t cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
@@ -91,8 +91,8 @@ HttpResponseCommand::~HttpResponseCommand() {}
 
 bool HttpResponseCommand::executeInternal()
 {
-  HttpRequestHandle httpRequest = httpConnection->getFirstHttpRequest();
-  HttpResponseHandle httpResponse = httpConnection->receiveResponse();
+  SharedHandle<HttpRequest> httpRequest = httpConnection->getFirstHttpRequest();
+  SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse();
   if(httpResponse.isNull()) {
     // The server has not responded to our request yet.
     // For socket->wantRead() == true, setReadCheckSocket(socket) is already
@@ -213,9 +213,10 @@ bool HttpResponseCommand::shouldInflateContentEncoding
     !fileIsGzipped(httpResponse);
 }
 
-bool HttpResponseCommand::handleDefaultEncoding(const HttpResponseHandle& httpResponse)
+bool HttpResponseCommand::handleDefaultEncoding
+(const SharedHandle<HttpResponse>& httpResponse)
 {
-  HttpRequestHandle httpRequest = httpResponse->getHttpRequest();
+  SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest();
   _requestGroup->adjustFilename
     (SharedHandle<BtProgressInfoFile>(new DefaultBtProgressInfoFile
                                       (_requestGroup->getDownloadContext(),
@@ -244,7 +245,8 @@ bool HttpResponseCommand::handleDefaultEncoding(const HttpResponseHandle& httpRe
     _requestGroup->loadAndOpenFile(infoFile);
     File file(_requestGroup->getFirstFilePath());
 
-    SegmentHandle segment = _requestGroup->getSegmentMan()->getSegment(cuid, 0);
+    SharedHandle<Segment> segment =
+      _requestGroup->getSegmentMan()->getSegment(cuid, 0);
     // pipelining requires implicit range specified. But the request for
     // this response most likely dones't contains range header. This means
     // we can't continue to use this socket because server sends all entity
@@ -305,9 +307,10 @@ static SharedHandle<Decoder> getContentEncodingDecoder
   return decoder;
 }
 
-bool HttpResponseCommand::handleOtherEncoding(const HttpResponseHandle& httpResponse) {
+bool HttpResponseCommand::handleOtherEncoding
+(const SharedHandle<HttpResponse>& httpResponse) {
   // We assume that RequestGroup::getTotalLength() == 0 here
-  HttpRequestHandle httpRequest = httpResponse->getHttpRequest();
+  SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest();
 
   if(getOption()->getAsBool(PREF_DRY_RUN)) {
     _requestGroup->initPieceStorage();
@@ -379,7 +382,7 @@ bool HttpResponseCommand::skipResponseBody
 }
 
 HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand
-(const HttpResponseHandle& httpResponse,
+(const SharedHandle<HttpResponse>& httpResponse,
  const SharedHandle<Decoder>& transferEncodingDecoder,
  const SharedHandle<Decoder>& contentEncodingDecoder)
 {
diff --git a/src/IndexBtMessageValidator.h b/src/IndexBtMessageValidator.h
index 50751cad..60d1dc18 100644
--- a/src/IndexBtMessageValidator.h
+++ b/src/IndexBtMessageValidator.h
@@ -51,11 +51,9 @@ public:
     _message(message),
     _numPiece(numPiece) {}
 
-  virtual bool validate(Errors& errors)
+  virtual void validate()
   {
-    // TODO
     bittorrent::checkIndex(_message->getIndex(), _numPiece);
-    return true;
   }
 
 };
diff --git a/src/InitiateConnectionCommand.cc b/src/InitiateConnectionCommand.cc
index 8045e549..ff81c450 100644
--- a/src/InitiateConnectionCommand.cc
+++ b/src/InitiateConnectionCommand.cc
@@ -53,7 +53,7 @@ namespace aria2 {
 
 InitiateConnectionCommand::InitiateConnectionCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e):
@@ -79,7 +79,7 @@ bool InitiateConnectionCommand::executeInternal() {
     hostname = proxyRequest->getHost();
     port = proxyRequest->getPort();
   }
-  std::deque<std::string> addrs;
+  std::vector<std::string> addrs;
   e->findAllCachedIPAddresses(std::back_inserter(addrs), hostname, port);
   std::string ipaddr;
   if(addrs.empty()) {
@@ -107,7 +107,7 @@ bool InitiateConnectionCommand::executeInternal() {
     logger->info(MSG_NAME_RESOLUTION_COMPLETE, cuid,
                  hostname.c_str(),
                  strjoin(addrs.begin(), addrs.end(), ", ").c_str());
-    for(std::deque<std::string>::const_iterator i = addrs.begin();
+    for(std::vector<std::string>::const_iterator i = addrs.begin();
         i != addrs.end(); ++i) {
       e->cacheIPAddress(hostname, *i, port);
     }
diff --git a/src/InitiateConnectionCommand.h b/src/InitiateConnectionCommand.h
index 00043c2a..7c326786 100644
--- a/src/InitiateConnectionCommand.h
+++ b/src/InitiateConnectionCommand.h
@@ -57,7 +57,7 @@ protected:
   // server.
   virtual Command* createNextCommand
   (const std::string& hostname, const std::string& addr, uint16_t port,
-   const std::deque<std::string>& resolvedAddresses,
+   const std::vector<std::string>& resolvedAddresses,
    const SharedHandle<Request>& proxyRequest) = 0;
 public:
   InitiateConnectionCommand(int cuid, const SharedHandle<Request>& req,
diff --git a/src/InitiateConnectionCommandFactory.cc b/src/InitiateConnectionCommandFactory.cc
index 9498e92a..5170fcbb 100644
--- a/src/InitiateConnectionCommandFactory.cc
+++ b/src/InitiateConnectionCommandFactory.cc
@@ -50,7 +50,7 @@ namespace aria2 {
 Command*
 InitiateConnectionCommandFactory::createInitiateConnectionCommand
 (int32_t cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e)
diff --git a/src/MSEHandshake.cc b/src/MSEHandshake.cc
index 4ed7a769..db7cd35d 100644
--- a/src/MSEHandshake.cc
+++ b/src/MSEHandshake.cc
@@ -454,7 +454,7 @@ bool MSEHandshake::findReceiverHashMarker()
 }
 
 bool MSEHandshake::receiveReceiverHashAndPadCLength
-(const std::deque<SharedHandle<DownloadContext> >& downloadContexts)
+(const std::vector<SharedHandle<DownloadContext> >& downloadContexts)
 {
   size_t r = 20+VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2/*PadC length*/-_rbufLength;
   if(r > receiveNBytes(r)) {
@@ -464,7 +464,7 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength
   // pointing to the position of HASH('req2', SKEY) xor HASH('req3', S)
   unsigned char* rbufptr = _rbuf;
   SharedHandle<DownloadContext> downloadContext;
-  for(std::deque<SharedHandle<DownloadContext> >::const_iterator i =
+  for(std::vector<SharedHandle<DownloadContext> >::const_iterator i =
         downloadContexts.begin(); i != downloadContexts.end(); ++i) {
     unsigned char md[20];
     const BDE& torrentAttrs = (*i)->getAttribute(bittorrent::BITTORRENT);
diff --git a/src/MSEHandshake.h b/src/MSEHandshake.h
index 6e5075b7..8ce66386 100644
--- a/src/MSEHandshake.h
+++ b/src/MSEHandshake.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "BtConstants.h"
@@ -158,7 +158,7 @@ public:
   bool findReceiverHashMarker();
 
   bool receiveReceiverHashAndPadCLength
-  (const std::deque<SharedHandle<DownloadContext> >& downloadContexts);
+  (const std::vector<SharedHandle<DownloadContext> >& downloadContexts);
 
   bool receiveReceiverIALength();
 
diff --git a/src/MemoryBufferPreDownloadHandler.h b/src/MemoryBufferPreDownloadHandler.h
index c23d156b..78d0e136 100644
--- a/src/MemoryBufferPreDownloadHandler.h
+++ b/src/MemoryBufferPreDownloadHandler.h
@@ -49,8 +49,6 @@ public:
   virtual void execute(RequestGroup* requestGroup);
 };
 
-typedef SharedHandle<MemoryBufferPreDownloadHandler> MemoryBufferPreDownloadHandlerHandle;
-
 } // namespace aria2
 
 #endif // _D_MEMORY_BUFFER_PRE_DOWNLOAD_HANDLER_H_
diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc
index fc3ff427..5ad017d8 100644
--- a/src/Metalink2RequestGroup.cc
+++ b/src/Metalink2RequestGroup.cc
@@ -71,9 +71,9 @@ Metalink2RequestGroup::Metalink2RequestGroup():
 
 class AccumulateNonP2PUrl {
 private:
-  std::deque<std::string>& urlsPtr;
+  std::vector<std::string>& urlsPtr;
 public:
-  AccumulateNonP2PUrl(std::deque<std::string>& urlsPtr)
+  AccumulateNonP2PUrl(std::vector<std::string>& urlsPtr)
     :urlsPtr(urlsPtr) {}
 
   void operator()(const SharedHandle<MetalinkResource>& resource) {
@@ -103,9 +103,10 @@ public:
 };
 
 void
-Metalink2RequestGroup::generate(std::deque<SharedHandle<RequestGroup> >& groups,
-                                const std::string& metalinkFile,
-                                const SharedHandle<Option>& option)
+Metalink2RequestGroup::generate
+(std::vector<SharedHandle<RequestGroup> >& groups,
+ const std::string& metalinkFile,
+ const SharedHandle<Option>& option)
 {
   std::vector<SharedHandle<MetalinkEntry> > entries;
   MetalinkHelper::parseAndQuery(entries, metalinkFile, option.get());
@@ -113,9 +114,10 @@ Metalink2RequestGroup::generate(std::deque<SharedHandle<RequestGroup> >& groups,
 }
 
 void
-Metalink2RequestGroup::generate(std::deque<SharedHandle<RequestGroup> >& groups,
-                                const SharedHandle<BinaryStream>& binaryStream,
-                                const SharedHandle<Option>& option)
+Metalink2RequestGroup::generate
+(std::vector<SharedHandle<RequestGroup> >& groups,
+ const SharedHandle<BinaryStream>& binaryStream,
+ const SharedHandle<Option>& option)
 {
   std::vector<SharedHandle<MetalinkEntry> > entries;
   MetalinkHelper::parseAndQuery(entries, binaryStream, option.get());
@@ -135,7 +137,7 @@ void removeMetalinkContentTypes(const SharedHandle<RequestGroup>& group)
 
 void
 Metalink2RequestGroup::createRequestGroup
-(std::deque<SharedHandle<RequestGroup> >& groups,
+(std::vector<SharedHandle<RequestGroup> >& groups,
  const std::vector<SharedHandle<MetalinkEntry> >& entries,
  const SharedHandle<Option>& option)
 {
@@ -143,7 +145,7 @@ Metalink2RequestGroup::createRequestGroup
     _logger->notice(EX_NO_RESULT_WITH_YOUR_PREFS);
     return;
   }
-  std::deque<int32_t> selectIndexes =
+  std::vector<int32_t> selectIndexes =
     util::parseIntRange(option->get(PREF_SELECT_FILE)).flush();
   std::sort(selectIndexes.begin(), selectIndexes.end());
   std::vector<SharedHandle<MetalinkEntry> > selectedEntries;
@@ -194,10 +196,10 @@ Metalink2RequestGroup::createRequestGroup
 #ifdef ENABLE_BITTORRENT
     SharedHandle<RequestGroup> torrentRg;
     if(!metaurl.empty()) {
-      std::deque<std::string> uris;
+      std::vector<std::string> uris;
       uris.push_back(metaurl);
       {
-        std::deque<SharedHandle<RequestGroup> > result;
+        std::vector<SharedHandle<RequestGroup> > result;
         createRequestGroupForUri(result, option, uris,
                                  /* ignoreForceSequential = */true,
                                  /* ignoreLocalPath = */true);
@@ -228,7 +230,7 @@ Metalink2RequestGroup::createRequestGroup
       SharedHandle<MetalinkEntry> entry = mes[0];
       _logger->info(MSG_METALINK_QUEUEING, entry->getPath().c_str());
       entry->reorderResourcesByPriority();
-      std::deque<std::string> uris;
+      std::vector<std::string> uris;
       std::for_each(entry->resources.begin(), entry->resources.end(),
                     AccumulateNonP2PUrl(uris));
       // If piece hash is specified in the metalink,
@@ -282,7 +284,7 @@ Metalink2RequestGroup::createRequestGroup
                       (*i)->getPath().c_str());
         _logger->debug("originalName = %s", (*i)->metaurls[0]->name.c_str());
         (*i)->reorderResourcesByPriority();
-        std::deque<std::string> uris;
+        std::vector<std::string> uris;
         std::for_each((*i)->resources.begin(), (*i)->resources.end(),
                       AccumulateNonP2PUrl(uris));
         SharedHandle<FileEntry> fe
diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h
index 00d2d712..066f842c 100644
--- a/src/Metalink2RequestGroup.h
+++ b/src/Metalink2RequestGroup.h
@@ -38,7 +38,6 @@
 #include "common.h"
 #include "SharedHandle.h"
 #include <string>
-#include <deque>
 #include <vector>
 
 namespace aria2 {
@@ -54,17 +53,17 @@ private:
   Logger* _logger;
 
   void
-  createRequestGroup(std::deque<SharedHandle<RequestGroup> >& groups,
+  createRequestGroup(std::vector<SharedHandle<RequestGroup> >& groups,
                      const std::vector<SharedHandle<MetalinkEntry> >& entries,
                      const SharedHandle<Option>& option);
 public:
   Metalink2RequestGroup();
 
-  void generate(std::deque<SharedHandle<RequestGroup> >& groups,
+  void generate(std::vector<SharedHandle<RequestGroup> >& groups,
                 const std::string& metalinkFile,
                 const SharedHandle<Option>& option);
 
-  void generate(std::deque<SharedHandle<RequestGroup> >& groups,
+  void generate(std::vector<SharedHandle<RequestGroup> >& groups,
                 const SharedHandle<BinaryStream>& binaryStream,
                 const SharedHandle<Option>& option);
 };
diff --git a/src/MetalinkPostDownloadHandler.cc b/src/MetalinkPostDownloadHandler.cc
index 7e4456bf..5f43c709 100644
--- a/src/MetalinkPostDownloadHandler.cc
+++ b/src/MetalinkPostDownloadHandler.cc
@@ -61,7 +61,7 @@ MetalinkPostDownloadHandler::MetalinkPostDownloadHandler()
 MetalinkPostDownloadHandler::~MetalinkPostDownloadHandler() {}
 
 void MetalinkPostDownloadHandler::getNextRequestGroups
-(std::deque<SharedHandle<RequestGroup> >& groups,
+(std::vector<SharedHandle<RequestGroup> >& groups,
  RequestGroup* requestGroup)
 {
   if(_logger->debug()) {
@@ -73,7 +73,7 @@ void MetalinkPostDownloadHandler::getNextRequestGroups
   try {
     diskAdaptor->openExistingFile();
     //requestOption.put(PREF_DIR, requestGroup->getDownloadContext()->getDir());
-    std::deque<SharedHandle<RequestGroup> > newRgs;
+    std::vector<SharedHandle<RequestGroup> > newRgs;
     Metalink2RequestGroup().generate(newRgs, diskAdaptor,
                                      requestGroup->getOption());
     requestGroup->followedBy(newRgs.begin(), newRgs.end());
diff --git a/src/MetalinkPostDownloadHandler.h b/src/MetalinkPostDownloadHandler.h
index a3fdc8a8..7223691d 100644
--- a/src/MetalinkPostDownloadHandler.h
+++ b/src/MetalinkPostDownloadHandler.h
@@ -47,12 +47,10 @@ public:
   virtual ~MetalinkPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
-typedef SharedHandle<MetalinkPostDownloadHandler> MetalinkPostDownloadHandlerHandle;
-
 } // namespace aria2
 
 #endif // _D_METALINK_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h
index b8be938d..4b627258 100644
--- a/src/MultiDiskAdaptor.h
+++ b/src/MultiDiskAdaptor.h
@@ -37,8 +37,6 @@
 
 #include "DiskAdaptor.h"
 
-#include <deque>
-
 namespace aria2 {
 
 class MultiFileAllocationIterator;
diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc
index 5f79633d..6ab48821 100644
--- a/src/MultiFileAllocationIterator.cc
+++ b/src/MultiFileAllocationIterator.cc
@@ -58,9 +58,9 @@ void MultiFileAllocationIterator::allocateChunk()
     if(_entries.empty()) {
       break;
     }
-    DiskWriterEntryHandle entry = _entries.front();
+    SharedHandle<DiskWriterEntry> entry = _entries.front();
     _entries.pop_front();
-    FileEntryHandle fileEntry = entry->getFileEntry();
+    SharedHandle<FileEntry> fileEntry = entry->getFileEntry();
     // Open file before calling DiskWriterEntry::size()
     _diskAdaptor->openIfNot(entry, &DiskWriterEntry::openFile);
     if(entry->needsFileAllocation() && entry->size() < fileEntry->getLength()) {
diff --git a/src/MultiUrlRequestInfo.cc b/src/MultiUrlRequestInfo.cc
index 88ec284e..ca73a9c6 100644
--- a/src/MultiUrlRequestInfo.cc
+++ b/src/MultiUrlRequestInfo.cc
@@ -77,7 +77,7 @@ static void handler(int signal) {
 }
 
 MultiUrlRequestInfo::MultiUrlRequestInfo
-(const RequestGroups& requestGroups,
+(const std::vector<SharedHandle<RequestGroup> >& requestGroups,
  const SharedHandle<Option>& op,
  const SharedHandle<StatCalc>& statCalc,
  std::ostream& summaryOut)
diff --git a/src/MultiUrlRequestInfo.h b/src/MultiUrlRequestInfo.h
index c4e94c61..2191151a 100644
--- a/src/MultiUrlRequestInfo.h
+++ b/src/MultiUrlRequestInfo.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 #include <iosfwd>
 
 #include "SharedHandle.h"
@@ -52,7 +52,7 @@ class StatCalc;
 
 class MultiUrlRequestInfo {
 private:
-  std::deque<SharedHandle<RequestGroup> > _requestGroups;
+  std::vector<SharedHandle<RequestGroup> > _requestGroups;
 
   SharedHandle<Option> _option;
 
@@ -66,7 +66,7 @@ private:
 
 public:
   MultiUrlRequestInfo
-  (const std::deque<SharedHandle<RequestGroup> >& requestGroups,
+  (const std::vector<SharedHandle<RequestGroup> >& requestGroups,
    const SharedHandle<Option>& op,
    const SharedHandle<StatCalc>& statCalc,
    std::ostream& summaryOut);
diff --git a/src/NameMatchOptionHandler.h b/src/NameMatchOptionHandler.h
index a0620079..f974c499 100644
--- a/src/NameMatchOptionHandler.h
+++ b/src/NameMatchOptionHandler.h
@@ -42,6 +42,7 @@
 #include <algorithm>
 #include <sstream>
 #include <iterator>
+#include <vector>
 
 #include "A2STR.h"
 #include "util.h"
@@ -63,7 +64,7 @@ protected:
 
   std::string _defaultValue;
 
-  std::deque<std::string> _tags;
+  std::vector<std::string> _tags;
 
   int _id;
 
diff --git a/src/NameResolver.cc b/src/NameResolver.cc
index 7efd066d..7a126d6e 100644
--- a/src/NameResolver.cc
+++ b/src/NameResolver.cc
@@ -46,7 +46,7 @@ namespace aria2 {
 
 NameResolver::NameResolver():_socktype(0), _family(AF_UNSPEC) {}
 
-void NameResolver::resolve(std::deque<std::string>& resolvedAddresses,
+void NameResolver::resolve(std::vector<std::string>& resolvedAddresses,
                            const std::string& hostname)
 {
   struct addrinfo* res;
diff --git a/src/NameResolver.h b/src/NameResolver.h
index 1686aa84..0e9781b0 100644
--- a/src/NameResolver.h
+++ b/src/NameResolver.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 #include <string>
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
@@ -51,7 +51,7 @@ public:
   /**
    * Reolved addresses are pushed into addresses.
    */
-  void resolve(std::deque<std::string>& resolvedAddresses,
+  void resolve(std::vector<std::string>& resolvedAddresses,
                const std::string& hostname);
 
   // specify SOCK_STREAM or SOCK_DGRAM
diff --git a/src/Netrc.cc b/src/Netrc.cc
index 253c2e5f..40b068b6 100644
--- a/src/Netrc.cc
+++ b/src/Netrc.cc
@@ -36,7 +36,6 @@
 
 #include <fstream>
 #include <algorithm>
-#include <vector>
 
 #include "DlAbortEx.h"
 #include "StringFormat.h"
@@ -85,7 +84,7 @@ void Netrc::parse(const std::string& path)
     SET_ACCOUNT,
     SET_MACDEF
   };
-  AuthenticatorHandle authenticator;
+  SharedHandle<Authenticator> authenticator;
   std::string line;
   STATE state = GET_TOKEN;
   while(getline(f, line)) {
@@ -144,7 +143,7 @@ void Netrc::parse(const std::string& path)
   storeAuthenticator(authenticator);
 }
 
-void Netrc::storeAuthenticator(const AuthenticatorHandle& authenticator)
+void Netrc::storeAuthenticator(const SharedHandle<Authenticator>& authenticator)
 {
   if(!authenticator.isNull()) {
     authenticators.push_back(authenticator);
@@ -157,22 +156,23 @@ private:
 public:
   AuthHostMatch(const std::string& hostname):hostname(hostname) {}
 
-  bool operator()(const AuthenticatorHandle& authenticator)
+  bool operator()(const SharedHandle<Authenticator>& authenticator)
   {
     return authenticator->match(hostname);
   }
 };
 
-AuthenticatorHandle Netrc::findAuthenticator(const std::string& hostname) const
+SharedHandle<Authenticator>
+Netrc::findAuthenticator(const std::string& hostname) const
 {
-  Authenticators::const_iterator itr =
+  SharedHandle<Authenticator> res;
+  std::vector<SharedHandle<Authenticator> >::const_iterator itr =
     std::find_if(authenticators.begin(), authenticators.end(),
                  AuthHostMatch(hostname));
-  if(itr == authenticators.end()) {
-    return SharedHandle<Authenticator>();
-  } else {
-    return *itr;
+  if(itr != authenticators.end()) {
+    res = *itr;
   }
+  return res;
 }
 
 } // namespace aria2
diff --git a/src/Netrc.h b/src/Netrc.h
index 7be2581c..ec17bcba 100644
--- a/src/Netrc.h
+++ b/src/Netrc.h
@@ -36,12 +36,14 @@
 #define _D_NETRC_H_
 
 #include "common.h"
-#include "SharedHandle.h"
-#include "A2STR.h"
+
 #include <string>
-#include <deque>
+#include <vector>
 #include <iosfwd>
 
+#include "SharedHandle.h"
+#include "A2STR.h"
+
 namespace aria2 {
 
 class Authenticatable {
@@ -51,8 +53,6 @@ public:
   virtual bool match(const std::string& hostname) const = 0;
 };
 
-typedef SharedHandle<Authenticatable> AuthenticatableHandle;
-
 class Authenticator : public Authenticatable {
 private:
   std::string machine;
@@ -107,9 +107,6 @@ public:
   void setAccount(const std::string& account) { this->account = account; }
 };
 
-typedef SharedHandle<Authenticator> AuthenticatorHandle;
-typedef std::deque<AuthenticatorHandle> Authenticators;
-
 class DefaultAuthenticator : public Authenticator {
 public:
   DefaultAuthenticator() {}
@@ -127,13 +124,11 @@ public:
   }
 };
 
-typedef SharedHandle<DefaultAuthenticator> DefaultAuthenticatorHandle;
-
 class Netrc {
 private:
-  Authenticators authenticators;
+  std::vector<SharedHandle<Authenticator> > authenticators;
 
-  void storeAuthenticator(const AuthenticatorHandle& authenticator);
+  void storeAuthenticator(const SharedHandle<Authenticator>& authenticator);
 
   std::string getRequiredNextToken(std::ifstream& f) const;
   
@@ -143,14 +138,15 @@ public:
 
   void parse(const std::string& path);
 
-  AuthenticatorHandle findAuthenticator(const std::string& hostname) const;
+  SharedHandle<Authenticator> findAuthenticator
+  (const std::string& hostname) const;
 
-  const Authenticators& getAuthenticators() const
+  const std::vector<SharedHandle<Authenticator> >& getAuthenticators() const
   {
     return authenticators;
   }
 
-  void addAuthenticator(const AuthenticatorHandle& authenticator)
+  void addAuthenticator(const SharedHandle<Authenticator>& authenticator)
   {
     authenticators.push_back(authenticator);
   }
@@ -168,8 +164,6 @@ public:
   static const std::string MACDEF;
 };
 
-typedef SharedHandle<Netrc> NetrcHandle;
-
 } // namespace aria2
 
 #endif // _D_NETRC_H_
diff --git a/src/NetrcAuthResolver.cc b/src/NetrcAuthResolver.cc
index 110c64be..2a3fbae4 100644
--- a/src/NetrcAuthResolver.cc
+++ b/src/NetrcAuthResolver.cc
@@ -40,7 +40,8 @@ namespace aria2 {
 
 NetrcAuthResolver::NetrcAuthResolver():_ignoreDefault(false) {}
 
-AuthConfigHandle NetrcAuthResolver::resolveAuthConfig(const std::string& hostname)
+SharedHandle<AuthConfig>
+NetrcAuthResolver::resolveAuthConfig(const std::string& hostname)
 {
   if(_userDefinedAuthConfig.isNull()) {
     return findNetrcAuthenticator(hostname);
@@ -49,12 +50,13 @@ AuthConfigHandle NetrcAuthResolver::resolveAuthConfig(const std::string& hostnam
   }
 }
 
-AuthConfigHandle NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const
+SharedHandle<AuthConfig>
+NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const
 {
   if(_netrc.isNull()) {
     return _defaultAuthConfig;
   } else {
-    AuthenticatorHandle auth = _netrc->findAuthenticator(hostname);
+    SharedHandle<Authenticator> auth = _netrc->findAuthenticator(hostname);
     if(auth.isNull()) {
       return _defaultAuthConfig;
     } else {
@@ -68,7 +70,7 @@ AuthConfigHandle NetrcAuthResolver::findNetrcAuthenticator(const std::string& ho
   }
 }
 
-void NetrcAuthResolver::setNetrc(const NetrcHandle& netrc)
+void NetrcAuthResolver::setNetrc(const SharedHandle<Netrc>& netrc)
 {
   _netrc = netrc;
 }
diff --git a/src/NsCookieParser.cc b/src/NsCookieParser.cc
index 927cdb50..ed08ff8f 100644
--- a/src/NsCookieParser.cc
+++ b/src/NsCookieParser.cc
@@ -35,7 +35,6 @@
 #include "NsCookieParser.h"
 
 #include <fstream>
-#include <vector>
 
 #include "util.h"
 #include "A2STR.h"
@@ -76,7 +75,7 @@ static Cookie parseNsCookie(const std::string& nsCookieStr)
   return c;
 }
 
-std::deque<Cookie> NsCookieParser::parse(const std::string& filename)
+std::vector<Cookie> NsCookieParser::parse(const std::string& filename)
 {
   std::ifstream s(filename.c_str(), std::ios::binary);
   if(!s) {
@@ -84,7 +83,7 @@ std::deque<Cookie> NsCookieParser::parse(const std::string& filename)
       (StringFormat("Failed to open file %s", filename.c_str()).str());
   }
   std::string line;
-  std::deque<Cookie> cookies;
+  std::vector<Cookie> cookies;
   while(getline(s, line)) {
     if(util::startsWith(line, A2STR::SHARP_C)) {
       continue;
diff --git a/src/NsCookieParser.h b/src/NsCookieParser.h
index 6204a97d..5395ec80 100644
--- a/src/NsCookieParser.h
+++ b/src/NsCookieParser.h
@@ -36,9 +36,11 @@
 #define _D_NS_COOKIE_PARSER_H_
 
 #include "common.h"
-#include "Cookie.h"
+
 #include <string>
-#include <deque>
+#include <vector>
+
+#include "Cookie.h"
 
 namespace aria2 {
 
@@ -48,7 +50,7 @@ public:
 
   ~NsCookieParser();
 
-  std::deque<Cookie> parse(const std::string& filename);
+  std::vector<Cookie> parse(const std::string& filename);
 };
 
 } // namespace aria2
diff --git a/src/NumberDecorator.h b/src/NumberDecorator.h
index e04671f8..c52c28fe 100644
--- a/src/NumberDecorator.h
+++ b/src/NumberDecorator.h
@@ -36,9 +36,11 @@
 #define _D_NUMBER_DECORATOR_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class NumberDecorator {
@@ -48,8 +50,6 @@ public:
   virtual std::string decorate(unsigned int number) = 0;
 };
 
-typedef SharedHandle<NumberDecorator> NumberDecoratorHandle;
-
 } // namespace aria2;
 
 #endif // _D_NUMBER_DECORATOR_H_
diff --git a/src/OptionHandlerFactory.cc b/src/OptionHandlerFactory.cc
index e4e02647..b46f1acd 100644
--- a/src/OptionHandlerFactory.cc
+++ b/src/OptionHandlerFactory.cc
@@ -209,7 +209,7 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
 #else // !HAVE_EPOLL
                                     V_SELECT,
 #endif // !HAVE_EPOLL
-                                    std::deque<std::string>
+                                    std::vector<std::string>
                                     (&params[0],&params[arrayLength(params)])));
     op->addTag(TAG_ADVANCED);
     handlers.push_back(op);
@@ -285,7 +285,7 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
                                    (PREF_LOG_LEVEL,
                                     TEXT_LOG_LEVEL,
                                     V_DEBUG,
-                                    std::deque<std::string>
+                                    std::vector<std::string>
                                     (&params[0],
                                      &params[arrayLength(params)])));
     op->addTag(TAG_ADVANCED);
@@ -646,7 +646,7 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
                                    (PREF_URI_SELECTOR,
                                     TEXT_URI_SELECTOR,
                                     V_FEEDBACK,
-                                    std::deque<std::string>
+                                    std::vector<std::string>
                                     (&params[0], &params[arrayLength(params)])));
     op->addTag(TAG_FTP);
     op->addTag(TAG_HTTP);
@@ -1304,7 +1304,7 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
                                    (PREF_METALINK_PREFERRED_PROTOCOL,
                                     TEXT_METALINK_PREFERRED_PROTOCOL,
                                     V_NONE,
-                                    std::deque<std::string>
+                                    std::vector<std::string>
                                     (&params[0], &params[arrayLength(params)])));
     op->addTag(TAG_METALINK);
     handlers.push_back(op);
diff --git a/src/OptionHandlerImpl.h b/src/OptionHandlerImpl.h
index ded59c46..3489163f 100644
--- a/src/OptionHandlerImpl.h
+++ b/src/OptionHandlerImpl.h
@@ -43,6 +43,7 @@
 #include <numeric>
 #include <sstream>
 #include <iterator>
+#include <vector>
 
 #include "NameMatchOptionHandler.h"
 #include "util.h"
@@ -416,12 +417,12 @@ public:
 
 class ParameterOptionHandler : public NameMatchOptionHandler {
 private:
-  std::deque<std::string> _validParamValues;
+  std::vector<std::string> _validParamValues;
 public:
   ParameterOptionHandler(const std::string& optName,
                          const std::string& description,
                          const std::string& defaultValue,
-                         const std::deque<std::string>& validParamValues,
+                         const std::vector<std::string>& validParamValues,
                          char shortName = 0):
     NameMatchOptionHandler(optName, description, defaultValue,
                            OptionHandler::REQ_ARG, shortName),
@@ -470,7 +471,7 @@ public:
 
   virtual void parseArg(Option& option, const std::string& optarg)
   {
-    std::deque<std::string>::const_iterator itr =
+    std::vector<std::string>::const_iterator itr =
       std::find(_validParamValues.begin(), _validParamValues.end(), optarg);
     if(itr == _validParamValues.end()) {
       std::string msg = _optName;
@@ -478,7 +479,8 @@ public:
       if(_validParamValues.size() == 0) {
         msg += "''";
       } else {
-        for(std::deque<std::string>::const_iterator itr = _validParamValues.begin();
+        for(std::vector<std::string>::const_iterator itr =
+              _validParamValues.begin();
             itr != _validParamValues.end(); ++itr) {
           strappend(msg, "'", *itr, "' ");
         }
diff --git a/src/OptionParser.cc b/src/OptionParser.cc
index 40c04bb9..7e8b56ac 100644
--- a/src/OptionParser.cc
+++ b/src/OptionParser.cc
@@ -127,7 +127,8 @@ static std::string createOptstring(InputIterator first, InputIterator last)
 }
 
 void OptionParser::parseArg
-(std::ostream& out, std::deque<std::string>& nonopts, int argc, char* const argv[])
+(std::ostream& out, std::vector<std::string>& nonopts,
+ int argc, char* const argv[])
 {
   size_t numPublicOption = countPublicOption(_optionHandlers.begin(),
                                              _optionHandlers.end());
diff --git a/src/OptionParser.h b/src/OptionParser.h
index f9ec3ddc..8294d3ed 100644
--- a/src/OptionParser.h
+++ b/src/OptionParser.h
@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 #include <vector>
 #include <iosfwd>
 
@@ -69,7 +68,7 @@ public:
   // Parses options in argv and writes option name and value to out in
   // NAME=VALUE format. Non-option strings are stored in nonopts.
   // Throws Exception when an unrecognized option is found.
-  void parseArg(std::ostream& out, std::deque<std::string>& nonopts,
+  void parseArg(std::ostream& out, std::vector<std::string>& nonopts,
                 int argc, char* const argv[]);
 
   void parse(Option& option, std::istream& ios);
diff --git a/src/PStringBuildVisitor.cc b/src/PStringBuildVisitor.cc
index b023d1d3..81d1171a 100644
--- a/src/PStringBuildVisitor.cc
+++ b/src/PStringBuildVisitor.cc
@@ -74,14 +74,14 @@ void PStringBuildVisitor::visit(PStringNumLoop& s)
 
 void PStringBuildVisitor::visit(PStringSelect& s)
 {
-  const std::deque<std::string>& values = s.getValues();
-  for(std::deque<std::string>::const_iterator i = values.begin();
+  const std::vector<std::string>& values = s.getValues();
+  for(std::vector<std::string>::const_iterator i = values.begin();
       i != values.end(); ++i) {
     PStringSegment(*i, s.getNext()).accept(*this);
   }
 }
 
-const std::deque<std::string>& PStringBuildVisitor::getURIs() const
+const std::vector<std::string>& PStringBuildVisitor::getURIs() const
 {
   return _uris;
 }
diff --git a/src/PStringBuildVisitor.h b/src/PStringBuildVisitor.h
index ec428c01..687237cd 100644
--- a/src/PStringBuildVisitor.h
+++ b/src/PStringBuildVisitor.h
@@ -38,6 +38,7 @@
 #include "PStringVisitor.h"
 
 #include <deque>
+#include <vector>
 #include <string>
 
 #include "SharedHandle.h"
@@ -50,7 +51,7 @@ private:
 
   std::deque<std::string> _buildQueue;
 
-  std::deque<std::string> _uris;
+  std::vector<std::string> _uris;
 public:
   
   virtual void visit(PStringSegment& s);
@@ -59,7 +60,7 @@ public:
 
   virtual void visit(PStringSelect& s);
 
-  const std::deque<std::string>& getURIs() const;
+  const std::vector<std::string>& getURIs() const;
 
   void reset();
 };
diff --git a/src/PStringDatum.h b/src/PStringDatum.h
index 7b43b186..256c65fb 100644
--- a/src/PStringDatum.h
+++ b/src/PStringDatum.h
@@ -49,8 +49,6 @@ public:
   virtual void accept(PStringVisitor& visitor) = 0;
 };
 
-typedef SharedHandle<PStringDatum> PStringDatumHandle;
-
 } // namespace aria2
 
 #endif // _D_P_STRING_DATUM_H_
diff --git a/src/PStringNumLoop.h b/src/PStringNumLoop.h
index c32a2ec5..c7456764 100644
--- a/src/PStringNumLoop.h
+++ b/src/PStringNumLoop.h
@@ -52,15 +52,15 @@ private:
 
   unsigned int _step;
 
-  NumberDecoratorHandle _numberDecorator;
+  SharedHandle<NumberDecorator> _numberDecorator;
 
-  PStringDatumHandle _next;
+  SharedHandle<PStringDatum> _next;
 
 public:
   PStringNumLoop(unsigned int startValue, unsigned int endValue,
                  unsigned int step,
-                 const NumberDecoratorHandle& nd,
-                 const PStringDatumHandle& next):
+                 const SharedHandle<NumberDecorator>& nd,
+                 const SharedHandle<PStringDatum>& next):
     _startValue(startValue),
     _endValue(endValue),
     _step(step),
@@ -69,7 +69,7 @@ public:
 
   PStringNumLoop(unsigned int startValue, unsigned int endValue,
                  unsigned int step,
-                 const NumberDecoratorHandle& nd):
+                 const SharedHandle<NumberDecorator>& nd):
     _startValue(startValue),
     _endValue(endValue),
     _step(step),
@@ -82,12 +82,12 @@ public:
     visitor.visit(*this);
   }
 
-  const NumberDecoratorHandle& getNumberDecorator() const
+  const SharedHandle<NumberDecorator>& getNumberDecorator() const
   {
     return _numberDecorator;
   }
 
-  PStringDatumHandle getNext() const
+  SharedHandle<PStringDatum> getNext() const
   {
     return _next;
   }
@@ -109,8 +109,6 @@ public:
 
 };
 
-typedef SharedHandle<PStringNumLoop> PStringNumLoopHandle;
-
 } // namespace aria2
 
 #endif // _D_P_STRING_NUM_LOOP_H_
diff --git a/src/PStringSegment.h b/src/PStringSegment.h
index cedd8f7d..99d58da5 100644
--- a/src/PStringSegment.h
+++ b/src/PStringSegment.h
@@ -65,8 +65,6 @@ public:
   SharedHandle<PStringDatum> getNext() const;
 };
 
-typedef SharedHandle<PStringSegment> PStringSegmentHandle;
-
 } // namespace aria2
 
 #endif // _D_P_STRING_SEGMENT_H_
diff --git a/src/PStringSelect.h b/src/PStringSelect.h
index a6e3a09f..0cf40750 100644
--- a/src/PStringSelect.h
+++ b/src/PStringSelect.h
@@ -45,17 +45,17 @@ class PStringSelect : public PStringDatum
 {
 private:
   
-  std::deque<std::string> _values;
+  std::vector<std::string> _values;
 
-  PStringDatumHandle _next;
+  SharedHandle<PStringDatum> _next;
 
 public:
-  PStringSelect(const std::deque<std::string>& values,
-                const PStringDatumHandle& next):
+  PStringSelect(const std::vector<std::string>& values,
+                const SharedHandle<PStringDatum>& next):
     _values(values),
     _next(next) {}
 
-  PStringSelect(const std::deque<std::string>& values):
+  PStringSelect(const std::vector<std::string>& values):
     _values(values) {}
 
   virtual ~PStringSelect() {}
@@ -65,19 +65,17 @@ public:
     visitor.visit(*this);
   }
 
-  const std::deque<std::string>& getValues() const
+  const std::vector<std::string>& getValues() const
   {
     return _values;
   }
 
-  PStringDatumHandle getNext() const
+  SharedHandle<PStringDatum> getNext() const
   {
     return _next;
   }
 };
 
-typedef SharedHandle<PStringSelect> PStringSelectHandle;
-
 } // namespace aria2
 
 #endif // _D_P_STRING_SELECT_H_
diff --git a/src/ParameterizedStringParser.cc b/src/ParameterizedStringParser.cc
index b21bbc98..d342838e 100644
--- a/src/ParameterizedStringParser.cc
+++ b/src/ParameterizedStringParser.cc
@@ -47,14 +47,15 @@
 
 namespace aria2 {
 
-PStringDatumHandle ParameterizedStringParser::parse(const std::string& src)
+SharedHandle<PStringDatum>
+ParameterizedStringParser::parse(const std::string& src)
 {
   int offset = 0;
   return diggPString(src, offset);
 }
 
-PStringDatumHandle ParameterizedStringParser::diggPString(const std::string& src,
-                                                          int& offset)
+SharedHandle<PStringDatum>
+ParameterizedStringParser::diggPString(const std::string& src, int& offset)
 {
   if(src.size() == (size_t)offset) {
     return SharedHandle<PStringDatum>();
@@ -69,8 +70,8 @@ PStringDatumHandle ParameterizedStringParser::diggPString(const std::string& src
   } 
 }
 
-PStringDatumHandle ParameterizedStringParser::createSegment(const std::string& src,
-                                                            int& offset)
+SharedHandle<PStringDatum>
+ParameterizedStringParser::createSegment(const std::string& src, int& offset)
 {
   std::string::size_type nextDelimiterIndex = src.find_first_of("[{", offset);
   if(nextDelimiterIndex == std::string::npos) {
@@ -78,31 +79,31 @@ PStringDatumHandle ParameterizedStringParser::createSegment(const std::string& s
   }
   std::string value = src.substr(offset, nextDelimiterIndex-offset);
   offset = nextDelimiterIndex;
-  PStringDatumHandle next = diggPString(src, offset);
+  SharedHandle<PStringDatum> next = diggPString(src, offset);
   return SharedHandle<PStringDatum>(new PStringSegment(value, next));
 }
 
-PStringDatumHandle ParameterizedStringParser::createSelect(const std::string& src,
-                                                           int& offset)
+SharedHandle<PStringDatum>
+ParameterizedStringParser::createSelect(const std::string& src, int& offset)
 {
   ++offset;
   std::string::size_type rightParenIndex = src.find("}", offset);
   if(rightParenIndex == std::string::npos) {
     throw DL_ABORT_EX("Missing '}' in the parameterized string.");
   }
-  std::deque<std::string> values;
+  std::vector<std::string> values;
   util::split(src.substr(offset, rightParenIndex-offset),
               std::back_inserter(values), ",", true);
   if(values.empty()) {
     throw DL_ABORT_EX("Empty {} is not allowed.");
   }
   offset = rightParenIndex+1;
-  PStringDatumHandle next = diggPString(src, offset);
+  SharedHandle<PStringDatum> next = diggPString(src, offset);
   return SharedHandle<PStringDatum>(new PStringSelect(values, next));
 }
 
-PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
-                                                         int& offset)
+SharedHandle<PStringDatum>
+ParameterizedStringParser::createLoop(const std::string& src, int& offset)
 {
   ++offset;
   std::string::size_type rightParenIndex = src.find("]", offset);
@@ -127,7 +128,7 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
   if(range.first.empty() || range.second.empty()) {
     throw DL_ABORT_EX("Loop range missing.");
   }
-  NumberDecoratorHandle nd;
+  SharedHandle<NumberDecorator> nd;
   unsigned int start;
   unsigned int end;
   if(util::isNumber(range.first) && util::isNumber(range.second)) {
@@ -146,7 +147,7 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
     throw DL_ABORT_EX("Invalid loop range.");
   }
 
-  PStringDatumHandle next(diggPString(src, offset));
+  SharedHandle<PStringDatum> next(diggPString(src, offset));
   return SharedHandle<PStringDatum>(new PStringNumLoop(start, end, step, nd, next));
 }
 
diff --git a/src/Peer.cc b/src/Peer.cc
index ceef6f9b..a47171c8 100644
--- a/src/Peer.cc
+++ b/src/Peer.cc
@@ -300,7 +300,7 @@ size_t Peer::countPeerAllowedIndexSet() const
   return _res->peerAllowedIndexSet().size();
 }
 
-const std::deque<size_t>& Peer::getPeerAllowedIndexSet() const
+const std::vector<size_t>& Peer::getPeerAllowedIndexSet() const
 {
   assert(_res);
   return _res->peerAllowedIndexSet();
diff --git a/src/Peer.h b/src/Peer.h
index 79158811..bb2c54f8 100644
--- a/src/Peer.h
+++ b/src/Peer.h
@@ -39,7 +39,7 @@
 
 #include <cassert>
 #include <string>
-#include <deque>
+#include <vector>
 #include <algorithm>
 
 #include "SharedHandle.h"
@@ -248,7 +248,7 @@ public:
 
   size_t countPeerAllowedIndexSet() const;
 
-  const std::deque<size_t>& getPeerAllowedIndexSet() const;
+  const std::vector<size_t>& getPeerAllowedIndexSet() const;
 
   void addAmAllowedIndex(size_t index);
 
@@ -306,9 +306,6 @@ size_t countSeeder(InputIterator first, InputIterator last)
   return std::count_if(first, last, mem_fun_sh(&Peer::isSeeder));
 }
 
-typedef SharedHandle<Peer> PeerHandle;
-typedef std::deque<PeerHandle> Peers;
-
 } // namespace aria2
 
 #endif // _D_PEER_H_
diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc
index 67e4b26d..f26cec59 100644
--- a/src/PeerAbstractCommand.cc
+++ b/src/PeerAbstractCommand.cc
@@ -47,7 +47,7 @@
 namespace aria2 {
 
 PeerAbstractCommand::PeerAbstractCommand(int32_t cuid,
-                                         const PeerHandle& peer,
+                                         const SharedHandle<Peer>& peer,
                                          DownloadEngine* e,
                                          const SocketHandle& s):
   Command(cuid),
diff --git a/src/PeerInitiateConnectionCommand.cc b/src/PeerInitiateConnectionCommand.cc
index 6cbf9479..c6e783e9 100644
--- a/src/PeerInitiateConnectionCommand.cc
+++ b/src/PeerInitiateConnectionCommand.cc
@@ -54,7 +54,7 @@ namespace aria2 {
 PeerInitiateConnectionCommand::PeerInitiateConnectionCommand
 (int cuid,
  RequestGroup* requestGroup,
- const PeerHandle& peer,
+ const SharedHandle<Peer>& peer,
  DownloadEngine* e,
  const SharedHandle<BtRuntime>& btRuntime,
  bool mseHandshakeEnabled)
@@ -99,7 +99,7 @@ bool PeerInitiateConnectionCommand::executeInternal() {
 // TODO this method removed when PeerBalancerCommand is implemented
 bool PeerInitiateConnectionCommand::prepareForNextPeer(time_t wait) {
   if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) {
-    PeerHandle peer = _peerStorage->getUnusedPeer();
+    SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
     peer->usedBy(e->newCUID());
     PeerInitiateConnectionCommand* command =
       new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, e,
diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc
index 9e731324..23274a78 100644
--- a/src/PeerInteractionCommand.cc
+++ b/src/PeerInteractionCommand.cc
@@ -78,7 +78,7 @@ namespace aria2 {
 PeerInteractionCommand::PeerInteractionCommand
 (int32_t cuid,
  RequestGroup* requestGroup,
- const PeerHandle& p,
+ const SharedHandle<Peer>& p,
  DownloadEngine* e,
  const SharedHandle<BtRuntime>& btRuntime,
  const SharedHandle<PieceStorage>& pieceStorage,
@@ -325,7 +325,7 @@ bool PeerInteractionCommand::executeInternal() {
 // TODO this method removed when PeerBalancerCommand is implemented
 bool PeerInteractionCommand::prepareForNextPeer(time_t wait) {
   if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) {
-    PeerHandle peer = _peerStorage->getUnusedPeer();
+    SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
     peer->usedBy(e->newCUID());
     PeerInitiateConnectionCommand* command =
       new PeerInitiateConnectionCommand
diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc
index cb213a91..1b9f237b 100644
--- a/src/PeerListenCommand.cc
+++ b/src/PeerListenCommand.cc
@@ -35,7 +35,6 @@
 #include "PeerListenCommand.h"
 
 #include <utility>
-#include <deque>
 #include <algorithm>
 
 #include "DownloadEngine.h"
@@ -72,11 +71,11 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
 {
   socket.reset(new SocketCore());
 
-  std::deque<int32_t> randPorts = seq.flush();
+  std::vector<int32_t> randPorts = seq.flush();
   std::random_shuffle(randPorts.begin(), randPorts.end(),
                       *SimpleRandomizer::getInstance().get());
   
-  for(std::deque<int32_t>::const_iterator portItr = randPorts.begin();
+  for(std::vector<int32_t>::const_iterator portItr = randPorts.begin();
       portItr != randPorts.end(); ++portItr) {
     if(!(0 < (*portItr) && (*portItr) <= 65535)) {
       continue;
@@ -120,7 +119,7 @@ bool PeerListenCommand::execute() {
 
       peerSocket->setNonBlockingMode();
 
-      PeerHandle peer(new Peer(peerInfo.first, peerInfo.second, true));
+      SharedHandle<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true));
       int32_t cuid = e->newCUID();
       Command* command =
         new ReceiverMSEHandshakeCommand(cuid, peer, e, peerSocket);
diff --git a/src/PeerReceiveHandshakeCommand.cc b/src/PeerReceiveHandshakeCommand.cc
index b09e5acd..31299bc7 100644
--- a/src/PeerReceiveHandshakeCommand.cc
+++ b/src/PeerReceiveHandshakeCommand.cc
@@ -61,7 +61,7 @@ namespace aria2 {
 
 PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand
 (int32_t cuid,
- const PeerHandle& peer,
+ const SharedHandle<Peer>& peer,
  DownloadEngine* e,
  const SocketHandle& s,
  const SharedHandle<PeerConnection>& peerConnection)
diff --git a/src/PeerSessionResource.cc b/src/PeerSessionResource.cc
index 7bbd33b2..60f53799 100644
--- a/src/PeerSessionResource.cc
+++ b/src/PeerSessionResource.cc
@@ -158,14 +158,14 @@ void PeerSessionResource::fastExtensionEnabled(bool b)
   _fastExtensionEnabled = b;
 }
 
-const std::deque<size_t>& PeerSessionResource::peerAllowedIndexSet() const
+const std::vector<size_t>& PeerSessionResource::peerAllowedIndexSet() const
 {
   return _peerAllowedIndexSet;
 }
 
-static void updateIndexSet(std::deque<size_t>& c, size_t index)
+static void updateIndexSet(std::vector<size_t>& c, size_t index)
 {
-  std::deque<size_t>::iterator i = std::lower_bound(c.begin(), c.end(), index);
+  std::vector<size_t>::iterator i = std::lower_bound(c.begin(), c.end(), index);
   if(i == c.end() || (*i) != index) {
     c.insert(i, index);
   } 
diff --git a/src/PeerSessionResource.h b/src/PeerSessionResource.h
index 016cf7a1..7e191275 100644
--- a/src/PeerSessionResource.h
+++ b/src/PeerSessionResource.h
@@ -36,11 +36,13 @@
 #define _D_PEER_SESSION_RESOURCE_H_
 
 #include "common.h"
+
+#include <string>
+#include <vector>
+
 #include "BtConstants.h"
 #include "PeerStat.h"
 #include "TimeA2.h"
-#include <string>
-#include <deque>
 
 namespace aria2 {
 
@@ -67,9 +69,9 @@ private:
   BitfieldMan* _bitfieldMan;
   bool _fastExtensionEnabled;
   // fast index set which a peer has sent to localhost.
-  std::deque<size_t> _peerAllowedIndexSet;
+  std::vector<size_t> _peerAllowedIndexSet;
   // fast index set which localhost has sent to a peer.
-  std::deque<size_t> _amAllowedIndexSet;
+  std::vector<size_t> _amAllowedIndexSet;
   bool _extendedMessagingEnabled;
   Extensions _extensions;
   bool _dhtEnabled;
@@ -165,14 +167,14 @@ public:
   void fastExtensionEnabled(bool b);
 
   // fast index set which a peer has sent to localhost.
-  const std::deque<size_t>& peerAllowedIndexSet() const;
+  const std::vector<size_t>& peerAllowedIndexSet() const;
 
   void addPeerAllowedIndex(size_t index);
 
   bool peerAllowedIndexSetContains(size_t index) const;
 
   // fast index set which localhost has sent to a peer.
-  const std::deque<size_t>& amAllowedIndexSet() const
+  const std::vector<size_t>& amAllowedIndexSet() const
   {
     return _amAllowedIndexSet;
   }
diff --git a/src/PeerStorage.h b/src/PeerStorage.h
index e946f6a1..857358fd 100644
--- a/src/PeerStorage.h
+++ b/src/PeerStorage.h
@@ -36,9 +36,12 @@
 #define _D_PEER_STORAGE_H_
 
 #include "common.h"
+
+#include <deque>
+#include <vector>
+
 #include "SharedHandle.h"
 #include "TransferStat.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -57,7 +60,7 @@ public:
   /**
    * Adds all peers in peers to internal peer list.
    */
-  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers) = 0;
+  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers) = 0;
 
   /**
    * Returns internal peer list.
@@ -78,7 +81,7 @@ public:
   /**
    * Returns the list of peers which are currently connected from localhost.
    */
-  virtual void getActivePeers(std::deque<SharedHandle<Peer> >& peers) = 0;
+  virtual void getActivePeers(std::vector<SharedHandle<Peer> >& peers) = 0;
 
   /**
    * Calculates current download/upload statistics.
diff --git a/src/Piece.h b/src/Piece.h
index 02cdeb87..badd3ccc 100644
--- a/src/Piece.h
+++ b/src/Piece.h
@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <stdint.h>
-#include <deque>
 #include <vector>
 #include <string>
 
@@ -180,9 +179,6 @@ public:
   void reconfigure(size_t length);
 };
 
-typedef SharedHandle<Piece> PieceHandle;
-typedef std::deque<PieceHandle> Pieces;
-
 } // namespace aria2
 
 #endif // _D_PIECE_H_
diff --git a/src/PieceStorage.h b/src/PieceStorage.h
index 30514704..6934b39e 100644
--- a/src/PieceStorage.h
+++ b/src/PieceStorage.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "TimeA2.h"
@@ -77,7 +77,7 @@ public:
    */
   virtual SharedHandle<Piece> getMissingPiece
   (const SharedHandle<Peer>& peer,
-   const std::deque<size_t>& excludedIndexes) = 0;
+   const std::vector<size_t>& excludedIndexes) = 0;
 
   /**
    * Returns a piece that the peer has but localhost doesn't.
@@ -95,7 +95,7 @@ public:
    */
   virtual SharedHandle<Piece> getMissingFastPiece
   (const SharedHandle<Peer>& peer,
-   const std::deque<size_t>& excludedIndexes) = 0;
+   const std::vector<size_t>& excludedIndexes) = 0;
 
 #endif // ENABLE_BITTORRENT
 
@@ -204,7 +204,7 @@ public:
    * indexes is filled with piece index which is not advertised by the caller
    * command and newer than lastCheckTime.
    */
-  virtual void getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+  virtual void getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                                          int32_t myCuid,
                                          const Time& lastCheckTime) = 0;
 
@@ -225,11 +225,11 @@ public:
   virtual void markPiecesDone(uint64_t length) = 0;
 
   virtual void
-  addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) = 0;
+  addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces) = 0;
 
   virtual size_t countInFlightPiece() = 0;
 
-  virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces) = 0;
+  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces) = 0;
 
   virtual void addPieceStats(size_t index) = 0;
 
diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc
index eb506099..bc774122 100644
--- a/src/PiecedSegment.cc
+++ b/src/PiecedSegment.cc
@@ -38,7 +38,8 @@
 
 namespace aria2 {
 
-PiecedSegment::PiecedSegment(size_t pieceLength, const PieceHandle& piece):
+PiecedSegment::PiecedSegment
+(size_t pieceLength, const SharedHandle<Piece>& piece):
   _pieceLength(pieceLength), _overflowLength(0), _piece(piece)
 {
   size_t index;
@@ -123,7 +124,7 @@ void PiecedSegment::clear()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-PieceHandle PiecedSegment::getPiece() const
+SharedHandle<Piece> PiecedSegment::getPiece() const
 {
   return _piece;
 }
diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h
index ec96c112..544347a1 100644
--- a/src/PiecedSegment.h
+++ b/src/PiecedSegment.h
@@ -99,8 +99,6 @@ public:
   virtual SharedHandle<Piece> getPiece() const;
 };
 
-typedef SharedHandle<PiecedSegment> PiecedSegmentHandle;
-
 } // namespace aria2
 
 #endif // _D_PIECED_SEGMENT_H_
diff --git a/src/PostDownloadHandler.h b/src/PostDownloadHandler.h
index 8a5c9b9c..d442bd53 100644
--- a/src/PostDownloadHandler.h
+++ b/src/PostDownloadHandler.h
@@ -37,6 +37,8 @@
 
 #include "DownloadHandler.h"
 
+#include <vector>
+
 namespace aria2 {
 
 class PostDownloadHandler:public DownloadHandler
@@ -47,13 +49,10 @@ public:
   virtual ~PostDownloadHandler() {}
 
   virtual void
-  getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
                        RequestGroup* requestGroup) = 0;
 };
 
-typedef SharedHandle<PostDownloadHandler> PostDownloadHandlerHandle;
-typedef std::deque<PostDownloadHandlerHandle> PostDownloadHandlers;
-
 } // namespace aria2
 
 #endif // _D_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/PreDownloadHandler.h b/src/PreDownloadHandler.h
index fc4501a4..bc0a377d 100644
--- a/src/PreDownloadHandler.h
+++ b/src/PreDownloadHandler.h
@@ -49,9 +49,6 @@ public:
   virtual void execute(RequestGroup* requestGroup) = 0;
 };
 
-typedef SharedHandle<PreDownloadHandler> PreDownloadHandlerHandle;
-typedef std::deque<PreDownloadHandlerHandle> PreDownloadHandlers;
-
 } // namespace aria2
 
 #endif // _D_PRE_DOWNLOAD_HANDLER_H_
diff --git a/src/RangeBtMessageValidator.h b/src/RangeBtMessageValidator.h
index d1be175d..87e96385 100644
--- a/src/RangeBtMessageValidator.h
+++ b/src/RangeBtMessageValidator.h
@@ -54,16 +54,14 @@ public:
     _numPiece(numPiece),
     _pieceLength(pieceLength) {}
 
-  virtual bool validate(Errors& errors)
+  virtual void validate()
   {
-    // TODO
     bittorrent::checkIndex(_message->getIndex(), _numPiece);
     bittorrent::checkBegin(_message->getBegin(), _pieceLength);
     bittorrent::checkLength(_message->getLength());
     bittorrent::checkRange(_message->getBegin(),
                            _message->getLength(),
                            _pieceLength);
-    return true;
   }
 };
 
diff --git a/src/ReceiverMSEHandshakeCommand.cc b/src/ReceiverMSEHandshakeCommand.cc
index d2dd0476..5cc71438 100644
--- a/src/ReceiverMSEHandshakeCommand.cc
+++ b/src/ReceiverMSEHandshakeCommand.cc
@@ -135,7 +135,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
     break;
   }
   case RECEIVER_RECEIVE_PAD_C_LENGTH: {
-    std::deque<SharedHandle<DownloadContext> > downloadContexts;
+    std::vector<SharedHandle<DownloadContext> > downloadContexts;
     e->getBtRegistry()->getAllDownloadContext
       (std::back_inserter(downloadContexts));
     if(_mseHandshake->receiveReceiverHashAndPadCLength(downloadContexts)) {
diff --git a/src/Request.h b/src/Request.h
index 0cde6109..907f2b81 100644
--- a/src/Request.h
+++ b/src/Request.h
@@ -37,7 +37,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 
 #include "SharedHandle.h"
 #include "PeerStat.h"
@@ -218,10 +217,6 @@ public:
 
 };
 
-typedef SharedHandle<Request> RequestHandle;
-typedef WeakHandle<Request> RequestWeakHandle;
-typedef std::deque<RequestHandle> Requests;
-
 } // namespace aria2
 
 #endif // _D_REQUEST_H_
diff --git a/src/RequestGroup.cc b/src/RequestGroup.cc
index 05fc74dd..c6552f21 100644
--- a/src/RequestGroup.cc
+++ b/src/RequestGroup.cc
@@ -190,7 +190,7 @@ void RequestGroup::closeFile()
 }
 
 void RequestGroup::createInitialCommand
-(std::deque<Command*>& commands, DownloadEngine* e)
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
 #ifdef ENABLE_BITTORRENT
   {
@@ -272,7 +272,7 @@ void RequestGroup::createInitialCommand
                                 (progressInfoFile))));
       if(metadataGetMode) {
         if(_option->getAsBool(PREF_ENABLE_DHT)) {
-          std::deque<Command*> dhtCommands;
+          std::vector<Command*> dhtCommands;
           DHTSetup().setup(dhtCommands, e, _option.get());
           e->addCommand(dhtCommands);
         } else {
@@ -333,11 +333,11 @@ void RequestGroup::createInitialCommand
 
       if(torrentAttrs[bittorrent::PRIVATE].i() == 0 &&
          _option->getAsBool(PREF_ENABLE_DHT)) {
-        std::deque<Command*> dhtCommands;
+        std::vector<Command*> dhtCommands;
         DHTSetup().setup(dhtCommands, e, _option.get());
         e->addCommand(dhtCommands);
         if(!torrentAttrs[bittorrent::NODES].empty() && DHTSetup::initialized()) {
-          std::deque<std::pair<std::string, uint16_t> > entryPoints;
+          std::vector<std::pair<std::string, uint16_t> > entryPoints;
           const BDE& nodes = torrentAttrs[bittorrent::NODES];
           for(BDE::List::const_iterator i = nodes.listBegin();
               i != nodes.listEnd(); ++i) {
@@ -354,7 +354,7 @@ void RequestGroup::createInitialCommand
           e->commands.push_back(command);
         }
       }
-      CheckIntegrityEntryHandle entry(new BtCheckIntegrityEntry(this));
+      SharedHandle<CheckIntegrityEntry> entry(new BtCheckIntegrityEntry(this));
       // --bt-seed-unverified=true is given and download has completed, skip
       // validation for piece hashes.
       if(_option->getAsBool(PREF_BT_SEED_UNVERIFIED) &&
@@ -444,9 +444,10 @@ void RequestGroup::createInitialCommand
   }
 }
 
-void RequestGroup::processCheckIntegrityEntry(std::deque<Command*>& commands,
-                                              const CheckIntegrityEntryHandle& entry,
-                                              DownloadEngine* e)
+void RequestGroup::processCheckIntegrityEntry
+(std::vector<Command*>& commands,
+ const SharedHandle<CheckIntegrityEntry>& entry,
+ DownloadEngine* e)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_option->getAsBool(PREF_CHECK_INTEGRITY) &&
@@ -666,7 +667,7 @@ bool RequestGroup::tryAutoFileRenaming()
   return false;
 }
 
-void RequestGroup::createNextCommandWithAdj(std::deque<Command*>& commands,
+void RequestGroup::createNextCommandWithAdj(std::vector<Command*>& commands,
                                             DownloadEngine* e, int numAdj)
 {
   int numCommand;
@@ -682,7 +683,7 @@ void RequestGroup::createNextCommandWithAdj(std::deque<Command*>& commands,
   }
 }
 
-void RequestGroup::createNextCommand(std::deque<Command*>& commands,
+void RequestGroup::createNextCommand(std::vector<Command*>& commands,
                                      DownloadEngine* e,
                                      unsigned int numCommand)
 {
@@ -852,7 +853,8 @@ void RequestGroup::preDownloadProcessing()
                    getFirstFilePath().c_str());
   }
   try {
-    for(PreDownloadHandlers::const_iterator itr = _preDownloadHandlers.begin();
+    for(std::vector<SharedHandle<PreDownloadHandler> >::const_iterator itr =
+          _preDownloadHandlers.begin();
         itr != _preDownloadHandlers.end(); ++itr) {
       if((*itr)->canHandle(this)) {
         (*itr)->execute(this);
@@ -870,14 +872,15 @@ void RequestGroup::preDownloadProcessing()
 }
 
 void RequestGroup::postDownloadProcessing
-(std::deque<SharedHandle<RequestGroup> >& groups)
+(std::vector<SharedHandle<RequestGroup> >& groups)
 {
   if(_logger->debug()) {
     _logger->debug("Finding PostDownloadHandler for path %s.",
                    getFirstFilePath().c_str());
   }
   try {
-    for(PostDownloadHandlers::const_iterator itr = _postDownloadHandlers.begin();
+    for(std::vector<SharedHandle<PostDownloadHandler> >::const_iterator itr =
+          _postDownloadHandlers.begin();
         itr != _postDownloadHandlers.end(); ++itr) {
       if((*itr)->canHandle(this)) {
         (*itr)->getNextRequestGroups(groups, this);
@@ -940,12 +943,14 @@ void RequestGroup::setDiskWriterFactory(const DiskWriterFactoryHandle& diskWrite
   _diskWriterFactory = diskWriterFactory;
 }
 
-void RequestGroup::addPostDownloadHandler(const PostDownloadHandlerHandle& handler)
+void RequestGroup::addPostDownloadHandler
+(const SharedHandle<PostDownloadHandler>& handler)
 {
   _postDownloadHandlers.push_back(handler);
 }
 
-void RequestGroup::addPreDownloadHandler(const PreDownloadHandlerHandle& handler)
+void RequestGroup::addPreDownloadHandler
+(const SharedHandle<PreDownloadHandler>& handler)
 {
   _preDownloadHandlers.push_back(handler);
 }
diff --git a/src/RequestGroup.h b/src/RequestGroup.h
index 4d85ec40..d7672b82 100644
--- a/src/RequestGroup.h
+++ b/src/RequestGroup.h
@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 #include <algorithm>
 #include <vector>
 
@@ -120,11 +119,11 @@ private:
 
   HaltReason _haltReason;
 
-  std::deque<SharedHandle<PreDownloadHandler> > _preDownloadHandlers;
+  std::vector<SharedHandle<PreDownloadHandler> > _preDownloadHandlers;
 
-  std::deque<SharedHandle<PostDownloadHandler> > _postDownloadHandlers;
+  std::vector<SharedHandle<PostDownloadHandler> > _postDownloadHandlers;
 
-  std::deque<std::string> _acceptTypes;
+  std::vector<std::string> _acceptTypes;
 
   SharedHandle<URISelector> _uriSelector;
 
@@ -197,13 +196,13 @@ public:
   // Returns first bootstrap commands to initiate a download.
   // If this is HTTP/FTP download and file size is unknown, only 1 command
   // (usually, HttpInitiateConnection or FtpInitiateConnection) will be created.
-  void createInitialCommand(std::deque<Command*>& commands,
+  void createInitialCommand(std::vector<Command*>& commands,
                             DownloadEngine* e);
 
-  void createNextCommandWithAdj(std::deque<Command*>& commands,
+  void createNextCommandWithAdj(std::vector<Command*>& commands,
                                 DownloadEngine* e, int numAdj);
 
-  void createNextCommand(std::deque<Command*>& commands,
+  void createNextCommand(std::vector<Command*>& commands,
                          DownloadEngine* e, unsigned int numCommand);
   
   bool downloadFinished() const;
@@ -338,7 +337,7 @@ public:
 
   void releaseRuntimeResource(DownloadEngine* e);
 
-  void postDownloadProcessing(std::deque<SharedHandle<RequestGroup> >& groups);
+  void postDownloadProcessing(std::vector<SharedHandle<RequestGroup> >& groups);
 
   void addPostDownloadHandler(const SharedHandle<PostDownloadHandler>& handler);
 
@@ -350,7 +349,7 @@ public:
 
   void clearPreDownloadHandler();
 
-  void processCheckIntegrityEntry(std::deque<Command*>& commands,
+  void processCheckIntegrityEntry(std::vector<Command*>& commands,
                                   const SharedHandle<CheckIntegrityEntry>& entry,
                                   DownloadEngine* e);
 
@@ -376,7 +375,7 @@ public:
 
   void reportDownloadFinished();
 
-  const std::deque<std::string>& getAcceptTypes() const
+  const std::vector<std::string>& getAcceptTypes() const
   {
     return _acceptTypes;
   }
@@ -494,10 +493,6 @@ public:
   static int32_t newGID();
 };
 
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef WeakHandle<RequestGroup> RequestGroupWeakHandle;
-typedef std::deque<RequestGroupHandle> RequestGroups;
-
 } // namespace aria2
 
 #endif // _D_REQUEST_GROUP_H_
diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc
index 84d0816a..72b03ca4 100644
--- a/src/RequestGroupMan.cc
+++ b/src/RequestGroupMan.cc
@@ -70,10 +70,11 @@
 
 namespace aria2 {
 
-RequestGroupMan::RequestGroupMan(const RequestGroups& requestGroups,
-                                 unsigned int maxSimultaneousDownloads,
-                                 const Option* option):
-  _reservedGroups(requestGroups),
+RequestGroupMan::RequestGroupMan
+(const std::vector<SharedHandle<RequestGroup> >& requestGroups,
+ unsigned int maxSimultaneousDownloads,
+ const Option* option):
+  _reservedGroups(requestGroups.begin(), requestGroups.end()),
   _logger(LogFactory::getInstance()),
   _maxSimultaneousDownloads(maxSimultaneousDownloads),
   _gidCounter(0),
@@ -95,23 +96,26 @@ bool RequestGroupMan::downloadFinished()
   return _requestGroups.empty() && _reservedGroups.empty();
 }
 
-void RequestGroupMan::addRequestGroup(const RequestGroupHandle& group)
+void RequestGroupMan::addRequestGroup
+(const SharedHandle<RequestGroup>& group)
 {
   _requestGroups.push_back(group);
 }
 
-void RequestGroupMan::addReservedGroup(const RequestGroups& groups)
+void RequestGroupMan::addReservedGroup
+(const std::vector<SharedHandle<RequestGroup> >& groups)
 {
   _reservedGroups.insert(_reservedGroups.end(), groups.begin(), groups.end());
 }
 
-void RequestGroupMan::addReservedGroup(const SharedHandle<RequestGroup>& group)
+void RequestGroupMan::addReservedGroup
+(const SharedHandle<RequestGroup>& group)
 {
   _reservedGroups.push_back(group);
 }
 
 void RequestGroupMan::insertReservedGroup
-(size_t pos, const std::deque<SharedHandle<RequestGroup> >& groups)
+(size_t pos, const std::vector<SharedHandle<RequestGroup> >& groups)
 {
   _reservedGroups.insert
     (_reservedGroups.begin()+std::min(_reservedGroups.size(), pos),
@@ -130,7 +134,7 @@ size_t RequestGroupMan::countRequestGroup() const
   return _requestGroups.size();
 }
 
-RequestGroupHandle RequestGroupMan::getRequestGroup(size_t index) const
+SharedHandle<RequestGroup> RequestGroupMan::getRequestGroup(size_t index) const
 {
   if(index < _requestGroups.size()) {
     return _requestGroups[index];
@@ -342,7 +346,7 @@ public:
           } else {
             group->saveControlFile();
           }
-          RequestGroups nextGroups;
+          std::vector<SharedHandle<RequestGroup> > nextGroups;
           group->postDownloadProcessing(nextGroups);
           if(!nextGroups.empty()) {
             if(_logger->debug()) {
@@ -382,9 +386,9 @@ public:
       if(!group->getSegmentMan().isNull()) {
         bool singleConnection =
           group->getSegmentMan()->getPeerStats().size() == 1;
-        const std::deque<SharedHandle<PeerStat> >& peerStats =
+        const std::vector<SharedHandle<PeerStat> >& peerStats =
           group->getSegmentMan()->getFastestPeerStats();
-        for(std::deque<SharedHandle<PeerStat> >::const_iterator i =
+        for(std::vector<SharedHandle<PeerStat> >::const_iterator i =
               peerStats.begin(); i != peerStats.end(); ++i) {
           if((*i)->getHostname().empty() || (*i)->getProtocol().empty()) {
             continue;
@@ -467,7 +471,7 @@ void RequestGroupMan::configureRequestGroup
 }
 
 static void createInitialCommand(const SharedHandle<RequestGroup>& requestGroup,
-                                 std::deque<Command*>& commands,
+                                 std::vector<Command*>& commands,
                                  DownloadEngine* e)
 {
   requestGroup->createInitialCommand(commands, e);
@@ -479,13 +483,13 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
   if(_maxSimultaneousDownloads <= _requestGroups.size()) {
     return;
   }
-  RequestGroups temp;
+  std::vector<SharedHandle<RequestGroup> > temp;
   unsigned int count = 0;
   size_t num = _maxSimultaneousDownloads-_requestGroups.size();
   while(count < num && !_reservedGroups.empty()) {
-    RequestGroupHandle groupToAdd = _reservedGroups.front();
+    SharedHandle<RequestGroup> groupToAdd = _reservedGroups.front();
     _reservedGroups.pop_front();
-    Commands commands;
+    std::vector<Command*> commands;
     try {
       if(!groupToAdd->isDependencyResolved()) {
         temp.push_back(groupToAdd);
@@ -525,8 +529,8 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e)
 
 void RequestGroupMan::save()
 {
-  for(RequestGroups::iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     if((*itr)->allDownloadFinished()) {
       (*itr)->removeControlFile();
     } else {
@@ -541,8 +545,8 @@ void RequestGroupMan::save()
 
 void RequestGroupMan::closeFile()
 {
-  for(RequestGroups::iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     (*itr)->closeFile();
   }
 }
@@ -553,8 +557,8 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const
   size_t error = 0;
   size_t inprogress = 0;
   downloadresultcode::RESULT lastError = downloadresultcode::FINISHED;
-  for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr = _downloadResults.begin();
-      itr != _downloadResults.end(); ++itr) {
+  for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr =
+        _downloadResults.begin(); itr != _downloadResults.end(); ++itr) {
     if((*itr)->result == downloadresultcode::FINISHED) {
       ++finished;
     } else {
@@ -562,8 +566,8 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const
       lastError = (*itr)->result;
     }
   }
-  for(RequestGroups::const_iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     DownloadResultHandle result = (*itr)->createDownloadResult();
     if(result->result == downloadresultcode::FINISHED) {
       ++finished;
@@ -613,8 +617,8 @@ void RequestGroupMan::showDownloadResults(std::ostream& o) const
     }
     o << formatDownloadResult(status, *itr) << "\n";
   }
-  for(RequestGroups::const_iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     DownloadResultHandle result = (*itr)->createDownloadResult();
     std::string status;
     if(result->result == downloadresultcode::FINISHED) {
@@ -691,9 +695,9 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
   if(!requestGroup->isPreLocalFileCheckEnabled()) {
     return false;
   }
-  std::deque<std::string> files;
-  for(RequestGroups::const_iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  std::vector<std::string> files;
+  for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     if((*itr).get() != requestGroup) {
       const std::vector<SharedHandle<FileEntry> >& entries =
         (*itr)->getDownloadContext()->getFileEntries();
@@ -711,16 +715,16 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons
 
 void RequestGroupMan::halt()
 {
-  for(RequestGroups::const_iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     (*itr)->setHaltRequested(true);
   }
 }
 
 void RequestGroupMan::forceHalt()
 {
-  for(RequestGroups::const_iterator itr = _requestGroups.begin();
-      itr != _requestGroups.end(); ++itr) {
+  for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr =
+        _requestGroups.begin(); itr != _requestGroups.end(); ++itr) {
     (*itr)->setForceHaltRequested(true);
   }
 }
diff --git a/src/RequestGroupMan.h b/src/RequestGroupMan.h
index 7f138f72..6f63ca92 100644
--- a/src/RequestGroupMan.h
+++ b/src/RequestGroupMan.h
@@ -40,6 +40,7 @@
 #include <string>
 #include <deque>
 #include <iosfwd>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "DownloadResult.h"
@@ -83,7 +84,7 @@ private:
   void configureRequestGroup
   (const SharedHandle<RequestGroup>& requestGroup) const;
 public:
-  RequestGroupMan(const std::deque<SharedHandle<RequestGroup> >& requestGroups,
+  RequestGroupMan(const std::vector<SharedHandle<RequestGroup> >& requestGroups,
                   unsigned int maxSimultaneousDownloads,
                   const Option* option);
 
@@ -103,12 +104,12 @@ public:
 
   void addRequestGroup(const SharedHandle<RequestGroup>& group);
 
-  void addReservedGroup(const std::deque<SharedHandle<RequestGroup> >& groups);
+  void addReservedGroup(const std::vector<SharedHandle<RequestGroup> >& groups);
 
   void addReservedGroup(const SharedHandle<RequestGroup>& group);
 
   void insertReservedGroup
-  (size_t pos, const std::deque<SharedHandle<RequestGroup> >& groups);
+  (size_t pos, const std::vector<SharedHandle<RequestGroup> >& groups);
 
   void insertReservedGroup(size_t pos, const SharedHandle<RequestGroup>& group);
 
diff --git a/src/RequestSlot.h b/src/RequestSlot.h
index e9724b2f..ddeb745e 100644
--- a/src/RequestSlot.h
+++ b/src/RequestSlot.h
@@ -36,9 +36,6 @@
 #define _D_REQUEST_SLOT_H_
 
 #include "common.h"
-
-#include <deque>
-
 #include "TimeA2.h"
 #include "Piece.h"
 
@@ -141,8 +138,6 @@ public:
   static bool isNull(const RequestSlot& requestSlot);
 };
 
-typedef std::deque<RequestSlot> RequestSlots;
-
 } // namespace aria2
 
 #endif // _D_REQUEST_SLOT_H_
diff --git a/src/SeedCheckCommand.cc b/src/SeedCheckCommand.cc
index 8e97835c..f254658a 100644
--- a/src/SeedCheckCommand.cc
+++ b/src/SeedCheckCommand.cc
@@ -44,10 +44,11 @@
 
 namespace aria2 {
 
-SeedCheckCommand::SeedCheckCommand(int cuid,
-                                   RequestGroup* requestGroup,
-                                   DownloadEngine* e,
-                                   const SeedCriteriaHandle& seedCriteria)
+SeedCheckCommand::SeedCheckCommand
+(int cuid,
+ RequestGroup* requestGroup,
+ DownloadEngine* e,
+ const SharedHandle<SeedCriteria>& seedCriteria)
   :Command(cuid),
    _requestGroup(requestGroup),
    e(e),
diff --git a/src/SeedCriteria.h b/src/SeedCriteria.h
index 22efe8a4..47953d0f 100644
--- a/src/SeedCriteria.h
+++ b/src/SeedCriteria.h
@@ -37,7 +37,6 @@
 
 #include "common.h"
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -56,10 +55,6 @@ public:
   virtual void reset() = 0;
 };
 
-typedef SharedHandle<SeedCriteria> SeedCriteriaHandle;
-
-typedef std::deque<SeedCriteriaHandle> SeedCriterion;
-
 } // namespace aria2
 
 #endif // _D_SEED_CRITERIA_H_
diff --git a/src/Segment.h b/src/Segment.h
index a5017b82..a2ff6ff4 100644
--- a/src/Segment.h
+++ b/src/Segment.h
@@ -36,12 +36,13 @@
 #define _D_SEGMENT_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <unistd.h>
 #include <stdint.h>
-#include <deque>
 #include <string>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class Piece;
@@ -90,9 +91,6 @@ public:
   }
 };
 
-typedef SharedHandle<Segment> SegmentHandle;
-typedef std::deque<SegmentHandle> Segments;
-
 } // namespace aria2
 
 #endif // _D_SEGMENT_H_
diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc
index a7f54d36..1b07429f 100644
--- a/src/SegmentMan.cc
+++ b/src/SegmentMan.cc
@@ -54,7 +54,7 @@
 
 namespace aria2 {
 
-SegmentEntry::SegmentEntry(cuid_t cuid, const SegmentHandle& segment):
+SegmentEntry::SegmentEntry(cuid_t cuid, const SharedHandle<Segment>& segment):
   cuid(cuid), segment(segment) {}
 
 SegmentEntry::~SegmentEntry() {}
@@ -110,8 +110,8 @@ void SegmentMan::setDownloadContext
   _downloadContext = downloadContext;
 }
 
-SegmentHandle SegmentMan::checkoutSegment(cuid_t cuid,
-                                          const PieceHandle& piece)
+SharedHandle<Segment> SegmentMan::checkoutSegment
+(cuid_t cuid, const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return SharedHandle<Segment>();
@@ -119,7 +119,7 @@ SegmentHandle SegmentMan::checkoutSegment(cuid_t cuid,
   if(logger->debug()) {
     logger->debug("Attach segment#%d to CUID#%d.", piece->getIndex(), cuid);
   }
-  SegmentHandle segment;
+  SharedHandle<Segment> segment;
   if(piece->getLength() == 0) {
     segment.reset(new GrowSegment(piece));
   } else {
@@ -155,8 +155,8 @@ SegmentHandle SegmentMan::checkoutSegment(cuid_t cuid,
   return segment;
 }
 
-void SegmentMan::getInFlightSegment(std::deque<SharedHandle<Segment> >& segments,
-                                    cuid_t cuid)
+void SegmentMan::getInFlightSegment
+(std::vector<SharedHandle<Segment> >& segments, cuid_t cuid)
 {
   for(SegmentEntries::iterator itr = usedSegmentEntries.begin();
       itr != usedSegmentEntries.end(); ++itr) {
@@ -167,22 +167,23 @@ void SegmentMan::getInFlightSegment(std::deque<SharedHandle<Segment> >& segments
   }
 }
 
-SegmentHandle SegmentMan::getSegment(cuid_t cuid) {
-  PieceHandle piece =
+SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid) {
+  SharedHandle<Piece> piece =
     _pieceStorage->getSparseMissingUnusedPiece
     (_ignoreBitfield.getFilterBitfield(),_ignoreBitfield.getBitfieldLength());
   return checkoutSegment(cuid, piece);
 }
 
-void SegmentMan::getSegment(std::deque<SharedHandle<Segment> >& segments,
-                            cuid_t cuid,
-                            const SharedHandle<FileEntry>& fileEntry,
-                            size_t maxSegments)
+void SegmentMan::getSegment
+(std::vector<SharedHandle<Segment> >& segments,
+ cuid_t cuid,
+ const SharedHandle<FileEntry>& fileEntry,
+ size_t maxSegments)
 {
   BitfieldMan filter(_ignoreBitfield);
   filter.enableFilter();
   filter.addNotFilter(fileEntry->getOffset(), fileEntry->getLength());
-  std::deque<SharedHandle<Segment> > pending;
+  std::vector<SharedHandle<Segment> > pending;
   while(segments.size() < maxSegments) {
     SharedHandle<Segment> segment =
       checkoutSegment(cuid,
@@ -198,13 +199,13 @@ void SegmentMan::getSegment(std::deque<SharedHandle<Segment> >& segments,
       segments.push_back(segment);
     }
   }
-  for(std::deque<SharedHandle<Segment> >::const_iterator i = pending.begin();
+  for(std::vector<SharedHandle<Segment> >::const_iterator i = pending.begin();
       i != pending.end(); ++i) {
     cancelSegment(cuid, *i);
   }
 }
 
-SegmentHandle SegmentMan::getSegment(cuid_t cuid, size_t index) {
+SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid, size_t index) {
   if(_downloadContext->getNumPieces() <= index) {
     return SharedHandle<Segment>();
   }
@@ -250,9 +251,9 @@ void SegmentMan::cancelSegment
 
 class FindSegmentEntry {
 private:
-  SegmentHandle _segment;
+  SharedHandle<Segment> _segment;
 public:
-  FindSegmentEntry(const SegmentHandle& segment):_segment(segment) {}
+  FindSegmentEntry(const SharedHandle<Segment>& segment):_segment(segment) {}
 
   bool operator()(const SegmentEntryHandle& segmentEntry) const
   {
@@ -260,7 +261,8 @@ public:
   }
 };
 
-bool SegmentMan::completeSegment(cuid_t cuid, const SegmentHandle& segment) {
+bool SegmentMan::completeSegment
+(cuid_t cuid, const SharedHandle<Segment>& segment) {
   _pieceStorage->completePiece(segment->getPiece());
   _pieceStorage->advertisePiece(cuid, segment->getPiece()->getIndex());
   SegmentEntries::iterator itr = std::find_if(usedSegmentEntries.begin(),
@@ -288,7 +290,7 @@ uint64_t SegmentMan::getDownloadLength() const {
 
 void SegmentMan::registerPeerStat(const SharedHandle<PeerStat>& peerStat)
 {
-  for(std::deque<SharedHandle<PeerStat> >::iterator i = peerStats.begin();
+  for(std::vector<SharedHandle<PeerStat> >::iterator i = peerStats.begin();
       i != peerStats.end(); ++i) {
     if((*i)->getStatus() == PeerStat::IDLE) {
       *i = peerStat;
@@ -314,7 +316,7 @@ public:
 
 void SegmentMan::updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat)
 {
-  std::deque<SharedHandle<PeerStat> >::iterator i =
+  std::vector<SharedHandle<PeerStat> >::iterator i =
     std::find_if(_fastestPeerStats.begin(), _fastestPeerStats.end(),
                  PeerStatHostProtoEqual(peerStat));
   if(i == _fastestPeerStats.end()) {
@@ -335,7 +337,7 @@ unsigned int SegmentMan::calculateDownloadSpeed()
   if(_lastPeerStatDlspdMapUpdated.elapsedInMillis(250)) {
     _lastPeerStatDlspdMapUpdated.reset();
     _peerStatDlspdMap.clear();
-    for(std::deque<SharedHandle<PeerStat> >::const_iterator i =
+    for(std::vector<SharedHandle<PeerStat> >::const_iterator i =
           peerStats.begin(); i != peerStats.end(); ++i) {
       if((*i)->getStatus() == PeerStat::ACTIVE) {
         unsigned int s = (*i)->calculateDownloadSpeed();
diff --git a/src/SegmentMan.h b/src/SegmentMan.h
index b0889dd8..8ab3d96e 100644
--- a/src/SegmentMan.h
+++ b/src/SegmentMan.h
@@ -38,6 +38,7 @@
 #include "common.h"
 
 #include <deque>
+#include <vector>
 #include <map>
 
 #include "SharedHandle.h"
@@ -89,10 +90,10 @@ private:
   std::map<size_t, size_t> _segmentWrittenLengthMemo;
 
   // Used for calculating download speed.
-  std::deque<SharedHandle<PeerStat> > peerStats;
+  std::vector<SharedHandle<PeerStat> > peerStats;
 
   // Keep track of fastest PeerStat for each server
-  std::deque<SharedHandle<PeerStat> > _fastestPeerStats;
+  std::vector<SharedHandle<PeerStat> > _fastestPeerStats;
 
   // key: PeerStat's cuid, value: its download speed
   std::map<cuid_t, unsigned int> _peerStatDlspdMap;
@@ -137,14 +138,14 @@ public:
    * Fill segments which are assigned to the command whose CUID is cuid.
    * This function doesn't clear passed segments.
    */
-  void getInFlightSegment(std::deque<SharedHandle<Segment> >& segments,
+  void getInFlightSegment(std::vector<SharedHandle<Segment> >& segments,
                           cuid_t cuid);
 
   SharedHandle<Segment> getSegment(cuid_t cuid);
 
   // Checkouts segments in the range of fileEntry and push back to
   // segments until segments.size() < maxSegments holds false
-  void getSegment(std::deque<SharedHandle<Segment> >& segments,
+  void getSegment(std::vector<SharedHandle<Segment> >& segments,
                   cuid_t cuid,
                   const SharedHandle<FileEntry>& fileEntry,
                   size_t maxSegments);
@@ -198,7 +199,7 @@ public:
   // inserted.
   void registerPeerStat(const SharedHandle<PeerStat>& peerStat);
 
-  const std::deque<SharedHandle<PeerStat> >& getPeerStats() const
+  const std::vector<SharedHandle<PeerStat> >& getPeerStats() const
   {
     return peerStats;
   }
@@ -209,7 +210,7 @@ public:
   // and protocol with given peerStat, given peerStat is inserted.
   void updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat);
 
-  const std::deque<SharedHandle<PeerStat> >& getFastestPeerStats() const
+  const std::vector<SharedHandle<PeerStat> >& getFastestPeerStats() const
   {
     return _fastestPeerStats;
   }
@@ -237,8 +238,6 @@ public:
   bool allSegmentsIgnored() const;
 };
 
-typedef SharedHandle<SegmentMan> SegmentManHandle;
-
 } // namespace aria2
 
 #endif // _D_SEGMENT_MAN_H_
diff --git a/src/Sequence.h b/src/Sequence.h
index 4fdbe185..cd685170 100644
--- a/src/Sequence.h
+++ b/src/Sequence.h
@@ -35,7 +35,7 @@
 #ifndef _D_SEQUENCE_H_
 #define _D_SEQUENCE_H_
 
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
@@ -62,35 +62,36 @@ public:
     }
   };
 
-  typedef std::deque<Value> Values;
+  typedef std::vector<Value> Values;
 private:
   Values _values;
+  typename Values::iterator _cur;
 public:
   Sequence(const Values& values):
-    _values(values) {}
+    _values(values), _cur(_values.begin())  {}
 
   Sequence() {}
 
   T next()
   {
-    if(_values.empty()) {
+    if(_cur == _values.end()) {
       return T();
     }
-    T t = _values.front().next();
-    if(!_values.front().hasNext()) {
-      _values.pop_front();
+    T t = (*_cur).next();
+    if(!(*_cur).hasNext()) {
+      ++_cur;
     }
     return t;
   }
 
   bool hasNext()
   {
-    return !_values.empty();
+    return _cur != _values.end();
   }
 
-  std::deque<T> flush()
+  std::vector<T> flush()
   {
-    std::deque<T> r;
+    std::vector<T> r;
     while(hasNext()) {
       r.push_back(next());
     }
diff --git a/src/Sqlite3MozCookieParser.cc b/src/Sqlite3MozCookieParser.cc
index 9dfc3d2c..5aaf1a43 100644
--- a/src/Sqlite3MozCookieParser.cc
+++ b/src/Sqlite3MozCookieParser.cc
@@ -65,7 +65,8 @@ static int cookieRowMapper(void* data, int rowIndex,
                            char** values, char** names)
 {
   try {
-    std::deque<Cookie>& cookies = *reinterpret_cast<std::deque<Cookie>*>(data);
+    std::vector<Cookie>& cookies =
+      *reinterpret_cast<std::vector<Cookie>*>(data);
     int64_t expireDate = util::parseLLInt(toString(values[3]));
     // TODO assuming time_t is int32_t...
     if(expireDate > INT32_MAX) {
@@ -90,7 +91,7 @@ static int cookieRowMapper(void* data, int rowIndex,
   return 0;
 }
 
-std::deque<Cookie>
+std::vector<Cookie>
 Sqlite3MozCookieParser::parse(const std::string& filename) const
 {
   sqlite3* db = 0;
@@ -113,7 +114,7 @@ Sqlite3MozCookieParser::parse(const std::string& filename) const
       (StringFormat("Failed to open SQLite3 database: %s",
                     errMsg.c_str()).str());
   }
-  std::deque<Cookie> cookies;
+  std::vector<Cookie> cookies;
   char* sqlite3ErrMsg = 0;
   static const char* QUERY =
     "SELECT host, path, isSecure, expiry, name, value FROM moz_cookies";
diff --git a/src/Sqlite3MozCookieParser.h b/src/Sqlite3MozCookieParser.h
index 5276a6ee..615ce983 100644
--- a/src/Sqlite3MozCookieParser.h
+++ b/src/Sqlite3MozCookieParser.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "Cookie.h"
 
@@ -50,7 +50,7 @@ public:
 
   ~Sqlite3MozCookieParser();
 
-  std::deque<Cookie> parse(const std::string& filename) const;
+  std::vector<Cookie> parse(const std::string& filename) const;
 };
 
 } // namespace aria2
diff --git a/src/StreamCheckIntegrityEntry.cc b/src/StreamCheckIntegrityEntry.cc
index 8295f6a0..27430ebd 100644
--- a/src/StreamCheckIntegrityEntry.cc
+++ b/src/StreamCheckIntegrityEntry.cc
@@ -48,15 +48,15 @@ StreamCheckIntegrityEntry::StreamCheckIntegrityEntry(RequestGroup* requestGroup,
 StreamCheckIntegrityEntry::~StreamCheckIntegrityEntry() {}
 
 void StreamCheckIntegrityEntry::onDownloadIncomplete
-(std::deque<Command*>& commands, DownloadEngine* e)
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
-  FileAllocationEntryHandle entry
+  SharedHandle<FileAllocationEntry> entry
     (new StreamFileAllocationEntry(_requestGroup, popNextCommand()));
   proceedFileAllocation(commands, entry, e);
 }
 
-void StreamCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
-                                                   DownloadEngine* e)
+void StreamCheckIntegrityEntry::onDownloadFinished
+(std::vector<Command*>& commands, DownloadEngine* e)
 {}
 
 } // namespace aria2
diff --git a/src/StreamCheckIntegrityEntry.h b/src/StreamCheckIntegrityEntry.h
index 9f4e52bf..81f48a7c 100644
--- a/src/StreamCheckIntegrityEntry.h
+++ b/src/StreamCheckIntegrityEntry.h
@@ -50,10 +50,10 @@ public:
 
   virtual ~StreamCheckIntegrityEntry();
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e);
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 
diff --git a/src/StreamFileAllocationEntry.cc b/src/StreamFileAllocationEntry.cc
index cf89e788..00800e6e 100644
--- a/src/StreamFileAllocationEntry.cc
+++ b/src/StreamFileAllocationEntry.cc
@@ -52,8 +52,9 @@ StreamFileAllocationEntry::StreamFileAllocationEntry(RequestGroup* requestGroup,
 
 StreamFileAllocationEntry::~StreamFileAllocationEntry() {}
 
-void StreamFileAllocationEntry::prepareForNextAction(std::deque<Command*>& commands,
-                                                     DownloadEngine* e)
+void StreamFileAllocationEntry::prepareForNextAction
+(std::vector<Command*>& commands,
+ DownloadEngine* e)
 {
   _requestGroup->getDownloadContext()->resetDownloadStartTime();
   if(_nextCommand) {
diff --git a/src/StreamFileAllocationEntry.h b/src/StreamFileAllocationEntry.h
index 1870f95e..e982d98f 100644
--- a/src/StreamFileAllocationEntry.h
+++ b/src/StreamFileAllocationEntry.h
@@ -49,13 +49,10 @@ public:
 
   virtual ~StreamFileAllocationEntry();
 
-  virtual void prepareForNextAction(std::deque<Command*>& commands,
+  virtual void prepareForNextAction(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 
-typedef SharedHandle<StreamFileAllocationEntry> StreamFileAllocationEntryHandle;
-typedef std::deque<StreamFileAllocationEntryHandle> StreamFileAllocationEntries;
-
 } // namespace aria2
 
 #endif // _D_STREAM_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/TrackerWatcherCommand.cc b/src/TrackerWatcherCommand.cc
index 39ed0fb0..f9875b0b 100644
--- a/src/TrackerWatcherCommand.cc
+++ b/src/TrackerWatcherCommand.cc
@@ -99,7 +99,7 @@ bool TrackerWatcherCommand::execute() {
   if(_trackerRequestGroup.isNull()) {
     _trackerRequestGroup = createAnnounce();
     if(!_trackerRequestGroup.isNull()) {
-      std::deque<Command*> commands;
+      std::vector<Command*> commands;
       try {
         _trackerRequestGroup->createInitialCommand(commands, e);
       } catch(RecoverableException& ex) {
@@ -140,7 +140,7 @@ bool TrackerWatcherCommand::execute() {
 }
 
 std::string TrackerWatcherCommand::getTrackerResponse
-(const RequestGroupHandle& requestGroup)
+(const SharedHandle<RequestGroup>& requestGroup)
 {
   std::stringstream strm;
   unsigned char data[2048];
@@ -164,7 +164,7 @@ void TrackerWatcherCommand::processTrackerResponse
     (reinterpret_cast<const unsigned char*>(trackerResponse.c_str()),
      trackerResponse.size());
   while(!_btRuntime->isHalt() && _btRuntime->lessThanMinPeers()) {
-    PeerHandle peer = _peerStorage->getUnusedPeer();
+    SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
     if(peer.isNull()) {
       break;
     }
@@ -182,8 +182,8 @@ void TrackerWatcherCommand::processTrackerResponse
   }
 }
 
-RequestGroupHandle TrackerWatcherCommand::createAnnounce() {
-  RequestGroupHandle rg;
+SharedHandle<RequestGroup> TrackerWatcherCommand::createAnnounce() {
+  SharedHandle<RequestGroup> rg;
   if(_btAnnounce->isAnnounceReady()) {
     rg = createRequestGroup(_btAnnounce->getAnnounceUrl());
     _btAnnounce->announceStart(); // inside it, trackers++.
@@ -209,12 +209,12 @@ static bool backupTrackerIsAvailable
   }
 }
 
-RequestGroupHandle
+SharedHandle<RequestGroup>
 TrackerWatcherCommand::createRequestGroup(const std::string& uri)
 {
-  std::deque<std::string> uris;
+  std::vector<std::string> uris;
   uris.push_back(uri);
-  RequestGroupHandle rg(new RequestGroup(getOption()));
+  SharedHandle<RequestGroup> rg(new RequestGroup(getOption()));
   // If backup tracker is available, only try 2 times for each tracker
   // and if they all fails, then try next one.
   if(backupTrackerIsAvailable(_requestGroup->getDownloadContext())) {
diff --git a/src/UTMetadataPostDownloadHandler.cc b/src/UTMetadataPostDownloadHandler.cc
index ea07b602..3d8f7f10 100644
--- a/src/UTMetadataPostDownloadHandler.cc
+++ b/src/UTMetadataPostDownloadHandler.cc
@@ -74,7 +74,7 @@ UTMetadataPostDownloadHandler::UTMetadataPostDownloadHandler():
 }
 
 void UTMetadataPostDownloadHandler::getNextRequestGroups
-(std::deque<SharedHandle<RequestGroup> >& groups, RequestGroup* requestGroup)
+(std::vector<SharedHandle<RequestGroup> >& groups, RequestGroup* requestGroup)
 {
   SharedHandle<DownloadContext> dctx = requestGroup->getDownloadContext();
   const BDE& attrs = dctx->getAttribute(bittorrent::BITTORRENT);
@@ -93,9 +93,9 @@ void UTMetadataPostDownloadHandler::getNextRequestGroups
     }
   }
   if(!requestGroup->getOption()->getAsBool(PREF_BT_METADATA_ONLY)) {
-    std::deque<SharedHandle<RequestGroup> > newRgs;
+    std::vector<SharedHandle<RequestGroup> > newRgs;
     createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
-                                    std::deque<std::string>(), torrent);
+                                    std::vector<std::string>(), torrent);
   
     requestGroup->followedBy(newRgs.begin(), newRgs.end());
     groups.insert(groups.end(), newRgs.begin(), newRgs.end());
diff --git a/src/UTMetadataPostDownloadHandler.h b/src/UTMetadataPostDownloadHandler.h
index 56201d73..bc8c0b32 100644
--- a/src/UTMetadataPostDownloadHandler.h
+++ b/src/UTMetadataPostDownloadHandler.h
@@ -56,7 +56,7 @@ public:
   UTMetadataPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
diff --git a/src/UTMetadataRequestFactory.cc b/src/UTMetadataRequestFactory.cc
index 4dcc27f7..8fac6dd0 100644
--- a/src/UTMetadataRequestFactory.cc
+++ b/src/UTMetadataRequestFactory.cc
@@ -49,10 +49,11 @@ UTMetadataRequestFactory::UTMetadataRequestFactory():
   _logger(LogFactory::getInstance()) {}
 
 void UTMetadataRequestFactory::create
-(std::deque<SharedHandle<BtMessage> >& msgs, size_t num,
+(std::vector<SharedHandle<BtMessage> >& msgs, size_t num,
  const SharedHandle<PieceStorage>& pieceStorage)
 {
-  for(size_t index = 0; index < _dctx->getNumPieces() && num; ++index) {
+  for(size_t index = 0, numPieces = _dctx->getNumPieces();
+      index < numPieces && num; ++index) {
     SharedHandle<Piece> p = pieceStorage->getMissingPiece(index);
     if(p.isNull()) {
       if(_logger->debug()) {
diff --git a/src/UTMetadataRequestFactory.h b/src/UTMetadataRequestFactory.h
index c9496e95..0c62fc68 100644
--- a/src/UTMetadataRequestFactory.h
+++ b/src/UTMetadataRequestFactory.h
@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 
@@ -70,7 +70,7 @@ public:
 
   // Creates at most num of ut_metadata request message and appends
   // them to msgs. pieceStorage is used to identify missing piece.
-  void create(std::deque<SharedHandle<BtMessage> >& msgs, size_t num,
+  void create(std::vector<SharedHandle<BtMessage> >& msgs, size_t num,
               const SharedHandle<PieceStorage>& pieceStorage);
 
   void setDownloadContext(const SharedHandle<DownloadContext>& dctx)
diff --git a/src/UTPexExtensionMessage.cc b/src/UTPexExtensionMessage.cc
index 43c28966..2e54852f 100644
--- a/src/UTPexExtensionMessage.cc
+++ b/src/UTPexExtensionMessage.cc
@@ -71,11 +71,13 @@ std::string UTPexExtensionMessage::getPayload()
 }
 
 std::pair<std::string, std::string>
-UTPexExtensionMessage::createCompactPeerListAndFlag(const Peers& peers)
+UTPexExtensionMessage::createCompactPeerListAndFlag
+(const std::vector<SharedHandle<Peer> >& peers)
 {
   std::string addrstring;
   std::string flagstring;
-  for(Peers::const_iterator itr = peers.begin(); itr != peers.end(); ++itr) {
+  for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin();
+      itr != peers.end(); ++itr) {
     unsigned char compact[6];
     if(bittorrent::createcompact(compact, (*itr)->ipaddr, (*itr)->port)) {
       addrstring.append(&compact[0], &compact[6]);
@@ -96,7 +98,7 @@ void UTPexExtensionMessage::doReceivedAction()
   _peerStorage->addPeer(_freshPeers);
 }
 
-bool UTPexExtensionMessage::addFreshPeer(const PeerHandle& peer)
+bool UTPexExtensionMessage::addFreshPeer(const SharedHandle<Peer>& peer)
 {
   if(!peer->isIncomingPeer() &&
      !peer->getFirstContactTime().elapsed(_interval)) {
@@ -112,7 +114,7 @@ bool UTPexExtensionMessage::freshPeersAreFull() const
   return _freshPeers.size() >= _maxFreshPeer;
 }
 
-bool UTPexExtensionMessage::addDroppedPeer(const PeerHandle& peer)
+bool UTPexExtensionMessage::addDroppedPeer(const SharedHandle<Peer>& peer)
 {
   if(!peer->isIncomingPeer() &&
      !peer->getBadConditionStartTime().elapsed(_interval)) {
diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h
index fd0535bf..e79620d4 100644
--- a/src/UTPexExtensionMessage.h
+++ b/src/UTPexExtensionMessage.h
@@ -38,7 +38,7 @@
 #include "ExtensionMessage.h"
 
 #include <utility>
-#include <deque>
+#include <vector>
 
 #include "a2time.h"
 
@@ -53,9 +53,9 @@ class UTPexExtensionMessage:public ExtensionMessage {
 private:
   uint8_t _extensionMessageID;
 
-  std::deque<SharedHandle<Peer> > _freshPeers;
+  std::vector<SharedHandle<Peer> > _freshPeers;
 
-  std::deque<SharedHandle<Peer> > _droppedPeers;
+  std::vector<SharedHandle<Peer> > _droppedPeers;
 
   SharedHandle<PeerStorage> _peerStorage;
 
@@ -66,7 +66,7 @@ private:
   size_t _maxDroppedPeer;
 
   std::pair<std::string, std::string>
-  createCompactPeerListAndFlag(const std::deque<SharedHandle<Peer> >& peers);
+  createCompactPeerListAndFlag(const std::vector<SharedHandle<Peer> >& peers);
 
 public:
   UTPexExtensionMessage(uint8_t extensionMessageID);
@@ -93,7 +93,7 @@ public:
 
   bool addFreshPeer(const SharedHandle<Peer>& peer);
 
-  const std::deque<SharedHandle<Peer> >& getFreshPeers() const
+  const std::vector<SharedHandle<Peer> >& getFreshPeers() const
   {
     return _freshPeers;
   }
@@ -102,7 +102,7 @@ public:
 
   bool addDroppedPeer(const SharedHandle<Peer>& peer);
 
-  const std::deque<SharedHandle<Peer> >& getDroppedPeers() const
+  const std::vector<SharedHandle<Peer> >& getDroppedPeers() const
   {
     return _droppedPeers;
   }
diff --git a/src/UnionSeedCriteria.h b/src/UnionSeedCriteria.h
index 8257c507..1aa0e598 100644
--- a/src/UnionSeedCriteria.h
+++ b/src/UnionSeedCriteria.h
@@ -37,23 +37,26 @@
 
 #include "SeedCriteria.h"
 #include <algorithm>
+#include <vector>
 
 namespace aria2 {
 
 class UnionSeedCriteria : public SeedCriteria {
 private:
-  SeedCriterion criterion;
+  std::vector<SharedHandle<SeedCriteria> > _criterion;
 
   class Reset {
   public:
-    void operator()(SeedCriteriaHandle cri) {
+    void operator()(SharedHandle<SeedCriteria> cri)
+    {
       cri->reset();
     }
   };
 
   class Eval {
   public:
-    bool operator()(SeedCriteriaHandle cri) {
+    bool operator()(SharedHandle<SeedCriteria> cri)
+    {
       return cri->evaluate();
     }
   };
@@ -62,23 +65,26 @@ public:
   virtual ~UnionSeedCriteria() {}
 
     
-  virtual void reset() {
-    std::for_each(criterion.begin(), criterion.end(), Reset());
+  virtual void reset()
+  {
+    std::for_each(_criterion.begin(), _criterion.end(), Reset());
   }
 
-  virtual bool evaluate() {
-    SeedCriterion::iterator itr = std::find_if(criterion.begin(),
-                                               criterion.end(),
-                                               Eval());
-    return itr != criterion.end();
+  virtual bool evaluate()
+  {
+    std::vector<SharedHandle<SeedCriteria> >::iterator itr =
+      std::find_if(_criterion.begin(), _criterion.end(), Eval());
+    return itr != _criterion.end();
   }
 
-  void addSeedCriteria(SeedCriteriaHandle cri) {
-    criterion.push_back(cri);
+  void addSeedCriteria(const SharedHandle<SeedCriteria>& cri)
+  {
+    _criterion.push_back(cri);
   }
 
-  const SeedCriterion& getSeedCriterion() const {
-    return criterion;
+  const std::vector<SharedHandle<SeedCriteria> >& getSeedCriterion() const
+  {
+    return _criterion;
   }
 };
 
diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc
index 573b19bb..12b9363d 100644
--- a/src/UnknownLengthPieceStorage.cc
+++ b/src/UnknownLengthPieceStorage.cc
@@ -84,7 +84,7 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece(const SharedHandl
 }
 
 SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   abort();
 }
@@ -95,7 +95,7 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getMissingFastPiece(const SharedH
 }
 
 SharedHandle<Piece> UnknownLengthPieceStorage::getMissingFastPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   abort();
 }
@@ -121,7 +121,7 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getSparseMissingUnusedPiece
   }
 }
 
-PieceHandle UnknownLengthPieceStorage::getMissingPiece(size_t index)
+SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece(size_t index)
 {
   if(index == 0) {
     return getSparseMissingUnusedPiece(0, 0);
@@ -130,7 +130,7 @@ PieceHandle UnknownLengthPieceStorage::getMissingPiece(size_t index)
   }
 }
 
-PieceHandle UnknownLengthPieceStorage::getPiece(size_t index)
+SharedHandle<Piece> UnknownLengthPieceStorage::getPiece(size_t index)
 {
   if(index == 0) {
     if(_piece.isNull()) {
@@ -143,7 +143,7 @@ PieceHandle UnknownLengthPieceStorage::getPiece(size_t index)
   }
 }
 
-void UnknownLengthPieceStorage::completePiece(const PieceHandle& piece)
+void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 {
   if(_piece == piece) {
     _downloadFinished = true;
@@ -153,7 +153,7 @@ void UnknownLengthPieceStorage::completePiece(const PieceHandle& piece)
   }
 }
 
-void UnknownLengthPieceStorage::cancelPiece(const PieceHandle& piece)
+void UnknownLengthPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
 {
   if(_piece == piece) {
     _piece.reset();
@@ -213,10 +213,12 @@ void UnknownLengthPieceStorage::markPieceMissing(size_t index)
   abort();
 }
 
-void UnknownLengthPieceStorage::getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces)
+void UnknownLengthPieceStorage::getInFlightPieces
+(std::vector<SharedHandle<Piece> >& pieces)
 {}
 
-void UnknownLengthPieceStorage::setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory)
+void UnknownLengthPieceStorage::setDiskWriterFactory
+(const DiskWriterFactoryHandle& diskWriterFactory)
 {
   _diskWriterFactory = diskWriterFactory;
 }
diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h
index b05414cb..3c9cfaf1 100644
--- a/src/UnknownLengthPieceStorage.h
+++ b/src/UnknownLengthPieceStorage.h
@@ -82,7 +82,7 @@ public:
   virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer);
 
   virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
   /**
    * Returns a piece that the peer has but localhost doesn't.
@@ -94,7 +94,7 @@ public:
   virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer);
 
   virtual SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
 #endif // ENABLE_BITTORRENT
 
@@ -228,7 +228,7 @@ public:
    * newer than lastCheckTime.
    */
   virtual void
-  getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+  getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                             int32_t myCuid, const Time& lastCheckTime)
   {}
 
@@ -251,14 +251,15 @@ public:
    * Do nothing because loading in-flight piece is not supported for this
    * class.
    */
-  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {}
+  virtual void addInFlightPiece
+  (const std::vector<SharedHandle<Piece> >& pieces) {}
 
   virtual size_t countInFlightPiece()
   {
     return 0;
   }
 
-  virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces);
+  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces);
 
   virtual void addPieceStats(size_t index) {}
 
diff --git a/src/UriListParser.cc b/src/UriListParser.cc
index 38303966..51618e0e 100644
--- a/src/UriListParser.cc
+++ b/src/UriListParser.cc
@@ -64,7 +64,7 @@ void UriListParser::getOptions(Option& op)
   _optparser.parse(op, ss);
 }
 
-void UriListParser::parseNext(std::deque<std::string>& uris, Option& op)
+void UriListParser::parseNext(std::vector<std::string>& uris, Option& op)
 {
   if(_line.empty()) {
     getline(_in, _line);
diff --git a/src/UriListParser.h b/src/UriListParser.h
index 0f22c719..f5199db9 100644
--- a/src/UriListParser.h
+++ b/src/UriListParser.h
@@ -60,7 +60,7 @@ public:
 
   ~UriListParser();
 
-  void parseNext(std::deque<std::string>& uris, Option& op);
+  void parseNext(std::vector<std::string>& uris, Option& op);
 
   bool hasNext() const;
 };
diff --git a/src/XmlRpcMethodImpl.cc b/src/XmlRpcMethodImpl.cc
index d2771cdc..36a8b9c6 100644
--- a/src/XmlRpcMethodImpl.cc
+++ b/src/XmlRpcMethodImpl.cc
@@ -165,6 +165,17 @@ static void getPosParam(const BDE& params, size_t posParamIndex,
   }
 } 
 
+template<typename OutputIterator>
+static void extractUris(OutputIterator out, const BDE& src)
+{
+  for(BDE::List::const_iterator i = src.listBegin(), end = src.listEnd();
+      i != end; ++i) {
+    if((*i).isString()) {
+      out++ = (*i).s();
+    }
+  }
+}
+
 BDE AddUriXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
 {
   const BDE& params = req._params;
@@ -172,13 +183,8 @@ BDE AddUriXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
   if(params.empty() || !params[0].isList() || params[0].empty()) {
     throw DL_ABORT_EX("URI is not provided.");
   }
-  std::deque<std::string> uris;
-  for(BDE::List::const_iterator i = params[0].listBegin();
-      i != params[0].listEnd(); ++i) {
-    if((*i).isString()) {
-      uris.push_back((*i).s());
-    }
-  }
+  std::vector<std::string> uris;
+  extractUris(std::back_inserter(uris), params[0]);
 
   SharedHandle<Option> requestOption(new Option(*e->option));
   if(hasDictParam(params, 1)) {
@@ -188,7 +194,7 @@ BDE AddUriXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
   bool posGiven = false;
   getPosParam(params, 2, posGiven, pos);
 
-  std::deque<SharedHandle<RequestGroup> > result;
+  std::vector<SharedHandle<RequestGroup> > result;
   createRequestGroupForUri(result, requestOption, uris,
                            /* ignoreForceSeq = */ true,
                            /* ignoreLocalPath = */ true);
@@ -210,14 +216,9 @@ BDE AddTorrentXmlRpcMethod::process
     throw DL_ABORT_EX("Torrent data is not provided.");
   }
   
-  std::deque<std::string> uris;
+  std::vector<std::string> uris;
   if(params.size() > 1 && params[1].isList()) {
-    for(BDE::List::const_iterator i = params[1].listBegin();
-        i != params[1].listEnd(); ++i) {
-      if((*i).isString()) {
-        uris.push_back((*i).s());
-      }
-    }
+    extractUris(std::back_inserter(uris), params[1]);
   }
   SharedHandle<Option> requestOption(new Option(*e->option));
   if(hasDictParam(params, 2)) {
@@ -227,7 +228,7 @@ BDE AddTorrentXmlRpcMethod::process
   bool posGiven = false;
   getPosParam(params, 3, posGiven, pos);
 
-  std::deque<SharedHandle<RequestGroup> > result;
+  std::vector<SharedHandle<RequestGroup> > result;
   createRequestGroupForBitTorrent(result, requestOption,
                                   uris,
                                   params[0].s());
@@ -258,7 +259,7 @@ BDE AddMetalinkXmlRpcMethod::process
   bool posGiven = false;
   getPosParam(params, 2, posGiven, pos);
 
-  std::deque<SharedHandle<RequestGroup> > result;
+  std::vector<SharedHandle<RequestGroup> > result;
   createRequestGroupForMetalink(result, requestOption, params[0].s());
   if(!result.empty()) {
     if(posGiven) {
@@ -267,7 +268,7 @@ BDE AddMetalinkXmlRpcMethod::process
       e->_requestGroupMan->addReservedGroup(result);
     }
     BDE gids = BDE::list();
-    for(std::deque<SharedHandle<RequestGroup> >::const_iterator i =
+    for(std::vector<SharedHandle<RequestGroup> >::const_iterator i =
           result.begin(); i != result.end(); ++i) {
       gids << BDE(util::itos((*i)->getGID()));
     }
@@ -322,9 +323,9 @@ static void createFileEntry(BDE& files, InputIterator first, InputIterator last)
     entry[KEY_LENGTH] = util::uitos((*first)->getLength());
 
     BDE uriList = BDE::list();
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     (*first)->getUris(uris);
-    for(std::deque<std::string>::const_iterator i = uris.begin();
+    for(std::vector<std::string>::const_iterator i = uris.begin();
         i != uris.end(); ++i) {
       BDE uriEntry = BDE::dict();
       uriEntry[KEY_URI] = *i;
@@ -423,7 +424,7 @@ static void gatherProgressBitTorrent
     SharedHandle<PeerStorage> peerStorage = btObject._peerStorage;
     assert(!peerStorage.isNull());
 
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     peerStorage->getActivePeers(peers);
     entryDict[KEY_NUM_SEEDERS] = countSeeder(peers.begin(), peers.end());
   }
@@ -431,9 +432,9 @@ static void gatherProgressBitTorrent
 
 static void gatherPeer(BDE& peers, const SharedHandle<PeerStorage>& ps)
 {
-  std::deque<SharedHandle<Peer> > activePeers;
+  std::vector<SharedHandle<Peer> > activePeers;
   ps->getActivePeers(activePeers);
-  for(std::deque<SharedHandle<Peer> >::const_iterator i =
+  for(std::vector<SharedHandle<Peer> >::const_iterator i =
         activePeers.begin(); i != activePeers.end(); ++i) {
     BDE peerEntry = BDE::dict();
     peerEntry[KEY_PEER_ID] = util::torrentUrlencode((*i)->getPeerId(),
@@ -558,9 +559,9 @@ BDE GetUrisXmlRpcMethod::process
   BDE uriList = BDE::list();
   // TODO Current implementation just returns first FileEntry's URIs.
   if(!group->getDownloadContext()->getFileEntries().empty()) {
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
-    for(std::deque<std::string>::const_iterator i = uris.begin();
+    for(std::vector<std::string>::const_iterator i = uris.begin();
         i != uris.end(); ++i) {
       BDE entry = BDE::dict();
       entry[KEY_URI] = *i;
diff --git a/src/bittorrent_helper.cc b/src/bittorrent_helper.cc
index 02b3d187..9538db8d 100644
--- a/src/bittorrent_helper.cc
+++ b/src/bittorrent_helper.cc
@@ -254,7 +254,7 @@ static void extractFileEntries
         throw DL_ABORT_EX
           (StringFormat(MSG_DIR_TRAVERSAL_DETECTED, path.c_str()).str());
       }
-      std::deque<std::string> uris;
+      std::vector<std::string> uris;
       createUri(urlList.begin(), urlList.end(), std::back_inserter(uris), path);
       SharedHandle<FileEntry> fileEntry
         (new FileEntry(util::applyDir(ctx->getDir(), util::escapePath(path)),
@@ -276,7 +276,7 @@ static void extractFileEntries
 
     // For each uri in urlList, if it ends with '/', then
     // concatenate name to it. Specification just says so.
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     for(std::vector<std::string>::const_iterator i = urlList.begin();
         i != urlList.end(); ++i) {
       if(util::endsWith(*i, A2STR::SLASH_C)) {
@@ -360,7 +360,7 @@ static void processRootDictionary
  const BDE& rootDict,
  const std::string& defaultName,
  const std::string& overrideName,
- const std::deque<std::string>& uris)
+ const std::vector<std::string>& uris)
 {
   if(!rootDict.isDict()) {
     throw DL_ABORT_EX("torrent file does not contain a root dictionary.");
@@ -465,12 +465,12 @@ void load(const std::string& torrentFile,
                         bencode::decodeFromFile(torrentFile),
                         torrentFile,
                         overrideName,
-                        std::deque<std::string>());
+                        std::vector<std::string>());
 }
 
 void load(const std::string& torrentFile,
           const SharedHandle<DownloadContext>& ctx,
-          const std::deque<std::string>& uris,
+          const std::vector<std::string>& uris,
           const std::string& overrideName)
 {
   processRootDictionary(ctx,
@@ -490,13 +490,13 @@ void loadFromMemory(const unsigned char* content,
                         bencode::decode(content, length),
                         defaultName,
                         overrideName,
-                        std::deque<std::string>());
+                        std::vector<std::string>());
 }
 
 void loadFromMemory(const unsigned char* content,
                     size_t length,
                     const SharedHandle<DownloadContext>& ctx,
-                    const std::deque<std::string>& uris,
+                    const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName)
 {
@@ -516,12 +516,12 @@ void loadFromMemory(const std::string& context,
     (ctx,
      bencode::decode(context),
      defaultName, overrideName,
-     std::deque<std::string>());
+     std::vector<std::string>());
 }
 
 void loadFromMemory(const std::string& context,
                     const SharedHandle<DownloadContext>& ctx,
-                    const std::deque<std::string>& uris,
+                    const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName)
 {
diff --git a/src/bittorrent_helper.h b/src/bittorrent_helper.h
index e0b3fcf8..0a7e4c19 100644
--- a/src/bittorrent_helper.h
+++ b/src/bittorrent_helper.h
@@ -39,7 +39,6 @@
 
 #include <string>
 #include <vector>
-#include <deque>
 #include <utility>
 
 #include "SharedHandle.h"
@@ -94,7 +93,7 @@ void load(const std::string& torrentFile,
 
 void load(const std::string& torrentFile,
           const SharedHandle<DownloadContext>& ctx,
-          const std::deque<std::string>& uris,
+          const std::vector<std::string>& uris,
           const std::string& overrideName = "");
 
 void loadFromMemory(const unsigned char* content, size_t length,
@@ -104,7 +103,7 @@ void loadFromMemory(const unsigned char* content, size_t length,
 
 void loadFromMemory(const unsigned char* content, size_t length,
                     const SharedHandle<DownloadContext>& ctx,
-                    const std::deque<std::string>& uris,
+                    const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
@@ -115,7 +114,7 @@ void loadFromMemory(const std::string& context,
 
 void loadFromMemory(const std::string& context,
                     const SharedHandle<DownloadContext>& ctx,
-                    const std::deque<std::string>& uris,
+                    const std::vector<std::string>& uris,
                     const std::string& defaultName,
                     const std::string& overrideName = "");
 
diff --git a/src/download_helper.cc b/src/download_helper.cc
index 86e2e7ae..ad6bed5a 100644
--- a/src/download_helper.cc
+++ b/src/download_helper.cc
@@ -38,7 +38,6 @@
 #include <fstream>
 #include <algorithm>
 #include <sstream>
-#include <vector>
 
 #include "RequestGroup.h"
 #include "Option.h"
@@ -153,11 +152,11 @@ const std::set<std::string>& listRequestOptions()
 }
 
 static void unfoldURI
-(std::deque<std::string>& result, const std::deque<std::string>& args)
+(std::vector<std::string>& result, const std::vector<std::string>& args)
 {
   ParameterizedStringParser p;
   PStringBuildVisitor v;
-  for(std::deque<std::string>::const_iterator itr = args.begin();
+  for(std::vector<std::string>::const_iterator itr = args.begin();
       itr != args.end(); ++itr) {
     v.reset();
     p.parse(*itr)->accept(v);
@@ -165,9 +164,10 @@ static void unfoldURI
   }
 }
 
-static void splitURI(std::deque<std::string>& result,
-                     std::deque<std::string>::const_iterator begin,
-                     std::deque<std::string>::const_iterator end,
+template<typename InputIterator>
+static void splitURI(std::vector<std::string>& result,
+                     InputIterator begin,
+                     InputIterator end,
                      size_t numSplit)
 {
   size_t numURIs = std::distance(begin, end);
@@ -182,7 +182,7 @@ static void splitURI(std::deque<std::string>& result,
 }
 
 static SharedHandle<RequestGroup> createRequestGroup
-(const SharedHandle<Option>& option, const std::deque<std::string>& uris,
+(const SharedHandle<Option>& option, const std::vector<std::string>& uris,
  bool useOutOption = false)
 {
   SharedHandle<RequestGroup> rg(new RequestGroup(option));
@@ -204,7 +204,7 @@ static
 SharedHandle<RequestGroup>
 createBtRequestGroup(const std::string& torrentFilePath,
                      const SharedHandle<Option>& option,
-                     const std::deque<std::string>& auxUris,
+                     const std::vector<std::string>& auxUris,
                      const std::string& torrentData = "")
 {
   SharedHandle<RequestGroup> rg(new RequestGroup(option));
@@ -234,7 +234,7 @@ static
 SharedHandle<RequestGroup>
 createBtMagnetRequestGroup(const std::string& magnetLink,
                            const SharedHandle<Option>& option,
-                           const std::deque<std::string>& auxUris)
+                           const std::vector<std::string>& auxUris)
 {
   SharedHandle<RequestGroup> rg(new RequestGroup(option));
   SharedHandle<DownloadContext> dctx
@@ -259,12 +259,12 @@ createBtMagnetRequestGroup(const std::string& magnetLink,
 }
 
 void createRequestGroupForBitTorrent
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
- const std::deque<std::string>& uris,
+ const std::vector<std::string>& uris,
  const std::string& torrentData)
 {
-  std::deque<std::string> nargs;
+  std::vector<std::string> nargs;
   if(option->get(PREF_PARAMETERIZED_URI) == V_TRUE) {
     unfoldURI(nargs, uris);
   } else {
@@ -272,7 +272,7 @@ void createRequestGroupForBitTorrent
   }
   // we ignore -Z option here
   size_t numSplit = option->getAsInt(PREF_SPLIT);
-  std::deque<std::string> auxUris;
+  std::vector<std::string> auxUris;
   splitURI(auxUris, nargs.begin(), nargs.end(), numSplit);
   SharedHandle<RequestGroup> rg =
     createBtRequestGroup(option->get(PREF_TORRENT_FILE), option, auxUris,
@@ -285,7 +285,7 @@ void createRequestGroupForBitTorrent
 
 #ifdef ENABLE_METALINK
 void createRequestGroupForMetalink
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
  const std::string& metalinkData)
 {
@@ -306,12 +306,12 @@ void createRequestGroupForMetalink
 
 class AccRequestGroup {
 private:
-  std::deque<SharedHandle<RequestGroup> >& _requestGroups;
+  std::vector<SharedHandle<RequestGroup> >& _requestGroups;
   ProtocolDetector _detector;
   SharedHandle<Option> _option;
   bool _ignoreLocalPath;
 public:
-  AccRequestGroup(std::deque<SharedHandle<RequestGroup> >& requestGroups,
+  AccRequestGroup(std::vector<SharedHandle<RequestGroup> >& requestGroups,
                   const SharedHandle<Option>& option,
                   bool ignoreLocalPath = false):
     _requestGroups(requestGroups), _option(option),
@@ -321,7 +321,7 @@ public:
   operator()(const std::string& uri)
   {
     if(_detector.isStreamProtocol(uri)) {
-      std::deque<std::string> streamURIs;
+      std::vector<std::string> streamURIs;
       size_t numSplit = _option->getAsInt(PREF_SPLIT);
       for(size_t i = 0; i < numSplit; ++i) {
         streamURIs.push_back(uri);
@@ -335,7 +335,7 @@ public:
     else if(_detector.guessTorrentMagnet(uri)) {
       try {
         SharedHandle<RequestGroup> group =
-          createBtMagnetRequestGroup(uri, _option, std::deque<std::string>());
+          createBtMagnetRequestGroup(uri, _option, std::vector<std::string>());
         _requestGroups.push_back(group);
       } catch(RecoverableException& e) {
         // error occurred while parsing torrent file.
@@ -344,8 +344,8 @@ public:
       }
     } else if(!_ignoreLocalPath && _detector.guessTorrentFile(uri)) {
       try {
-        _requestGroups.push_back(createBtRequestGroup(uri, _option,
-                                                      std::deque<std::string>()));
+        _requestGroups.push_back
+          (createBtRequestGroup(uri, _option, std::vector<std::string>()));
       } catch(RecoverableException& e) {
         // error occurred while parsing torrent file.
         // We simply ignore it. 
@@ -380,13 +380,13 @@ public:
 };
 
 void createRequestGroupForUri
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
- const std::deque<std::string>& uris,
+ const std::vector<std::string>& uris,
  bool ignoreForceSequential,
  bool ignoreLocalPath)
 {
-  std::deque<std::string> nargs;
+  std::vector<std::string> nargs;
   if(option->get(PREF_PARAMETERIZED_URI) == V_TRUE) {
     unfoldURI(nargs, uris);
   } else {
@@ -396,12 +396,12 @@ void createRequestGroupForUri
     std::for_each(nargs.begin(), nargs.end(),
                   AccRequestGroup(result, option, ignoreLocalPath));
   } else {
-    std::deque<std::string>::iterator strmProtoEnd =
+    std::vector<std::string>::iterator strmProtoEnd =
       std::stable_partition(nargs.begin(), nargs.end(), StreamProtocolFilter());
     // let's process http/ftp protocols first.
     if(nargs.begin() != strmProtoEnd) {
       size_t numSplit = option->getAsInt(PREF_SPLIT);
-      std::deque<std::string> streamURIs;
+      std::vector<std::string> streamURIs;
       splitURI(streamURIs, nargs.begin(), strmProtoEnd,
                numSplit);
       SharedHandle<RequestGroup> rg =
@@ -416,13 +416,13 @@ void createRequestGroupForUri
 }
 
 static void createRequestGroupForUriList
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
  std::istream& in)
 {
   UriListParser p(in);
   while(p.hasNext()) {
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     SharedHandle<Option> tempOption(new Option());
     p.parseNext(uris, *tempOption.get());
     if(uris.empty()) {
@@ -442,7 +442,7 @@ static void createRequestGroupForUriList
 }
 
 void createRequestGroupForUriList
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option)
 {
   if(option->get(PREF_INPUT_FILE) == "-") {
diff --git a/src/download_helper.h b/src/download_helper.h
index 68074a4f..e6d00dd4 100644
--- a/src/download_helper.h
+++ b/src/download_helper.h
@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 #include <set>
 
 #include "SharedHandle.h"
@@ -56,9 +56,9 @@ const std::set<std::string>& listRequestOptions();
 // it is used as a content of torrent file instead. In this function,
 // force-sequential is ignored.
 void createRequestGroupForBitTorrent
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
- const std::deque<std::string>& uris,
+ const std::vector<std::string>& uris,
  const std::string& torrentData = "");
 #endif // ENABLE_BITTORRENT
 
@@ -67,7 +67,7 @@ void createRequestGroupForBitTorrent
 // metalink-file option. If non-empty metalinkData is specified, it is
 // used as a content of metalink file instead.
 void createRequestGroupForMetalink
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
  const std::string& metalinkData = "");
 #endif // ENABLE_METALINK
@@ -78,15 +78,15 @@ void createRequestGroupForMetalink
 // The additional out and dir options can be specified after each line of URIs.
 // This optional line must start with white space(s).
 void createRequestGroupForUriList
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option);
 
 // Create RequestGroup object using provided uris.  If ignoreLocalPath
 // is true, a path to torrent file abd metalink file are ignored.
 void createRequestGroupForUri
-(std::deque<SharedHandle<RequestGroup> >& result,
+(std::vector<SharedHandle<RequestGroup> >& result,
  const SharedHandle<Option>& option,
- const std::deque<std::string>& uris,
+ const std::vector<std::string>& uris,
  bool ignoreForceSequential = false,
  bool ignoreLocalPath = false);
 
diff --git a/src/magnet.cc b/src/magnet.cc
index b74e4f1d..c74c4ba2 100644
--- a/src/magnet.cc
+++ b/src/magnet.cc
@@ -45,11 +45,11 @@ BDE parse(const std::string& magnet)
   if(!util::startsWith(magnet, "magnet:?")) {
     return result;
   }
-  std::deque<std::string> queries;
+  std::vector<std::string> queries;
   util::split(std::string(magnet.begin()+8, magnet.end()),
               std::back_inserter(queries), "&");
   BDE dict = BDE::dict();
-  for(std::deque<std::string>::const_iterator i = queries.begin();
+  for(std::vector<std::string>::const_iterator i = queries.begin();
       i != queries.end(); ++i) {
     std::pair<std::string, std::string> kv;
     util::split(kv, *i, '=');
diff --git a/src/main.cc b/src/main.cc
index 03cac9fa..7ad7e963 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -38,10 +38,10 @@
 #include <unistd.h>
 #include <getopt.h>
 
-#include <deque>
 #include <fstream>
 #include <iostream>
 #include <numeric>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "LogFactory.h"
@@ -132,10 +132,10 @@ static void showMetalinkFile
 
 #if defined ENABLE_BITTORRENT || defined ENABLE_METALINK
 static void showFiles
-(const std::deque<std::string>& uris, const SharedHandle<Option>& op)
+(const std::vector<std::string>& uris, const SharedHandle<Option>& op)
 {
   ProtocolDetector dt;
-  for(std::deque<std::string>::const_iterator i = uris.begin();
+  for(std::vector<std::string>::const_iterator i = uris.begin();
       i != uris.end(); ++i) {
     printf(">>> ");
     printf(MSG_SHOW_FILES, (*i).c_str());
@@ -162,12 +162,12 @@ static void showFiles
 }
 #endif // ENABLE_BITTORRENT || ENABLE_METALINK
 
-extern void option_processing(Option& option, std::deque<std::string>& uris,
+extern void option_processing(Option& option, std::vector<std::string>& uris,
                               int argc, char* const argv[]);
 
 downloadresultcode::RESULT main(int argc, char* argv[])
 {
-  std::deque<std::string> args;
+  std::vector<std::string> args;
   SharedHandle<Option> op(new Option());
   option_processing(*op.get(), args, argc, argv);
 
@@ -227,7 +227,7 @@ downloadresultcode::RESULT main(int argc, char* argv[])
   // died.
   util::setGlobalSignalHandler(SIGCHLD, SIG_IGN, 0);
 #endif // SIGCHILD
-  std::deque<SharedHandle<RequestGroup> > requestGroups;
+  std::vector<SharedHandle<RequestGroup> > requestGroups;
 #ifdef ENABLE_BITTORRENT
   if(!op->blank(PREF_TORRENT_FILE)) {
     if(op->get(PREF_SHOW_FILES) == V_TRUE) {
diff --git a/src/option_processing.cc b/src/option_processing.cc
index d97652b4..ce9c9009 100644
--- a/src/option_processing.cc
+++ b/src/option_processing.cc
@@ -82,7 +82,7 @@ static void overrideWithEnv(Option& op, const OptionParser& optionParser,
   }
 }
 
-void option_processing(Option& op, std::deque<std::string>& uris,
+void option_processing(Option& op, std::vector<std::string>& uris,
                        int argc, char* const argv[])
 {
   OptionParser oparser;
diff --git a/src/util.h b/src/util.h
index e7b83e56..d1985209 100644
--- a/src/util.h
+++ b/src/util.h
@@ -41,7 +41,6 @@
 
 #include <string>
 #include <utility>
-#include <deque>
 #include <iosfwd>
 #include <ostream>
 #include <numeric>
@@ -291,7 +290,7 @@ std::string htmlEscape(const std::string& src);
 template<typename InputIterator>
 std::string joinPath(InputIterator first, InputIterator last)
 {
-  std::deque<std::string> elements;
+  std::vector<std::string> elements;
   for(;first != last; ++first) {
     if(*first == "..") {
       if(!elements.empty()) {
diff --git a/test/BNodeTest.cc b/test/BNodeTest.cc
index 8e86a19c..f5ddac6e 100644
--- a/test/BNodeTest.cc
+++ b/test/BNodeTest.cc
@@ -156,7 +156,7 @@ void BNodeTest::testFindClosestKNodes()
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      std::deque<SharedHandle<DHTNode> > nodes;
+      std::vector<SharedHandle<DHTNode> > nodes;
       BNode::findClosestKNodes(nodes, bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket4->isInRange(nodes[0]));
@@ -171,7 +171,7 @@ void BNodeTest::testFindClosestKNodes()
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0xf0, DHT_ID_LENGTH);
-      std::deque<SharedHandle<DHTNode> > nodes;
+      std::vector<SharedHandle<DHTNode> > nodes;
       BNode::findClosestKNodes(nodes, bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket1->isInRange(nodes[0]));
@@ -190,7 +190,7 @@ void BNodeTest::testFindClosestKNodes()
       }
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      std::deque<SharedHandle<DHTNode> > nodes;
+      std::vector<SharedHandle<DHTNode> > nodes;
       BNode::findClosestKNodes(nodes, bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       for(size_t i = 0; i < DHTBucket::K; ++i) {
@@ -217,7 +217,7 @@ void BNodeTest::testEnumerateBucket()
 
   {
     BNode b(bucket1);
-    std::deque<SharedHandle<DHTBucket> > buckets;
+    std::vector<SharedHandle<DHTBucket> > buckets;
     BNode::enumerateBucket(buckets, &b);
     CPPUNIT_ASSERT_EQUAL((size_t)1, buckets.size());
     CPPUNIT_ASSERT(bucket1 == buckets[0]);
@@ -245,7 +245,7 @@ void BNodeTest::testEnumerateBucket()
     bp4->setLeft(bp3);
     bp4->setRight(b2);
 
-    std::deque<SharedHandle<DHTBucket> > buckets;
+    std::vector<SharedHandle<DHTBucket> > buckets;
     BNode::enumerateBucket(buckets, bp4);
     CPPUNIT_ASSERT_EQUAL((size_t)5, buckets.size());
     CPPUNIT_ASSERT(bucket1 == buckets[0]);
diff --git a/test/BtDependencyTest.cc b/test/BtDependencyTest.cc
index 312fa54b..856e7835 100644
--- a/test/BtDependencyTest.cc
+++ b/test/BtDependencyTest.cc
@@ -38,7 +38,7 @@ class BtDependencyTest:public CppUnit::TestFixture {
     SharedHandle<DownloadContext> dctx
       (new DownloadContext(0, 0, "/tmp/outfile.path"));
     dctx->setDir("/tmp");
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     uris.push_back("http://localhost/outfile.path");
     SharedHandle<FileEntry> fileEntry = dctx->getFirstFileEntry();
     fileEntry->setUris(uris);
diff --git a/test/BtPostDownloadHandlerTest.cc b/test/BtPostDownloadHandlerTest.cc
index 2cc732cd..3f48f31d 100644
--- a/test/BtPostDownloadHandlerTest.cc
+++ b/test/BtPostDownloadHandlerTest.cc
@@ -71,7 +71,7 @@ void BtPostDownloadHandlerTest::testGetNextRequestGroups()
   rg.initPieceStorage();
 
   BtPostDownloadHandler handler;
-  std::deque<SharedHandle<RequestGroup> > groups;
+  std::vector<SharedHandle<RequestGroup> > groups;
   handler.getNextRequestGroups(groups, &rg);
   CPPUNIT_ASSERT_EQUAL((size_t)1, groups.size());
   CPPUNIT_ASSERT_EQUAL
diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc
index 8314b0f8..62dd95bd 100644
--- a/test/BtRequestMessageTest.cc
+++ b/test/BtRequestMessageTest.cc
@@ -269,9 +269,7 @@ void BtRequestMessageTest::testValidate() {
   msg.setBtMessageValidator
     (SharedHandle<BtMessageValidator>
      (new RangeBtMessageValidator(&msg, 1024, 256*1024)));
-  std::deque<std::string> errors;
-
-  msg.validate(errors);
+  msg.validate();
 }
 
 void BtRequestMessageTest::testValidate_lengthTooLong() {
@@ -279,9 +277,8 @@ void BtRequestMessageTest::testValidate_lengthTooLong() {
   msg.setBtMessageValidator
     (SharedHandle<BtMessageValidator>
      (new RangeBtMessageValidator(&msg, 1024, 256*1024)));
-  std::deque<std::string> errors;
   try {
-    msg.validate(errors);
+    msg.validate();
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(DlAbortEx& e) {
     CPPUNIT_ASSERT_EQUAL(std::string("Length too long: 16385 > 16KB"),
diff --git a/test/CookieStorageTest.cc b/test/CookieStorageTest.cc
index 8ca7acf0..8976cbe5 100644
--- a/test/CookieStorageTest.cc
+++ b/test/CookieStorageTest.cc
@@ -168,16 +168,16 @@ void CookieStorageTest::testCriteriaFind()
   CPPUNIT_ASSERT(st.store(juliet1));
   CPPUNIT_ASSERT(st.store(juliet2));
 
-  std::deque<Cookie> aria2Slash = st.criteriaFind("www.dl.aria2.org", "/",
-                                                  0, false);
+  std::vector<Cookie> aria2Slash = st.criteriaFind("www.dl.aria2.org", "/",
+                                                   0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)2, aria2Slash.size());
   CPPUNIT_ASSERT(std::find(aria2Slash.begin(), aria2Slash.end(), alpha)
                  != aria2Slash.end());
   CPPUNIT_ASSERT(std::find(aria2Slash.begin(), aria2Slash.end(), echo)
                  != aria2Slash.end());
 
-  std::deque<Cookie> aria2SlashFoo = st.criteriaFind("www.dl.aria2.org", "/foo",
-                                                     0, false);
+  std::vector<Cookie> aria2SlashFoo = st.criteriaFind("www.dl.aria2.org","/foo",
+                                                      0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)3, aria2SlashFoo.size());
   CPPUNIT_ASSERT_EQUAL(std::string("bravo"), aria2SlashFoo[0].getName());
   CPPUNIT_ASSERT(std::find(aria2SlashFoo.begin(), aria2SlashFoo.end(), alpha)
@@ -185,32 +185,32 @@ void CookieStorageTest::testCriteriaFind()
   CPPUNIT_ASSERT(std::find(aria2SlashFoo.begin(), aria2SlashFoo.end(), echo)
                  != aria2SlashFoo.end());
 
-  std::deque<Cookie> aria2Expires = st.criteriaFind("www.dl.aria2.org", "/foo",
-                                                    Time().getTime()+120,
-                                                    false);
+  std::vector<Cookie> aria2Expires = st.criteriaFind("www.dl.aria2.org", "/foo",
+                                                     Time().getTime()+120,
+                                                     false);
   CPPUNIT_ASSERT_EQUAL((size_t)2, aria2Expires.size());
   CPPUNIT_ASSERT(std::find(aria2Expires.begin(), aria2Expires.end(), alpha)
                  != aria2Expires.end());
   CPPUNIT_ASSERT(std::find(aria2Expires.begin(), aria2Expires.end(), echo)
                  != aria2Expires.end());
 
-  std::deque<Cookie> dlAria2 = st.criteriaFind("dl.aria2.org", "/", 0, false);
+  std::vector<Cookie> dlAria2 = st.criteriaFind("dl.aria2.org", "/", 0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)1, dlAria2.size());
   CPPUNIT_ASSERT_EQUAL(std::string("alpha"), dlAria2[0].getName());
 
-  std::deque<Cookie> numericHostCookies = st.criteriaFind("192.168.1.1", "/", 0,
-                                                          false);
+  std::vector<Cookie> numericHostCookies = st.criteriaFind("192.168.1.1", "/",0,
+                                                           false);
   CPPUNIT_ASSERT_EQUAL((size_t)1, numericHostCookies.size());
   CPPUNIT_ASSERT_EQUAL(std::string("golf"), numericHostCookies[0].getName());
 
-  std::deque<Cookie> sameNameCookies =
+  std::vector<Cookie> sameNameCookies =
     st.criteriaFind("samename.x", "/bar/wine", 0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)3, sameNameCookies.size());
   CPPUNIT_ASSERT_EQUAL(std::string("HOTEL3"), sameNameCookies[0].getValue());
   CPPUNIT_ASSERT_EQUAL(std::string("HOTEL4"), sameNameCookies[1].getValue());
   CPPUNIT_ASSERT_EQUAL(std::string("HOTEL1"), sameNameCookies[2].getValue());
 
-  std::deque<Cookie> defaultDomainCookies =
+  std::vector<Cookie> defaultDomainCookies =
     st.criteriaFind("default.domain", "/foo", 0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)2, defaultDomainCookies.size());
   CPPUNIT_ASSERT_EQUAL(std::string("INDIA1"),
@@ -223,7 +223,7 @@ void CookieStorageTest::testCriteriaFind()
 
 
   // localhost.local case
-  std::deque<Cookie> localDomainCookies =
+  std::vector<Cookie> localDomainCookies =
     st.criteriaFind("localhost", "/foo", 0, false);
   CPPUNIT_ASSERT_EQUAL((size_t)2, localDomainCookies.size());
   CPPUNIT_ASSERT_EQUAL(std::string("JULIET1"),
diff --git a/test/DHTAnnouncePeerMessageTest.cc b/test/DHTAnnouncePeerMessageTest.cc
index 67eab08b..dc3a8b8c 100644
--- a/test/DHTAnnouncePeerMessageTest.cc
+++ b/test/DHTAnnouncePeerMessageTest.cc
@@ -111,7 +111,7 @@ void DHTAnnouncePeerMessageTest::testDoReceivedAction()
   CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
   CPPUNIT_ASSERT_EQUAL(std::string("announce_peer"), m->getMessageType());
   CPPUNIT_ASSERT_EQUAL(transactionID, m->getTransactionID());
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   peerAnnounceStorage.getPeers(peers, infoHash);
   CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
   {
diff --git a/test/DHTBucketTest.cc b/test/DHTBucketTest.cc
index 5db4e879..3580bc13 100644
--- a/test/DHTBucketTest.cc
+++ b/test/DHTBucketTest.cc
@@ -373,7 +373,7 @@ void DHTBucketTest::testGetGoodNodes()
   }
   nodes[3]->markBad();
   nodes[5]->markBad();
-  std::deque<SharedHandle<DHTNode> > goodNodes;
+  std::vector<SharedHandle<DHTNode> > goodNodes;
   bucket.getGoodNodes(goodNodes);
   CPPUNIT_ASSERT_EQUAL((size_t)6, goodNodes.size());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, goodNodes[0]->getPort());
diff --git a/test/DHTFindNodeMessageTest.cc b/test/DHTFindNodeMessageTest.cc
index f8491813..00236dac 100644
--- a/test/DHTFindNodeMessageTest.cc
+++ b/test/DHTFindNodeMessageTest.cc
@@ -30,9 +30,10 @@ public:
   class MockDHTMessageFactory2:public MockDHTMessageFactory {
   public:
     virtual SharedHandle<DHTMessage>
-    createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                               const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                               const std::string& transactionID)
+    createFindNodeReplyMessage
+    (const SharedHandle<DHTNode>& remoteNode,
+     const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+     const std::string& transactionID)
     {
       SharedHandle<MockDHTMessage> m
         (new MockDHTMessage(_localNode, remoteNode, "find_node", transactionID));
diff --git a/test/DHTFindNodeReplyMessageTest.cc b/test/DHTFindNodeReplyMessageTest.cc
index 1998bce8..2391e73a 100644
--- a/test/DHTFindNodeReplyMessageTest.cc
+++ b/test/DHTFindNodeReplyMessageTest.cc
@@ -52,7 +52,8 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
       std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
       std::string(&buf[0], &buf[sizeof(buf)]);
   }
-  msg.setClosestKNodes(std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+  msg.setClosestKNodes
+    (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
   std::string msgbody = msg.getBencodedMessage();
 
diff --git a/test/DHTGetPeersMessageTest.cc b/test/DHTGetPeersMessageTest.cc
index 9a8ae5fc..c082fb93 100644
--- a/test/DHTGetPeersMessageTest.cc
+++ b/test/DHTGetPeersMessageTest.cc
@@ -33,7 +33,7 @@ public:
   public:
     virtual SharedHandle<DHTMessage>
     createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                               const std::deque<SharedHandle<Peer> >& peers,
+                               const std::vector<SharedHandle<Peer> >& peers,
                                const std::string& token,
                                const std::string& transactionID)
     {
@@ -45,10 +45,11 @@ public:
     }
 
     virtual SharedHandle<DHTMessage>
-    createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                               const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                               const std::string& token,
-                               const std::string& transactionID)
+    createGetPeersReplyMessage
+    (const SharedHandle<DHTNode>& remoteNode,
+     const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+     const std::string& token,
+     const std::string& transactionID)
     {
       SharedHandle<MockDHTMessage> m
         (new MockDHTMessage(_localNode, remoteNode, "get_peers", transactionID));
diff --git a/test/DHTGetPeersReplyMessageTest.cc b/test/DHTGetPeersReplyMessageTest.cc
index a089604f..75571edd 100644
--- a/test/DHTGetPeersReplyMessageTest.cc
+++ b/test/DHTGetPeersReplyMessageTest.cc
@@ -64,7 +64,7 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
         std::string(&buf[0], &buf[sizeof(buf)]);
     }
     msg.setClosestKNodes
-      (std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
+      (std::vector<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
     std::string msgbody = msg.getBencodedMessage();
 
@@ -75,7 +75,7 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
   }
   rDict.removeKey("nodes");
   {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     BDE valuesList = BDE::list();
     for(size_t i = 0; i < 4; ++i) {
       SharedHandle<Peer> peer(new Peer("192.168.0."+util::uitos(i+1), 6881+i));
diff --git a/test/DHTPeerAnnounceEntryTest.cc b/test/DHTPeerAnnounceEntryTest.cc
index a7cc91af..fd53c35c 100644
--- a/test/DHTPeerAnnounceEntryTest.cc
+++ b/test/DHTPeerAnnounceEntryTest.cc
@@ -44,7 +44,8 @@ void DHTPeerAnnounceEntryTest::testRemoveStalePeerAddrEntry()
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, entry.countPeerAddrEntry());
 
-  const std::deque<PeerAddrEntry>& peerAddrEntries = entry.getPeerAddrEntries();
+  const std::vector<PeerAddrEntry>& peerAddrEntries =
+    entry.getPeerAddrEntries();
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peerAddrEntries[0].getIPAddress());
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"), peerAddrEntries[1].getIPAddress());
 }
@@ -89,7 +90,7 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
 
   DHTPeerAnnounceEntry entry(infohash);
   {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     entry.getPeers(peers);
     CPPUNIT_ASSERT_EQUAL((size_t)0, peers.size());
   }
@@ -98,7 +99,7 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
   entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.2", 6882));
 
   {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     entry.getPeers(peers);
     CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
     CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peers[0]->ipaddr);
diff --git a/test/DHTPeerAnnounceStorageTest.cc b/test/DHTPeerAnnounceStorageTest.cc
index 79f3f008..a6c4c1b3 100644
--- a/test/DHTPeerAnnounceStorageTest.cc
+++ b/test/DHTPeerAnnounceStorageTest.cc
@@ -39,7 +39,7 @@ void DHTPeerAnnounceStorageTest::testAddAnnounce()
   storage.addPeerAnnounce(infohash2, "192.168.0.3", 6883);
   storage.addPeerAnnounce(infohash2, "192.168.0.4", 6884);
   
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   storage.getPeers(peers, infohash2);
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
diff --git a/test/DHTRoutingTableDeserializerTest.cc b/test/DHTRoutingTableDeserializerTest.cc
index 4e4267aa..a7f81f6c 100644
--- a/test/DHTRoutingTableDeserializerTest.cc
+++ b/test/DHTRoutingTableDeserializerTest.cc
@@ -43,7 +43,8 @@ void DHTRoutingTableDeserializerTest::testDeserialize()
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::deque<SharedHandle<DHTNode> > nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
+  std::vector<SharedHandle<DHTNode> > nodes
+    (&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
   
   DHTRoutingTableSerializer s;
   s.setLocalNode(localNode);
@@ -61,7 +62,7 @@ void DHTRoutingTableDeserializerTest::testDeserialize()
   std::cout << d.getSerializedTime().getTime() << std::endl;
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, d.getNodes().size());
-  const std::deque<SharedHandle<DHTNode> >& dsnodes = d.getNodes();
+  const std::vector<SharedHandle<DHTNode> >& dsnodes = d.getNodes();
   CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), dsnodes[0]->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, dsnodes[0]->getPort());
   CPPUNIT_ASSERT(memcmp(nodes[0]->getID(), dsnodes[0]->getID(), DHT_ID_LENGTH) == 0);
diff --git a/test/DHTRoutingTableSerializerTest.cc b/test/DHTRoutingTableSerializerTest.cc
index 09409c76..3c81e3df 100644
--- a/test/DHTRoutingTableSerializerTest.cc
+++ b/test/DHTRoutingTableSerializerTest.cc
@@ -40,7 +40,8 @@ void DHTRoutingTableSerializerTest::testSerialize()
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  std::deque<SharedHandle<DHTNode> > nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
+  std::vector<SharedHandle<DHTNode> > nodes
+    (&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
   
   DHTRoutingTableSerializer s;
   s.setLocalNode(localNode);
diff --git a/test/DHTRoutingTableTest.cc b/test/DHTRoutingTableTest.cc
index 67a3bb9f..8f664dba 100644
--- a/test/DHTRoutingTableTest.cc
+++ b/test/DHTRoutingTableTest.cc
@@ -99,7 +99,7 @@ void DHTRoutingTableTest::testGetClosestKNodes()
   }
   {
     createID(id, 0x80, 0x10);
-    std::deque<SharedHandle<DHTNode> > nodes;
+    std::vector<SharedHandle<DHTNode> > nodes;
     table.getClosestKNodes(nodes, id);
     CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
     for(size_t i = 0; i < nodes.size(); ++i) {
diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc
index b80b2601..bfba0bb8 100644
--- a/test/DefaultBtMessageDispatcherTest.cc
+++ b/test/DefaultBtMessageDispatcherTest.cc
@@ -152,7 +152,7 @@ public:
 
     _messageFactory.reset(new MockBtMessageFactory2());
 
-    _rgman.reset(new RequestGroupMan(std::deque<SharedHandle<RequestGroup> >(),
+    _rgman.reset(new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(),
                                      0, _option.get()));
 
     btMessageDispatcher.reset(new DefaultBtMessageDispatcher());
diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc
index 8045f840..0c6d2106 100644
--- a/test/DefaultBtProgressInfoFileTest.cc
+++ b/test/DefaultBtProgressInfoFileTest.cc
@@ -143,7 +143,7 @@ void DefaultBtProgressInfoFileTest::testLoad_compat()
                        _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   _pieceStorage->getInFlightPieces(inFlightPieces);
 
   SharedHandle<Piece> piece1 = inFlightPieces[0];
@@ -192,7 +192,7 @@ void DefaultBtProgressInfoFileTest::testLoad()
                        _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   _pieceStorage->getInFlightPieces(inFlightPieces);
 
   SharedHandle<Piece> piece1 = inFlightPieces[0];
@@ -222,7 +222,7 @@ void DefaultBtProgressInfoFileTest::testSave()
 
   SharedHandle<Piece> p1(new Piece(1, 1024));
   SharedHandle<Piece> p2(new Piece(2, 512));
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   _pieceStorage->addInFlightPiece(inFlightPieces);
@@ -357,7 +357,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat()
                        _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   _pieceStorage->getInFlightPieces(inFlightPieces);
 
   SharedHandle<Piece> piece1 = inFlightPieces[0];
@@ -402,7 +402,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
                        _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   _pieceStorage->getInFlightPieces(inFlightPieces);
 
   SharedHandle<Piece> piece1 = inFlightPieces[0];
@@ -457,7 +457,7 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 
   SharedHandle<Piece> p1(new Piece(1, 1024));
   SharedHandle<Piece> p2(new Piece(2, 512));
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   _pieceStorage->addInFlightPiece(inFlightPieces);
diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc
index 23c77ca2..c68a0e9a 100644
--- a/test/DefaultBtRequestFactoryTest.cc
+++ b/test/DefaultBtRequestFactoryTest.cc
@@ -142,11 +142,11 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   _requestFactory->addTargetPiece(piece1);
   _requestFactory->addTargetPiece(piece2);
 
-  std::deque<SharedHandle<BtMessage> > msgs;
+  std::vector<SharedHandle<BtMessage> > msgs;
   _requestFactory->createRequestMessages(msgs, 3);
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
+  std::vector<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   SharedHandle<MockBtRequestMessage> msg =
     dynamic_pointer_cast<MockBtRequestMessage>(*itr);
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
@@ -161,7 +161,7 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
 
   {
-    std::deque<SharedHandle<BtMessage> > msgs;
+    std::vector<SharedHandle<BtMessage> > msgs;
     _requestFactory->createRequestMessages(msgs, 3);
     CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
   }
@@ -179,11 +179,11 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
   _requestFactory->addTargetPiece(piece1);
   _requestFactory->addTargetPiece(piece2);
 
-  std::deque<SharedHandle<BtMessage> > msgs;
+  std::vector<SharedHandle<BtMessage> > msgs;
   _requestFactory->createRequestMessagesOnEndGame(msgs, 3);
 
-  std::deque<SharedHandle<MockBtRequestMessage> > mmsgs;
-  for(std::deque<SharedHandle<BtMessage> >::iterator i = msgs.begin();
+  std::vector<SharedHandle<MockBtRequestMessage> > mmsgs;
+  for(std::vector<SharedHandle<BtMessage> >::iterator i = msgs.begin();
       i != msgs.end(); ++i) {
     mmsgs.push_back(dynamic_pointer_cast<MockBtRequestMessage>(*i));
   }
@@ -191,7 +191,7 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
   std::sort(mmsgs.begin(), mmsgs.end(), SortMockBtRequestMessage());
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, mmsgs.size());
-  std::deque<SharedHandle<MockBtRequestMessage> >::iterator itr = mmsgs.begin();
+  std::vector<SharedHandle<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
   MockBtRequestMessage* msg = (*itr).get();
   CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
@@ -233,7 +233,7 @@ void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes()
   _requestFactory->addTargetPiece(piece1);
   _requestFactory->addTargetPiece(piece5);
 
-  std::deque<size_t> indexes;
+  std::vector<size_t> indexes;
   _requestFactory->getTargetPieceIndexes(indexes);
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes.size());
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes[0]);
diff --git a/test/DefaultPeerStorageTest.cc b/test/DefaultPeerStorageTest.cc
index 72ed8cf9..6d9afcc6 100644
--- a/test/DefaultPeerStorageTest.cc
+++ b/test/DefaultPeerStorageTest.cc
@@ -179,7 +179,7 @@ void DefaultPeerStorageTest::testActivatePeer() {
   DefaultPeerStorage ps(option);
 
   {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     ps.getActivePeers(peers);
     CPPUNIT_ASSERT_EQUAL((size_t)0, peers.size());
   }
@@ -189,7 +189,7 @@ void DefaultPeerStorageTest::testActivatePeer() {
   ps.addPeer(peer1);
 
   {
-    std::deque<SharedHandle<Peer> > activePeers;
+    std::vector<SharedHandle<Peer> > activePeers;
     ps.getActivePeers(activePeers);
 
     CPPUNIT_ASSERT_EQUAL((size_t)0, activePeers.size());
@@ -197,7 +197,7 @@ void DefaultPeerStorageTest::testActivatePeer() {
   {
     peer1->allocateSessionResource(1024*1024, 1024*1024*10);
 
-    std::deque<SharedHandle<Peer> > activePeers;
+    std::vector<SharedHandle<Peer> > activePeers;
     ps.getActivePeers(activePeers);
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, activePeers.size());
diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc
index 0834d44c..e33ca135 100644
--- a/test/DefaultPieceStorageTest.cc
+++ b/test/DefaultPieceStorageTest.cc
@@ -106,7 +106,7 @@ void DefaultPieceStorageTest::testGetMissingPiece_excludedIndexes()
 
   peer->setAllBitfield();
 
-  std::deque<size_t> excludedIndexes;
+  std::vector<size_t> excludedIndexes;
   excludedIndexes.push_back(1);
 
   SharedHandle<Piece> piece = pss.getMissingPiece(peer, excludedIndexes);
@@ -148,7 +148,7 @@ void DefaultPieceStorageTest::testGetMissingFastPiece_excludedIndexes()
   peer->addPeerAllowedIndex(1);
   peer->addPeerAllowedIndex(2);
 
-  std::deque<size_t> excludedIndexes;
+  std::vector<size_t> excludedIndexes;
   excludedIndexes.push_back(2);
 
   SharedHandle<Piece> piece = pss.getMissingFastPiece(peer, excludedIndexes);
@@ -281,7 +281,7 @@ void DefaultPieceStorageTest::testGetCompletedLength()
   ps.markPiecesDone(250*1024*1024);
   CPPUNIT_ASSERT_EQUAL((uint64_t)250*1024*1024, ps.getCompletedLength());
 
-  std::deque<SharedHandle<Piece> > inFlightPieces;
+  std::vector<SharedHandle<Piece> > inFlightPieces;
   for(int i = 0; i < 2; ++i) {
     SharedHandle<Piece> p(new Piece(250+i, 1024*1024));
     for(int j = 0; j < 32; ++j) {
diff --git a/test/DownloadHelperTest.cc b/test/DownloadHelperTest.cc
index 9b536877..17fde9b7 100644
--- a/test/DownloadHelperTest.cc
+++ b/test/DownloadHelperTest.cc
@@ -2,7 +2,6 @@
 
 #include <iostream>
 #include <string>
-#include <deque>
 #include <algorithm>
 
 #include <cppunit/extensions/HelperMacros.h>
@@ -70,18 +69,18 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
     "http://bravo/file",
     "http://charlie/file"
   };
-  std::deque<std::string> uris(&array[0], &array[arrayLength(array)]);
+  std::vector<std::string> uris(&array[0], &array[arrayLength(array)]);
   _option->put(PREF_SPLIT, "3");
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
     for(size_t i = 0; i < arrayLength(array); ++i) {
@@ -94,13 +93,13 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   }
   _option->put(PREF_SPLIT, "5");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)5, uris.size());
     for(size_t i = 0; i < arrayLength(array); ++i) {
@@ -113,13 +112,13 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   }
   _option->put(PREF_SPLIT, "2");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
     for(size_t i = 0; i < arrayLength(array); ++i) {
@@ -129,7 +128,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
   }
   _option->put(PREF_FORCE_SEQUENTIAL, V_TRUE);
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
@@ -137,7 +136,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri()
 
     // for alpha server
     SharedHandle<RequestGroup> alphaGroup = result[0];
-    std::deque<std::string> alphaURIs;
+    std::vector<std::string> alphaURIs;
     alphaGroup->getDownloadContext()->getFirstFileEntry()->getUris(alphaURIs);
     CPPUNIT_ASSERT_EQUAL((size_t)2, alphaURIs.size());
     for(size_t i = 0; i < 2; ++i) {
@@ -158,19 +157,19 @@ void DownloadHelperTest::testCreateRequestGroupForUri_parameterized()
     "http://{alpha, bravo}/file",
     "http://charlie/file"
   };
-  std::deque<std::string> uris(&array[0], &array[arrayLength(array)]);
+  std::vector<std::string> uris(&array[0], &array[arrayLength(array)]);
   _option->put(PREF_SPLIT, "3");
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   _option->put(PREF_PARAMETERIZED_URI, V_TRUE);
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
 
@@ -194,18 +193,18 @@ void DownloadHelperTest::testCreateRequestGroupForUri_BitTorrent()
     "http://bravo/file",
     "http://charlie/file"
   };
-  std::deque<std::string> uris(&array[0], &array[arrayLength(array)]);
+  std::vector<std::string> uris(&array[0], &array[arrayLength(array)]);
   _option->put(PREF_SPLIT, "3");
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
     CPPUNIT_ASSERT_EQUAL((size_t)2, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
 
@@ -220,7 +219,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri_BitTorrent()
                          ctx->getBasePath());
 
     SharedHandle<RequestGroup> torrentGroup = result[1];
-    std::deque<std::string> auxURIs;
+    std::vector<std::string> auxURIs;
     torrentGroup->getDownloadContext()->getFirstFileEntry()->getUris(auxURIs);
     CPPUNIT_ASSERT(auxURIs.empty());
     CPPUNIT_ASSERT_EQUAL((unsigned int)3,
@@ -242,13 +241,13 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink()
     "http://charlie/file",
     "test.xml"
   };
-  std::deque<std::string> uris(&array[0], &array[arrayLength(array)]);
+  std::vector<std::string> uris(&array[0], &array[arrayLength(array)]);
   _option->put(PREF_SPLIT, "3");
   _option->put(PREF_METALINK_SERVERS, "2");
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
     
     createRequestGroupForUri(result, _option, uris);
     
@@ -261,7 +260,7 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink()
 #endif // !ENABLE_BITTORRENT
 
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
     for(size_t i = 0; i < 3; ++i) {
@@ -296,14 +295,14 @@ void DownloadHelperTest::testCreateRequestGroupForUriList()
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
 
-  std::deque<SharedHandle<RequestGroup> > result;
+  std::vector<SharedHandle<RequestGroup> > result;
   
   createRequestGroupForUriList(result, _option);
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, result.size());
 
   SharedHandle<RequestGroup> fileGroup = result[0];
-  std::deque<std::string> fileURIs;
+  std::vector<std::string> fileURIs;
   fileGroup->getDownloadContext()->getFirstFileEntry()->getUris(fileURIs);
   CPPUNIT_ASSERT_EQUAL(std::string("http://alpha/file"), fileURIs[0]);
   CPPUNIT_ASSERT_EQUAL(std::string("http://bravo/file"), fileURIs[1]);
@@ -330,20 +329,20 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent()
     "http://charlie/file"
   };
 
-  std::deque<std::string> auxURIs(&array[0], &array[arrayLength(array)]);
+  std::vector<std::string> auxURIs(&array[0], &array[arrayLength(array)]);
   _option->put(PREF_SPLIT, "5");
   _option->put(PREF_TORRENT_FILE, "test.torrent");
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
   
     createRequestGroupForBitTorrent(result, _option, auxURIs);
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
 
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     // See -s option is ignored
     CPPUNIT_ASSERT_EQUAL((size_t)3, uris.size());
@@ -354,19 +353,19 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent()
   }
   {
     // no URIs are given
-    std::deque<SharedHandle<RequestGroup> > result;
-    std::deque<std::string> emptyURIs;
+    std::vector<SharedHandle<RequestGroup> > result;
+    std::vector<std::string> emptyURIs;
     createRequestGroupForBitTorrent(result, _option, emptyURIs);
 
     CPPUNIT_ASSERT_EQUAL((size_t)1, result.size());
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)0, uris.size());
   }
   _option->put(PREF_FORCE_SEQUENTIAL, V_TRUE);
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
   
     createRequestGroupForBitTorrent(result, _option, auxURIs);
 
@@ -385,7 +384,7 @@ void DownloadHelperTest::testCreateRequestGroupForMetalink()
   _option->put(PREF_DIR, "/tmp");
   _option->put(PREF_OUT, "file.out");
   {
-    std::deque<SharedHandle<RequestGroup> > result;
+    std::vector<SharedHandle<RequestGroup> > result;
   
     createRequestGroupForMetalink(result, _option);
 
@@ -395,7 +394,7 @@ void DownloadHelperTest::testCreateRequestGroupForMetalink()
     CPPUNIT_ASSERT_EQUAL((size_t)5, result.size());
 #endif // !ENABLE_BITTORRENT
     SharedHandle<RequestGroup> group = result[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     group->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     std::sort(uris.begin(), uris.end());
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
diff --git a/test/FeedbackURISelectorTest.cc b/test/FeedbackURISelectorTest.cc
index 5130b4cc..b2e9c224 100644
--- a/test/FeedbackURISelectorTest.cc
+++ b/test/FeedbackURISelectorTest.cc
@@ -33,7 +33,7 @@ public:
       "ftp://alpha/file",
       "http://bravo/file"
     };
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     uris.assign(&urisSrc[0], &urisSrc[arrayLength(urisSrc)]);
     
     _fileEntry.setUris(uris);
diff --git a/test/FileEntryTest.cc b/test/FileEntryTest.cc
index 42af9ec8..ee082cd8 100644
--- a/test/FileEntryTest.cc
+++ b/test/FileEntryTest.cc
@@ -36,7 +36,7 @@ static SharedHandle<FileEntry> createFileEntry()
                          "ftp://localhost/aria2.zip",
                          "http://mirror/aria2.zip" };
   SharedHandle<FileEntry> fileEntry(new FileEntry());
-  fileEntry->setUris(std::deque<std::string>(&uris[0], &uris[3]));
+  fileEntry->setUris(std::vector<std::string>(&uris[0], &uris[3]));
   return fileEntry;
 }
 
diff --git a/test/HttpHeaderTest.cc b/test/HttpHeaderTest.cc
index 64381bd2..e3ae3cc8 100644
--- a/test/HttpHeaderTest.cc
+++ b/test/HttpHeaderTest.cc
@@ -54,7 +54,7 @@ void HttpHeaderTest::testGet()
   h.put("a", "101");
   h.put("B", "200");
   
-  std::deque<std::string> r(h.get("A"));
+  std::vector<std::string> r(h.get("A"));
   CPPUNIT_ASSERT_EQUAL((size_t)2, r.size());
   CPPUNIT_ASSERT_EQUAL(std::string("100"), r[0]);
   CPPUNIT_ASSERT_EQUAL(std::string("101"), r[1]);
diff --git a/test/InOrderURISelectorTest.cc b/test/InOrderURISelectorTest.cc
index eef93467..e9b499ad 100644
--- a/test/InOrderURISelectorTest.cc
+++ b/test/InOrderURISelectorTest.cc
@@ -27,7 +27,7 @@ public:
       "ftp://alpha/file",
       "http://bravo/file"
     };
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     uris.assign(&urisSrc[0], &urisSrc[arrayLength(urisSrc)]);
     
     _fileEntry.setUris(uris);
diff --git a/test/MSEHandshakeTest.cc b/test/MSEHandshakeTest.cc
index 717aa4d0..4304006f 100644
--- a/test/MSEHandshakeTest.cc
+++ b/test/MSEHandshakeTest.cc
@@ -78,7 +78,7 @@ void MSEHandshakeTest::doHandshake(const SharedHandle<MSEHandshake>& initiator,
   initiator->sendInitiatorStep2();
 
   while(!receiver->findReceiverHashMarker());
-  std::deque<SharedHandle<DownloadContext> > contexts;
+  std::vector<SharedHandle<DownloadContext> > contexts;
   contexts.push_back(_dctx);
   while(!receiver->receiveReceiverHashAndPadCLength(contexts));
   while(!receiver->receivePad());
diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc
index 24e317e2..8b0b9363 100644
--- a/test/Metalink2RequestGroupTest.cc
+++ b/test/Metalink2RequestGroupTest.cc
@@ -37,13 +37,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION( Metalink2RequestGroupTest );
 
 void Metalink2RequestGroupTest::testGenerate()
 {
-  std::deque<SharedHandle<RequestGroup> > groups;
+  std::vector<SharedHandle<RequestGroup> > groups;
   _option->put(PREF_DIR, "/tmp");
   Metalink2RequestGroup().generate(groups, "test.xml", _option);
   // first file
   {
     SharedHandle<RequestGroup> rg = groups[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     std::sort(uris.begin(), uris.end());
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
@@ -69,7 +69,7 @@ void Metalink2RequestGroupTest::testGenerate()
   // second file
   {
     SharedHandle<RequestGroup> rg = groups[1];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
 
@@ -91,7 +91,7 @@ void Metalink2RequestGroupTest::testGenerate()
   // fifth file <- downloading .torrent file
   {
     SharedHandle<RequestGroup> rg = groups[4];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL
@@ -110,7 +110,7 @@ void Metalink2RequestGroupTest::testGenerate()
 #else
     SharedHandle<RequestGroup> rg = groups[4];
 #endif // ENABLE_BITTORRENT
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL
@@ -125,14 +125,14 @@ void Metalink2RequestGroupTest::testGenerate()
 
 void Metalink2RequestGroupTest::testGenerate_groupByMetaurl()
 {
-  std::deque<SharedHandle<RequestGroup> > groups;
+  std::vector<SharedHandle<RequestGroup> > groups;
   Metalink2RequestGroup().generate(groups, "metalink4-groupbymetaurl.xml",
                                    _option);
   CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size());
   // first RequestGroup is torrent for second RequestGroup
   {
     SharedHandle<RequestGroup> rg = groups[0];
-    std::deque<std::string> uris;
+    std::vector<std::string> uris;
     rg->getDownloadContext()->getFirstFileEntry()->getUris(uris);
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
     CPPUNIT_ASSERT_EQUAL(std::string("http://torrent"), uris[0]);
diff --git a/test/MetalinkPostDownloadHandlerTest.cc b/test/MetalinkPostDownloadHandlerTest.cc
index 4f8dbe0f..e4844f15 100644
--- a/test/MetalinkPostDownloadHandlerTest.cc
+++ b/test/MetalinkPostDownloadHandlerTest.cc
@@ -71,7 +71,7 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
   rg.initPieceStorage();
 
   MetalinkPostDownloadHandler handler;
-  RequestGroups groups;
+  std::vector<SharedHandle<RequestGroup> > groups;
   handler.getNextRequestGroups(groups, &rg);
 #ifdef ENABLE_BITTORRENT
   CPPUNIT_ASSERT_EQUAL((size_t)6/* 5 + 1 torrent file download */, groups.size());
diff --git a/test/MockBtMessage.h b/test/MockBtMessage.h
index b07e6d56..13324a24 100644
--- a/test/MockBtMessage.h
+++ b/test/MockBtMessage.h
@@ -80,9 +80,7 @@ public:
 
   virtual void send() {}
 
-  virtual bool validate(std::deque<std::string>& errors) {
-    return false;
-  }
+  virtual void validate() {}
 
   virtual void onAbortOutstandingRequestEvent
   (const BtAbortOutstandingRequestEvent& event) {}
diff --git a/test/MockBtMessageDispatcher.h b/test/MockBtMessageDispatcher.h
index 5ab3f916..6b18f883 100644
--- a/test/MockBtMessageDispatcher.h
+++ b/test/MockBtMessageDispatcher.h
@@ -12,7 +12,7 @@ namespace aria2 {
 
 class MockBtMessageDispatcher : public BtMessageDispatcher {
 public:
-  BtMessages messageQueue;
+  std::deque<SharedHandle<BtMessage> > messageQueue;
 
   virtual ~MockBtMessageDispatcher() {}
 
@@ -20,7 +20,9 @@ public:
     messageQueue.push_back(btMessage);
   }
 
-  virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) {
+  virtual void addMessageToQueue
+  (const std::vector<SharedHandle<BtMessage> >& btMessages)
+  {
     std::copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
   }
 
diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h
index 6942ffb2..77e97158 100644
--- a/test/MockBtRequestFactory.h
+++ b/test/MockBtRequestFactory.h
@@ -24,12 +24,12 @@ public:
   virtual void doChokedAction() {}
 
   virtual void createRequestMessages
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) {}
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) {}
 
   virtual void createRequestMessagesOnEndGame
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) {}
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) {}
 
-  virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const {}
+  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const {}
 };
 
 } // namespace aria2
diff --git a/test/MockDHTMessage.h b/test/MockDHTMessage.h
index 4cac30e4..d30523c7 100644
--- a/test/MockDHTMessage.h
+++ b/test/MockDHTMessage.h
@@ -16,9 +16,9 @@ public:
 
   std::string _messageType;
 
-  std::deque<SharedHandle<DHTNode> > _nodes;
+  std::vector<SharedHandle<DHTNode> > _nodes;
 
-  std::deque<SharedHandle<Peer> > _peers;
+  std::vector<SharedHandle<Peer> > _peers;
 
   std::string _token;
 public:
diff --git a/test/MockDHTMessageFactory.h b/test/MockDHTMessageFactory.h
index 07bd5cdd..0ae5ccd1 100644
--- a/test/MockDHTMessageFactory.h
+++ b/test/MockDHTMessageFactory.h
@@ -62,9 +62,10 @@ public:
   }
 
   virtual SharedHandle<DHTMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& transactionID)
+  createFindNodeReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& transactionID)
   {
     return SharedHandle<DHTMessage>();
   }
@@ -78,8 +79,9 @@ public:
   }
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
                              const std::string& token,
                              const std::string& transactionID)
   {
@@ -89,7 +91,7 @@ public:
 
   virtual SharedHandle<DHTMessage>
   createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<Peer> >& peers,
+                             const std::vector<SharedHandle<Peer> >& peers,
                              const std::string& token,
                              const std::string& transactionID)
   {
diff --git a/test/MockPeerStorage.h b/test/MockPeerStorage.h
index 42a4c2af..6544e495 100644
--- a/test/MockPeerStorage.h
+++ b/test/MockPeerStorage.h
@@ -13,7 +13,7 @@ class MockPeerStorage : public PeerStorage {
 private:
   TransferStat stat;
   std::deque<SharedHandle<Peer> > peers;
-  std::deque<SharedHandle<Peer> > activePeers;
+  std::vector<SharedHandle<Peer> > activePeers;
   int _numChokeExecuted;
 public:
   MockPeerStorage():_numChokeExecuted(0) {}
@@ -24,7 +24,7 @@ public:
     return true;
   }
 
-  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers) {
+  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers) {
     std::copy(peers.begin(), peers.end(), back_inserter(this->peers));
   }
 
@@ -40,12 +40,12 @@ public:
     return false;
   }
   
-  void setActivePeers(const std::deque<SharedHandle<Peer> >& activePeers)
+  void setActivePeers(const std::vector<SharedHandle<Peer> >& activePeers)
   {
     this->activePeers = activePeers;
   }
 
-  virtual void getActivePeers(std::deque<SharedHandle<Peer> >& peers) {
+  virtual void getActivePeers(std::vector<SharedHandle<Peer> >& peers) {
     peers.insert(peers.end(), activePeers.begin(), activePeers.end());
   }
 
diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h
index baa022e1..e72731fd 100644
--- a/test/MockPieceStorage.h
+++ b/test/MockPieceStorage.h
@@ -49,7 +49,7 @@ public:
   }
 
   virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
   {
     return SharedHandle<Piece>(new Piece());
   }
@@ -59,7 +59,7 @@ public:
   }
 
   virtual SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
   {
     return SharedHandle<Piece>(new Piece());
   }
@@ -212,7 +212,7 @@ public:
 
   virtual void advertisePiece(int32_t cuid, size_t index) {}
 
-  virtual void getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+  virtual void getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                                          int32_t myCuid,
                                          const Time& lastCheckTime)
   {}
@@ -221,7 +221,7 @@ public:
 
   virtual void markAllPiecesDone() {}
 
-  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces)
+  virtual void addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces)
   {
     std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
   }
@@ -231,7 +231,7 @@ public:
     return inFlightPieces.size();
   }
 
-  virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces)
+  virtual void getInFlightPieces(std::vector<SharedHandle<Piece> >& pieces)
   {
     pieces.insert(pieces.end(), inFlightPieces.begin(), inFlightPieces.end());
   }
diff --git a/test/NetrcTest.cc b/test/NetrcTest.cc
index 5c2d267c..17809564 100644
--- a/test/NetrcTest.cc
+++ b/test/NetrcTest.cc
@@ -59,7 +59,8 @@ void NetrcTest::testParse()
 {
   Netrc netrc;
   netrc.parse("sample.netrc");
-  std::deque<SharedHandle<Authenticator> >::const_iterator itr = netrc.getAuthenticators().begin();
+  std::vector<SharedHandle<Authenticator> >::const_iterator itr =
+    netrc.getAuthenticators().begin();
 
   SharedHandle<Authenticator> tujikawaauth = *itr;
   CPPUNIT_ASSERT(!tujikawaauth.isNull());
diff --git a/test/NsCookieParserTest.cc b/test/NsCookieParserTest.cc
index 2c51f9e0..496d8130 100644
--- a/test/NsCookieParserTest.cc
+++ b/test/NsCookieParserTest.cc
@@ -30,7 +30,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(NsCookieParserTest);
 void NsCookieParserTest::testParse()
 {
   NsCookieParser parser;
-  std::deque<Cookie> cookies = parser.parse("nscookietest.txt");
+  std::vector<Cookie> cookies = parser.parse("nscookietest.txt");
   CPPUNIT_ASSERT_EQUAL((size_t)5, cookies.size());
 
   Cookie c = cookies[0];
diff --git a/test/OptionHandlerTest.cc b/test/OptionHandlerTest.cc
index 6cadd302..8ff088d3 100644
--- a/test/OptionHandlerTest.cc
+++ b/test/OptionHandlerTest.cc
@@ -198,7 +198,7 @@ void OptionHandlerTest::testParameterOptionHandler_2argsInit()
 
 void OptionHandlerTest::testParameterOptionHandler_listInit()
 {
-  std::deque<std::string> validValues;
+  std::vector<std::string> validValues;
   validValues.push_back("value1");
   validValues.push_back("value2");
 
diff --git a/test/OptionParserTest.cc b/test/OptionParserTest.cc
index 9ee50981..d282980e 100644
--- a/test/OptionParserTest.cc
+++ b/test/OptionParserTest.cc
@@ -167,7 +167,7 @@ void OptionParserTest::testParseArg()
   int argc = arrayLength(argv);
 
   std::stringstream s;
-  std::deque<std::string> nonopts;
+  std::vector<std::string> nonopts;
 
   _oparser->parseArg(s, nonopts, argc, argv);
 
diff --git a/test/PStringBuildVisitorTest.cc b/test/PStringBuildVisitorTest.cc
index 7aab8b94..a307c8ca 100644
--- a/test/PStringBuildVisitorTest.cc
+++ b/test/PStringBuildVisitorTest.cc
@@ -37,7 +37,8 @@ void PStringBuildVisitorTest::testVisit_select()
   const char* select1data[] = { "alpha", "bravo", "charlie" };
   
   SharedHandle<PStringSelect> select1
-    (new PStringSelect(std::deque<std::string>(&select1data[0], &select1data[3]), segment1));
+    (new PStringSelect
+     (std::vector<std::string>(&select1data[0], &select1data[3]), segment1));
 
   PStringBuildVisitor v;
 
@@ -74,7 +75,8 @@ void PStringBuildVisitorTest::testVisit_select_numLoop()
   const char* select1data[] = { "alpha", "bravo", "charlie" };
   
   SharedHandle<PStringSelect> select1
-    (new PStringSelect(std::deque<std::string>(&select1data[0], &select1data[3]), segment1));
+    (new PStringSelect
+     (std::vector<std::string>(&select1data[0], &select1data[3]), segment1));
 
   SharedHandle<NumberDecorator> decorator(new FixedWidthNumberDecorator(2));
   SharedHandle<PStringNumLoop> loop1
diff --git a/test/ParameterizedStringParserTest.cc b/test/ParameterizedStringParserTest.cc
index fd5104d0..38df6917 100644
--- a/test/ParameterizedStringParserTest.cc
+++ b/test/ParameterizedStringParserTest.cc
@@ -1,7 +1,6 @@
 #include "ParameterizedStringParser.h"
 
 #include <iostream>
-#include <deque>
 
 #include <cppunit/extensions/HelperMacros.h>
 
@@ -61,7 +60,7 @@ void ParameterizedStringParserTest::testParse_select()
   SharedHandle<PStringSelect> select(dynamic_pointer_cast<PStringSelect>(ls));
   CPPUNIT_ASSERT(!select.isNull());
 
-  std::deque<std::string> values = select->getValues();
+  std::vector<std::string> values = select->getValues();
   CPPUNIT_ASSERT_EQUAL((size_t)3, values.size());
 
   CPPUNIT_ASSERT_EQUAL(std::string("alpha"), values[0]);
@@ -113,7 +112,7 @@ void ParameterizedStringParserTest::testParse_segment_select()
   SharedHandle<PStringSelect> select1
     (dynamic_pointer_cast<PStringSelect>(segment1->getNext()));
   CPPUNIT_ASSERT(!select1.isNull());
-  std::deque<std::string> selectValues = select1->getValues();
+  std::vector<std::string> selectValues = select1->getValues();
   CPPUNIT_ASSERT_EQUAL((size_t)3, selectValues.size());
   CPPUNIT_ASSERT_EQUAL(std::string("alpha"), selectValues[0]);
   CPPUNIT_ASSERT_EQUAL(std::string("bravo"), selectValues[1]);
diff --git a/test/RequestGroupManTest.cc b/test/RequestGroupManTest.cc
index b7ab1e57..12cc3c3f 100644
--- a/test/RequestGroupManTest.cc
+++ b/test/RequestGroupManTest.cc
@@ -58,7 +58,7 @@ void RequestGroupManTest::testIsSameFileBeingDownloaded()
   rg1->setDownloadContext(dctx1);
   rg2->setDownloadContext(dctx2);
 
-  RequestGroupMan gm(std::deque<SharedHandle<RequestGroup> >(), 1,
+  RequestGroupMan gm(std::vector<SharedHandle<RequestGroup> >(), 1,
                      _option.get());
 
   gm.addRequestGroup(rg1);
@@ -79,7 +79,8 @@ void RequestGroupManTest::testGetInitialCommands()
 
 void RequestGroupManTest::testSaveServerStat()
 {
-  RequestGroupMan rm(std::deque<SharedHandle<RequestGroup> >(),0,_option.get());
+  RequestGroupMan rm
+    (std::vector<SharedHandle<RequestGroup> >(),0,_option.get());
   SharedHandle<ServerStat> ss_localhost(new ServerStat("localhost", "http"));
   rm.addServerStat(ss_localhost);
   File f("/tmp/aria2_RequestGroupManTest_testSaveServerStat");
@@ -102,7 +103,8 @@ void RequestGroupManTest::testLoadServerStat()
     << "status=OK";
   o.close();
 
-  RequestGroupMan rm(std::deque<SharedHandle<RequestGroup> >(),0,_option.get());
+  RequestGroupMan rm
+    (std::vector<SharedHandle<RequestGroup> >(),0,_option.get());
   std::cerr << "testLoadServerStat" << std::endl;
   CPPUNIT_ASSERT(rm.loadServerStat(f.getPath()));
   SharedHandle<ServerStat> ss_localhost = rm.findServerStat("localhost",
@@ -119,7 +121,7 @@ void RequestGroupManTest::testChangeReservedGroupPosition()
     SharedHandle<RequestGroup>(new RequestGroup(_option)),
     SharedHandle<RequestGroup>(new RequestGroup(_option))
   };
-  std::deque<SharedHandle<RequestGroup> > groups(&gs[0], &gs[arrayLength(gs)]);
+  std::vector<SharedHandle<RequestGroup> > groups(&gs[0], &gs[arrayLength(gs)]);
   RequestGroupMan rm(groups, 0, _option.get());
 
   CPPUNIT_ASSERT_EQUAL
diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc
index 90c562b2..2875f1d0 100644
--- a/test/SegmentManTest.cc
+++ b/test/SegmentManTest.cc
@@ -77,7 +77,7 @@ void SegmentManTest::testCompleteSegment()
   seg->updateWrittenLength(pieceLength);
   segmentMan.completeSegment(1, seg);
   
-  std::deque<SharedHandle<Segment> > segments;
+  std::vector<SharedHandle<Segment> > segments;
   segmentMan.getInFlightSegment(segments, 1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
   CPPUNIT_ASSERT_EQUAL((size_t)0, segments[0]->getIndex());
@@ -98,7 +98,7 @@ void SegmentManTest::testGetSegment_sameFileEntry()
   SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &op));
   SegmentMan segman(&op, dctx, ps);
 
-  std::deque<SharedHandle<Segment> > segments;
+  std::vector<SharedHandle<Segment> > segments;
   segman.getSegment(segments, 1, fileEntries[1], 4);
   // See 3 segments are returned, not 4 because the part of file1 is
   // not filled in segment#1
diff --git a/test/SequenceTest.cc b/test/SequenceTest.cc
index 230ed027..8e96a16b 100644
--- a/test/SequenceTest.cc
+++ b/test/SequenceTest.cc
@@ -1,5 +1,4 @@
 #include "Sequence.h"
-#include <deque>
 #include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
@@ -72,7 +71,7 @@ void SequenceTest::testFlush()
     IntSequence::Value(10, 11),
   };
   IntSequence seq = IntSequence(IntSequence::Values(&params[0], &params[3]));
-  std::deque<int> r = seq.flush();
+  std::vector<int> r = seq.flush();
 
   int answers[] = { 1, 3, 4, 5, 6, 7, 8, 10 };
 
diff --git a/test/Sqlite3MozCookieParserTest.cc b/test/Sqlite3MozCookieParserTest.cc
index 6feb819d..637463b0 100644
--- a/test/Sqlite3MozCookieParserTest.cc
+++ b/test/Sqlite3MozCookieParserTest.cc
@@ -32,7 +32,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(Sqlite3MozCookieParserTest);
 void Sqlite3MozCookieParserTest::testParse()
 {
   Sqlite3MozCookieParser parser;
-  std::deque<Cookie> cookies = parser.parse("cookies.sqlite");
+  std::vector<Cookie> cookies = parser.parse("cookies.sqlite");
   CPPUNIT_ASSERT_EQUAL((size_t)3, cookies.size());
 
   const Cookie& localhost = cookies[0];
diff --git a/test/UTMetadataPostDownloadHandlerTest.cc b/test/UTMetadataPostDownloadHandlerTest.cc
index 9c6974d8..f5148efe 100644
--- a/test/UTMetadataPostDownloadHandlerTest.cc
+++ b/test/UTMetadataPostDownloadHandlerTest.cc
@@ -91,7 +91,7 @@ void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups()
      0);
 
   UTMetadataPostDownloadHandler handler;
-  std::deque<SharedHandle<RequestGroup> > results;
+  std::vector<SharedHandle<RequestGroup> > results;
   handler.getNextRequestGroups(results, _requestGroup.get());
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, results.size());
diff --git a/test/UTMetadataRequestFactoryTest.cc b/test/UTMetadataRequestFactoryTest.cc
index 561db2a1..1958a7af 100644
--- a/test/UTMetadataRequestFactoryTest.cc
+++ b/test/UTMetadataRequestFactoryTest.cc
@@ -1,7 +1,6 @@
 #include "UTMetadataRequestFactory.h"
 
 #include <vector>
-#include <deque>
 
 #include <cppunit/extensions/HelperMacros.h>
 
@@ -61,7 +60,7 @@ void UTMetadataRequestFactoryTest::testCreate()
     (new UTMetadataRequestTracker());
   factory.setUTMetadataRequestTracker(tracker);
 
-  std::deque<SharedHandle<BtMessage> > msgs;
+  std::vector<SharedHandle<BtMessage> > msgs;
 
   factory.create(msgs, 1, ps);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
diff --git a/test/UriListParserTest.cc b/test/UriListParserTest.cc
index 643ce749..ebfeb18f 100644
--- a/test/UriListParserTest.cc
+++ b/test/UriListParserTest.cc
@@ -21,7 +21,7 @@ class UriListParserTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testHasNext);
   CPPUNIT_TEST_SUITE_END();
 private:
-  std::string list2String(const std::deque<std::string>& src);
+  std::string list2String(const std::vector<std::string>& src);
 public:
   void setUp() {
   }
@@ -32,7 +32,7 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( UriListParserTest );
 
-std::string UriListParserTest::list2String(const std::deque<std::string>& src)
+std::string UriListParserTest::list2String(const std::vector<std::string>& src)
 {
   std::ostringstream strm;
   std::copy(src.begin(), src.end(), std::ostream_iterator<std::string>(strm, " "));
@@ -45,7 +45,7 @@ void UriListParserTest::testHasNext()
 
   UriListParser flp(in);
 
-  std::deque<std::string> uris;
+  std::vector<std::string> uris;
   Option reqOp;
 
   CPPUNIT_ASSERT(flp.hasNext());
diff --git a/test/XmlRpcMethodTest.cc b/test/XmlRpcMethodTest.cc
index eba06544..0c54e119 100644
--- a/test/XmlRpcMethodTest.cc
+++ b/test/XmlRpcMethodTest.cc
@@ -91,7 +91,7 @@ public:
     _e.reset(new DownloadEngine(SharedHandle<EventPoll>(new SelectEventPoll())));
     _e->option = _option.get();
     _e->_requestGroupMan.reset
-      (new RequestGroupMan(std::deque<SharedHandle<RequestGroup> >(),
+      (new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(),
                            1, _option.get()));
   }