From 1b7c1982896dba1d38e1fe84ba9660996607f5f9 Mon Sep 17 00:00:00 2001
From: Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com>
Date: Fri, 8 Feb 2008 15:53:45 +0000
Subject: [PATCH] 2008-02-08  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot
 com>

	Removed "using namespace std;" from all sources. Appended std::
prefix to c++
	standard classes.
	Included string.h where mem* function are used.
---
 ChangeLog                                     |   6 +
 src/{Directory.h => AbstractAuthResolver.cc}  |  44 ++--
 src/AbstractAuthResolver.h                    |  35 +--
 src/AbstractBtEventListener.h                 |  10 +-
 src/AbstractBtMessage.cc                      | 134 ++++++++++
 src/AbstractBtMessage.h                       | 123 ++++------
 src/AbstractCommand.cc                        |  43 +++-
 src/AbstractCommand.h                         |  44 ++--
 src/AbstractDiskWriter.cc                     |  20 +-
 src/AbstractDiskWriter.h                      |  16 +-
 src/AbstractProxyRequestCommand.cc            |   8 +
 src/AbstractProxyRequestCommand.h             |  12 +-
 src/AbstractProxyResponseCommand.cc           |   7 +
 src/AbstractProxyResponseCommand.h            |  14 +-
 src/AbstractSegmentManFactory.h               |   6 +
 src/AbstractSingleDiskAdaptor.cc              |  50 +++-
 src/AbstractSingleDiskAdaptor.h               |  43 ++--
 src/ActivePeerConnectionCommand.cc            |  11 +
 src/ActivePeerConnectionCommand.h             |  14 +-
 src/AlphaNumberDecorator.h                    |  16 +-
 src/AnnounceList.cc                           |  28 ++-
 src/AnnounceList.h                            |  24 +-
 src/AnnounceTier.h                            |  13 +-
 src/AuthConfig.cc                             |   5 +-
 src/AuthConfig.h                              |  23 +-
 src/AuthConfigFactory.cc                      |   6 +-
 src/AuthConfigFactory.h                       |  27 +-
 src/AuthResolver.h                            |  11 +-
 src/AutoSaveCommand.cc                        |   4 +
 src/AutoSaveCommand.h                         |   4 +
 src/BNode.cc                                  |  52 ++--
 src/BNode.h                                   |  26 +-
 src/Base64.cc                                 |  12 +-
 src/Base64.h                                  |   8 +-
 src/BencodeVisitor.cc                         |  12 +-
 src/BencodeVisitor.h                          |   9 +-
 src/BinaryStream.h                            |   6 +-
 src/BitfieldMan.cc                            |  93 ++++++-
 src/BitfieldMan.h                             |  76 ++----
 src/BitfieldManFactory.cc                     |  45 +++-
 src/BitfieldManFactory.h                      |  48 ++--
 src/BtAbortOutstandingRequestEvent.h          |  14 +-
 src/BtAllowedFastMessage.cc                   |   7 +-
 src/BtAllowedFastMessage.h                    |   6 +-
 src/BtAllowedFastMessageValidator.h           |   5 +
 src/BtAnnounce.h                              |   8 +-
 src/BtBitfieldMessage.cc                      |   8 +-
 src/BtBitfieldMessage.h                       |   6 +-
 src/BtBitfieldMessageValidator.h              |   5 +
 src/BtCancelMessage.cc                        |   7 +-
 src/BtCancelMessage.h                         |   7 +-
 src/BtCancelMessageValidator.h                |   5 +
 src/BtCancelSendingPieceEvent.h               |   4 +
 src/BtCheckIntegrityEntry.cc                  |   6 +-
 src/BtCheckIntegrityEntry.h                   |   8 +-
 src/BtChokeMessage.cc                         |   9 +-
 src/BtChokeMessage.h                          |   6 +-
 src/BtChokedEvent.h                           |   5 +
 src/BtChokingEvent.h                          |   4 +
 src/BtConstants.h                             |  12 +-
 src/BtContext.h                               |  19 +-
 src/BtContextAwareCommand.cc                  |  10 +
 src/BtContextAwareCommand.h                   |  32 ++-
 src/BtContextDecl.h                           |   4 +
 src/BtDependency.cc                           |   8 +-
 src/BtDependency.h                            |  14 +-
 src/BtEvent.h                                 |   4 +
 src/BtEventListener.h                         |  13 +-
 src/BtExtendedMessage.cc                      |  19 +-
 src/BtExtendedMessage.h                       |  20 +-
 src/BtFileAllocationEntry.cc                  |   4 +
 src/BtFileAllocationEntry.h                   |   9 +-
 src/BtHandshakeMessage.cc                     |  23 +-
 src/BtHandshakeMessage.h                      |  19 +-
 src/BtHandshakeMessageValidator.h             |   6 +
 src/BtHaveAllMessage.cc                       |   7 +-
 src/BtHaveAllMessage.h                        |   6 +-
 src/BtHaveMessage.cc                          |   7 +-
 src/BtHaveMessage.h                           |   6 +-
 src/BtHaveMessageValidator.h                  |   4 +
 src/BtHaveNoneMessage.cc                      |   7 +-
 src/BtHaveNoneMessage.h                       |   6 +-
 src/BtInteractive.h                           |  12 +-
 src/BtInterestedMessage.cc                    |   7 +-
 src/BtInterestedMessage.h                     |   6 +-
 src/BtKeepAliveMessage.cc                     |   4 +
 src/BtKeepAliveMessage.h                      |   6 +-
 src/BtMessage.h                               |  20 +-
 src/BtMessageDispatcher.h                     |  21 +-
 src/BtMessageFactory.h                        |  52 ++--
 src/BtMessageReceiver.h                       |  14 +-
 src/BtMessageValidator.h                      |  10 +-
 src/BtNotInterestedMessage.cc                 |   7 +-
 src/BtNotInterestedMessage.h                  |   6 +-
 src/BtPieceMessage.cc                         |  16 +-
 src/BtPieceMessage.h                          |  31 +--
 src/BtPieceMessageValidator.h                 |   5 +
 src/BtPortMessage.cc                          |  12 +-
 src/BtPortMessage.h                           |  11 +-
 src/BtPostDownloadHandler.cc                  |   9 +-
 src/BtPostDownloadHandler.h                   |   8 +-
 src/BtProgressInfoFile.h                      |   8 +-
 src/BtRegistry.cc                             |  49 ++--
 src/BtRegistry.h                              |  81 +++---
 src/BtRejectMessage.cc                        |   9 +-
 src/BtRejectMessage.h                         |   6 +-
 src/BtRejectMessageValidator.h                |   5 +
 src/BtRequestFactory.h                        |  21 +-
 src/BtRequestMessage.cc                       |  12 +-
 src/BtRequestMessage.h                        |  14 +-
 src/BtRequestMessageValidator.h               |   5 +
 src/BtRuntime.h                               |   4 +
 src/BtSetup.cc                                |   6 +-
 src/BtSetup.h                                 |  12 +-
 src/BtSuggestPieceMessage.cc                  |   6 +-
 src/BtSuggestPieceMessage.h                   |   6 +-
 src/BtSuggestPieceMessageValidator.h          |   6 +
 src/BtUnchokeMessage.cc                       |   7 +-
 src/BtUnchokeMessage.h                        |   6 +-
 src/ByteArrayDiskWriter.cc                    |  26 +-
 src/ByteArrayDiskWriter.h                     |  15 +-
 ...onDecl.h => ByteArrayDiskWriterFactory.cc} |  14 +-
 src/ByteArrayDiskWriterFactory.h              |  12 +-
 src/CUIDCounter.h                             |   5 +
 src/CheckIntegrityCommand.cc                  |  10 +-
 src/CheckIntegrityCommand.h                   |  13 +-
 src/CheckIntegrityEntry.cc                    |   6 +-
 src/CheckIntegrityEntry.h                     |  18 +-
 src/CheckIntegrityMan.cc                      |  10 +-
 src/CheckIntegrityMan.h                       |  16 +-
 src/Checksum.h                                |  22 +-
 src/ChecksumCheckIntegrityEntry.cc            |  15 +-
 src/ChecksumCheckIntegrityEntry.h             |   8 +-
 src/ChunkChecksum.h                           |  28 ++-
 src/ChunkedEncoding.cc                        |  14 +-
 src/ChunkedEncoding.h                         |   4 +
 src/Command.cc                                |  21 ++
 src/Command.h                                 |  27 +-
 src/CompactPeerListProcessor.cc               |  13 +-
 src/CompactPeerListProcessor.h                |  13 +-
 src/ConsoleStatCalc.cc                        | 143 +++++------
 src/ConsoleStatCalc.h                         |  11 +-
 src/ContentTypeRequestGroupCriteria.cc        |  17 +-
 src/ContentTypeRequestGroupCriteria.h         |  18 +-
 src/Cookie.cc                                 |  53 +++-
 src/Cookie.h                                  |  73 +++---
 src/CookieBox.cc                              |   8 +-
 src/CookieBox.h                               |  11 +-
 src/CookieBoxFactory.cc                       |  14 +-
 src/CookieBoxFactory.h                        |  19 +-
 src/CookieParser.cc                           |  29 ++-
 src/CookieParser.h                            |  16 +-
 src/CopyDiskAdaptor.cc                        |  12 +-
 src/CopyDiskAdaptor.h                         |  18 +-
 src/DHTAbstractMessage.cc                     |  19 +-
 src/DHTAbstractMessage.h                      |  25 +-
 src/DHTAbstractNodeLookupTask.cc              |  34 ++-
 src/DHTAbstractNodeLookupTask.h               |  30 ++-
 src/DHTAbstractTask.cc                        |   6 +-
 src/DHTAbstractTask.h                         |  26 +-
 src/DHTAbstractTaskDecl.h                     |  43 ----
 src/DHTAnnouncePeerMessage.cc                 |  17 +-
 src/DHTAnnouncePeerMessage.h                  |  23 +-
 src/DHTAnnouncePeerReplyMessage.cc            |  12 +-
 src/DHTAnnouncePeerReplyMessage.h             |  12 +-
 src/DHTAutoSaveCommand.cc                     |  30 ++-
 src/DHTAutoSaveCommand.h                      |  18 +-
 src/DHTBucket.cc                              |  71 +++---
 src/DHTBucket.h                               |  42 ++--
 src/DHTBucketDecl.h                           |  45 ----
 src/DHTBucketRefreshCommand.cc                |  11 +-
 src/DHTBucketRefreshCommand.h                 |  24 +-
 src/DHTBucketRefreshTask.cc                   |   8 +-
 src/DHTBucketRefreshTask.h                    |   4 +
 src/DHTConnection.h                           |   9 +-
 src/DHTConnectionImpl.cc                      |  18 +-
 src/DHTConnectionImpl.h                       |  15 +-
 src/DHTEntryPointNameResolveCommand.cc        |  23 +-
 src/DHTEntryPointNameResolveCommand.h         |  34 +--
 src/DHTFindNodeMessage.cc                     |  17 +-
 src/DHTFindNodeMessage.h                      |  12 +-
 src/DHTFindNodeReplyMessage.cc                |  23 +-
 src/DHTFindNodeReplyMessage.h                 |  19 +-
 src/DHTGetPeersCommand.cc                     |  13 +-
 src/DHTGetPeersCommand.h                      |  20 +-
 src/DHTGetPeersMessage.cc                     |  19 +-
 src/DHTGetPeersMessage.h                      |  17 +-
 src/DHTGetPeersReplyMessage.cc                |  31 ++-
 src/DHTGetPeersReplyMessage.h                 |  36 +--
 src/DHTIDCloser.h                             |  11 +-
 src/DHTInteractionCommand.cc                  |  11 +-
 src/DHTInteractionCommand.h                   |  30 ++-
 src/DHTMessage.cc                             |  16 +-
 src/DHTMessage.h                              |  32 ++-
 src/DHTMessageCallback.h                      |  15 +-
 src/DHTMessageCallbackDecl.h                  |  43 ----
 src/DHTMessageCallbackImpl.cc                 |   9 +-
 src/DHTMessageCallbackImpl.h                  |  11 +-
 src/DHTMessageCallbackListener.h              |  14 +-
 src/DHTMessageDecl.h                          |  45 ----
 src/DHTMessageDispatcher.cc                   |  21 +-
 src/DHTMessageDispatcher.h                    |  31 ++-
 src/DHTMessageDispatcherDecl.h                |  43 ----
 src/DHTMessageEntry.cc                        |   8 +-
 src/DHTMessageEntry.h                         |  19 +-
 src/DHTMessageEntryDecl.h                     |  45 ----
 src/DHTMessageFactory.h                       |  93 +++----
 src/DHTMessageFactoryDecl.h                   |  43 ----
 src/DHTMessageFactoryImpl.cc                  | 151 ++++++------
 src/DHTMessageFactoryImpl.h                   | 131 +++++-----
 src/DHTMessageReceiver.cc                     |  33 ++-
 src/DHTMessageReceiver.h                      |  41 ++--
 src/DHTMessageReceiverDecl.h                  |  43 ----
 src/DHTMessageTracker.cc                      |  46 ++--
 src/DHTMessageTracker.h                       |  41 ++--
 src/DHTMessageTrackerDecl.h                   |  43 ----
 src/DHTMessageTrackerEntry.cc                 |  14 +-
 src/DHTMessageTrackerEntry.h                  |  34 +--
 src/DHTMessageTrackerEntryDecl.h              |  45 ----
 src/DHTNode.cc                                |   7 +-
 src/DHTNode.h                                 |  15 +-
 src/DHTNodeDecl.h                             |  44 ----
 src/DHTNodeLookupEntry.cc                     |   6 +-
 src/DHTNodeLookupEntry.h                      |  12 +-
 src/DHTNodeLookupEntryDecl.h                  |  45 ----
 src/DHTNodeLookupTask.cc                      |  10 +-
 src/DHTNodeLookupTask.h                       |   8 +-
 src/DHTPeerAnnounceCommand.cc                 |   8 +-
 src/DHTPeerAnnounceCommand.h                  |  12 +-
 src/DHTPeerAnnounceEntry.cc                   |  23 +-
 src/DHTPeerAnnounceEntry.h                    |  19 +-
 src/DHTPeerAnnounceEntryDecl.h                |  45 ----
 src/DHTPeerAnnounceStorage.cc                 |  40 +--
 src/DHTPeerAnnounceStorage.h                  |  37 +--
 src/DHTPeerAnnounceStorageDecl.h              |  43 ----
 src/DHTPeerLookupTask.cc                      |  22 +-
 src/DHTPeerLookupTask.h                       |  30 +--
 src/DHTPingMessage.cc                         |  15 +-
 src/DHTPingMessage.h                          |  12 +-
 src/DHTPingReplyMessage.cc                    |  13 +-
 src/DHTPingReplyMessage.h                     |  12 +-
 src/DHTPingTask.cc                            |  14 +-
 src/DHTPingTask.h                             |  12 +-
 src/DHTQueryMessage.cc                        |  15 +-
 src/DHTQueryMessage.h                         |  14 +-
 src/DHTRegistry.cc                            |  22 +-
 src/DHTRegistry.h                             |  42 ++--
 src/DHTReplaceNodeTask.cc                     |  16 +-
 src/DHTReplaceNodeTask.h                      |  18 +-
 src/DHTResponseMessage.cc                     |  15 +-
 src/DHTResponseMessage.h                      |  14 +-
 src/DHTRoutingTable.cc                        |  45 ++--
 src/DHTRoutingTable.h                         |  50 ++--
 src/DHTRoutingTableDecl.h                     |  43 ----
 src/DHTRoutingTableDeserializer.cc            |  20 +-
 src/DHTRoutingTableDeserializer.h             |  19 +-
 src/DHTRoutingTableSerializer.cc              |  17 +-
 src/DHTRoutingTableSerializer.h               |  19 +-
 src/DHTSetup.cc                               |  33 ++-
 src/DHTSetup.h                                |   7 +-
 src/DHTTask.h                                 |   5 +-
 src/DHTTaskDecl.h                             |  45 ----
 src/DHTTaskFactory.h                          |  36 ++-
 src/DHTTaskFactoryDecl.h                      |  43 ----
 src/DHTTaskFactoryImpl.cc                     |  29 ++-
 src/DHTTaskFactoryImpl.h                      |  43 ++--
 src/DHTTaskQueue.h                            |  15 +-
 src/DHTTaskQueueImpl.cc                       |  13 +-
 src/DHTTaskQueueImpl.h                        |  25 +-
 src/DHTTokenTracker.cc                        |  19 +-
 src/DHTTokenTracker.h                         |  20 +-
 src/DHTTokenTrackerDecl.h                     |  43 ----
 src/DHTTokenUpdateCommand.cc                  |   8 +-
 src/DHTTokenUpdateCommand.h                   |  12 +-
 src/DHTUnknownMessage.cc                      |  14 +-
 src/DHTUnknownMessage.h                       |  14 +-
 src/DHTUtil.cc                                |   7 +-
 src/DHTUtil.h                                 |   5 +
 src/DNSCache.h                                |  21 +-
 src/Data.cc                                   |  11 +-
 src/Data.h                                    |   8 +-
 src/DefaultAuthResolver.cc                    |   9 +-
 src/DefaultAuthResolver.h                     |   8 +-
 src/DefaultBtAnnounce.cc                      |  54 +++-
 src/DefaultBtAnnounce.h                       |  64 ++---
 src/DefaultBtContext.cc                       |  78 +++---
 src/DefaultBtContext.h                        |  69 +++---
 src/DefaultBtInteractive.cc                   | 137 ++++++++---
 src/DefaultBtInteractive.h                    | 111 +++------
 src/DefaultBtMessageDispatcher.cc             |  86 ++++++-
 src/DefaultBtMessageDispatcher.h              | 109 +++------
 src/DefaultBtMessageFactory.cc                |  41 +++-
 src/DefaultBtMessageFactory.h                 | 104 ++++----
 src/DefaultBtMessageReceiver.cc               |  62 ++++-
 src/DefaultBtMessageReceiver.h                |  82 ++-----
 src/DefaultBtProgressInfoFile.cc              |  34 ++-
 src/DefaultBtProgressInfoFile.h               |  18 +-
 src/DefaultBtRequestFactory.cc                |  64 ++++-
 src/DefaultBtRequestFactory.h                 |  94 +++----
 src/DefaultDiskWriter.cc                      |   6 +-
 src/DefaultDiskWriter.h                       |   7 +-
 ...ueueDecl.h => DefaultDiskWriterFactory.cc} |  15 +-
 src/DefaultDiskWriterFactory.h                |  12 +-
 src/DefaultExtensionMessageFactory.cc         |   7 +-
 src/DefaultExtensionMessageFactory.h          |  22 +-
 src/DefaultPeerListProcessor.cc               |  15 +-
 src/DefaultPeerListProcessor.h                |  13 +-
 src/DefaultPeerStorage.cc                     |  33 ++-
 src/DefaultPeerStorage.h                      |  46 ++--
 src/DefaultPieceStorage.cc                    |  41 ++--
 src/DefaultPieceStorage.h                     |  64 ++---
 src/DefaultSegmentManFactory.cc               |  14 +-
 src/DefaultSegmentManFactory.h                |   9 +-
 src/DelegatingPeerListProcessor.cc            |  21 +-
 src/DelegatingPeerListProcessor.h             |  20 +-
 src/Dependency.h                              |   5 +
 src/Dictionary.cc                             |  17 +-
 src/Dictionary.h                              |  19 +-
 src/DirectDiskAdaptor.cc                      |   7 +-
 src/DirectDiskAdaptor.h                       |   6 +-
 src/DiskAdaptor.cc                            |  19 +-
 src/DiskAdaptor.h                             |  35 +--
 src/DiskWriter.h                              |  10 +-
 src/DiskWriterFactory.h                       |  10 +-
 src/DlAbortEx.h                               |   8 +-
 src/DlRetryEx.h                               |   4 +
 src/DownloadCommand.cc                        |  41 ++--
 src/DownloadCommand.h                         |  18 +-
 src/DownloadContext.h                         |  28 ++-
 src/DownloadEngine.cc                         |  44 ++--
 src/DownloadEngine.h                          |  55 ++---
 src/DownloadEngineFactory.cc                  |   6 +-
 src/DownloadEngineFactory.h                   |  14 +-
 src/DownloadFailureException.h                |   8 +-
 src/DownloadHandler.cc                        |   5 +
 src/DownloadHandler.h                         |  18 +-
 src/DownloadHandlerConstants.cc               |  29 ++-
 src/DownloadHandlerConstants.h                |  15 +-
 src/DownloadHandlerFactory.cc                 |  35 ++-
 src/DownloadHandlerFactory.h                  |  24 +-
 src/DownloadResult.h                          |  15 +-
 src/Exception.cc                              |   7 +-
 src/Exception.h                               |  17 +-
 src/ExpatMetalinkProcessor.h                  |  12 +-
 src/ExtendedMessagingAware.h                  |  11 +-
 src/ExtensionMessage.h                        |  11 +-
 src/ExtensionMessageFactory.h                 |  10 +-
 src/FatalException.h                          |   8 +-
 src/FeatureConfig.cc                          |   4 +
 src/FeatureConfig.h                           |  24 +-
 src/File.cc                                   |  29 ++-
 src/File.h                                    |  23 +-
 src/FileAllocationCommand.cc                  |   8 +-
 src/FileAllocationCommand.h                   |  13 +-
 src/FileAllocationDispatcherCommand.cc        |   5 +
 src/FileAllocationDispatcherCommand.h         |   4 +
 src/FileAllocationEntry.cc                    |   4 +
 src/FileAllocationEntry.h                     |  14 +-
 src/FileAllocationIterator.h                  |   5 +
 src/FileAllocationMan.cc                      |   4 +
 src/FileAllocationMan.h                       |  18 +-
 src/FileEntry.cc                              |  11 +-
 src/FileEntry.h                               |  28 ++-
 src/FileMetalinkParserState.cc                |  14 +-
 src/FileMetalinkParserState.h                 |   8 +-
 src/FileUriListParser.h                       |  63 -----
 src/FilesMetalinkParserState.cc               |  14 +-
 src/FilesMetalinkParserState.h                |   8 +-
 src/FillRequestGroupCommand.cc                |   5 +
 src/FillRequestGroupCommand.h                 |  10 +-
 src/FinMetalinkParserState.cc                 |  10 +-
 src/FinMetalinkParserState.h                  |   8 +-
 src/FixedWidthNumberDecorator.h               |   8 +-
 src/FtpConnection.cc                          |  70 ++++--
 src/FtpConnection.h                           |  39 +--
 src/FtpDownloadCommand.cc                     |   5 +
 src/FtpDownloadCommand.h                      |  14 +-
 src/FtpInitiateConnectionCommand.cc           |  10 +-
 src/FtpInitiateConnectionCommand.h            |  10 +-
 src/FtpNegotiationCommand.cc                  |  15 +-
 src/FtpNegotiationCommand.h                   |  19 +-
 src/FtpTunnelRequestCommand.cc                |   6 +
 src/FtpTunnelRequestCommand.h                 |  10 +-
 src/FtpTunnelResponseCommand.cc               |   9 +
 src/FtpTunnelResponseCommand.h                |  12 +-
 src/GrowSegment.cc                            |   4 +
 src/GrowSegment.h                             |  10 +-
 src/HandleRegistry.h                          |   7 +-
 src/HandshakeExtensionMessage.cc              |  37 +--
 src/HandshakeExtensionMessage.h               |  38 +--
 src/HashMetalinkParserState.cc                |  12 +-
 src/HashMetalinkParserState.h                 |   8 +-
 src/HaveEraseCommand.cc                       |   4 +
 src/HaveEraseCommand.h                        |   4 +
 src/HelpItem.cc                               |   9 +-
 src/HelpItem.h                                |  25 +-
 src/HelpItemFactory.cc                        |   4 +
 src/HelpItemFactory.h                         |   8 +-
 src/HttpConnection.cc                         |  45 +++-
 src/HttpConnection.h                          |  63 +++--
 src/HttpDownloadCommand.cc                    |   9 +-
 src/HttpDownloadCommand.h                     |  16 +-
 src/HttpHeader.cc                             |  39 +--
 src/HttpHeader.h                              |  24 +-
 src/HttpHeaderProcessor.cc                    |  46 ++--
 src/HttpHeaderProcessor.h                     |  20 +-
 src/HttpInitiateConnectionCommand.cc          |  19 +-
 src/HttpInitiateConnectionCommand.h           |  11 +-
 src/HttpProxyRequestCommand.cc                |   6 +
 src/HttpProxyRequestCommand.h                 |  10 +-
 src/HttpProxyResponseCommand.cc               |   9 +
 src/HttpProxyResponseCommand.h                |  12 +-
 src/HttpRequest.cc                            | 125 +++++++++-
 src/HttpRequest.h                             | 131 +++-------
 src/HttpRequestCommand.cc                     |  11 +-
 src/HttpRequestCommand.h                      |  14 +-
 src/HttpResponse.cc                           |  62 ++++-
 src/HttpResponse.h                            |  58 ++---
 src/HttpResponseCommand.cc                    |  32 ++-
 src/HttpResponseCommand.h                     |  21 +-
 src/InitialMetalinkParserState.cc             |  10 +-
 src/InitialMetalinkParserState.h              |   8 +-
 src/InitiateConnectionCommandFactory.cc       |  10 +-
 src/InitiateConnectionCommandFactory.h        |  22 +-
 src/IntSequence.h                             |   4 +
 src/IteratableChecksumValidator.cc            |   7 +-
 src/IteratableChecksumValidator.h             |  17 +-
 src/IteratableChunkChecksumValidator.cc       |  11 +-
 src/IteratableChunkChecksumValidator.h        |  21 +-
 src/IteratableValidator.h                     |   5 +
 src/LanguageMetalinkParserState.cc            |  12 +-
 src/LanguageMetalinkParserState.h             |   8 +-
 src/List.cc                                   |   8 +-
 src/List.h                                    |  10 +-
 src/LogFactory.cc                             |  10 +-
 src/LogFactory.h                              |  12 +-
 src/Logger.h                                  |   8 +-
 src/Makefile.am                               |  11 +-
 src/Makefile.in                               | 152 ++++++------
 src/MemoryBufferPreDownloadHandler.cc         |   4 +
 src/MemoryBufferPreDownloadHandler.h          |   5 +
 src/MessageDigestHelper.cc                    |  23 +-
 src/MessageDigestHelper.h                     |  19 +-
 src/MetaEntry.h                               |   6 +
 src/MetaEntryVisitor.h                        |   8 +-
 src/MetaFileUtil.cc                           |  18 +-
 src/MetaFileUtil.h                            |  17 +-
 src/Metalink2RequestGroup.cc                  |  77 +++---
 src/Metalink2RequestGroup.h                   |  19 +-
 src/MetalinkEntry.cc                          | 101 +++++---
 src/MetalinkEntry.h                           |  68 ++----
 src/MetalinkHelper.cc                         |  25 +-
 src/MetalinkHelper.h                          |  20 +-
 src/MetalinkMetalinkParserState.cc            |  12 +-
 src/MetalinkMetalinkParserState.h             |   8 +-
 src/MetalinkParserController.cc               |  62 ++---
 src/MetalinkParserController.h                |  53 ++--
 src/MetalinkParserState.h                     |   8 +-
 src/MetalinkParserStateMachine.cc             |  35 +--
 src/MetalinkParserStateMachine.h              |  39 +--
 src/MetalinkPostDownloadHandler.cc            |  12 +-
 src/MetalinkPostDownloadHandler.h             |   8 +-
 src/MetalinkProcessor.h                       |  13 +-
 src/MetalinkProcessorFactory.cc               |   6 +-
 src/MetalinkProcessorFactory.h                |  10 +-
 src/MetalinkResource.cc                       |   6 +-
 src/MetalinkResource.h                        |  14 +-
 src/Metalinker.cc                             |  42 ++--
 src/Metalinker.h                              |  17 +-
 src/MultiDiskAdaptor.cc                       |  74 +++++-
 src/MultiDiskAdaptor.h                        |  89 +++----
 src/MultiFileAllocationIterator.cc            |   7 +-
 src/MultiFileAllocationIterator.h             |  18 +-
 src/MultiUrlRequestInfo.cc                    |  20 +-
 src/MultiUrlRequestInfo.h                     |  13 +-
 src/NameMatchOptionHandler.h                  |  16 +-
 src/NameResolver.cc                           |  38 ++-
 src/NameResolver.h                            |  35 ++-
 src/Netrc.cc                                  |  30 ++-
 src/Netrc.h                                   |  63 ++---
 src/NetrcAuthResolver.cc                      |  20 +-
 src/NetrcAuthResolver.h                       |  24 +-
 src/NullLogger.h                              |   2 -
 src/NullProgressInfoFile.h                    |   6 +-
 src/NumberDecorator.h                         |   8 +-
 src/OSMetalinkParserState.cc                  |  12 +-
 src/OSMetalinkParserState.h                   |   8 +-
 src/Option.cc                                 |  29 ++-
 src/Option.h                                  |  20 +-
 src/OptionHandler.h                           |  17 +-
 src/OptionHandlerFactory.cc                   |   8 +-
 src/OptionHandlerFactory.h                    |  11 +-
 src/OptionHandlerImpl.h                       | 103 ++++----
 src/OptionParser.cc                           |  20 +-
 src/OptionParser.h                            |  25 +-
 src/PStringBuildVisitor.cc                    |   6 +-
 src/PStringBuildVisitor.h                     |  11 +-
 src/PStringDatum.h                            |  13 +-
 src/PStringNumLoop.h                          |   7 +-
 src/PStringSegment.cc                         |  32 ++-
 src/PStringSegment.h                          |  34 ++-
 src/PStringSelect.h                           |  16 +-
 src/PStringVisitor.h                          |   5 +
 src/ParameterizedStringParser.cc              |  41 ++--
 src/ParameterizedStringParser.h               |  14 +-
 src/Peer.cc                                   | 149 +++++++++++-
 src/Peer.h                                    | 134 ++++------
 src/PeerAbstractCommand.cc                    |  21 +-
 src/PeerAbstractCommand.h                     |  29 ++-
 src/PeerAddrEntry.h                           |  11 +-
 src/PeerChokeCommand.cc                       |  20 +-
 src/PeerChokeCommand.h                        |  18 +-
 src/PeerConnection.cc                         |  18 +-
 src/PeerConnection.h                          |  18 +-
 src/PeerDecl.h                                |   4 +
 src/PeerInitiateConnectionCommand.cc          |  15 +-
 src/PeerInitiateConnectionCommand.h           |   8 +-
 src/PeerInteractionCommand.cc                 |  20 +-
 src/PeerInteractionCommand.h                  |  20 +-
 src/PeerListProcessor.h                       |  13 +-
 src/PeerListenCommand.cc                      |  11 +-
 src/PeerListenCommand.h                       |   9 +-
 src/PeerMessageUtil.cc                        |  17 +-
 src/PeerMessageUtil.h                         |  10 +-
 src/PeerObject.h                              |  29 ++-
 src/PeerReceiveHandshakeCommand.cc            |  14 +-
 src/PeerReceiveHandshakeCommand.h             |  13 +-
 src/PeerStat.h                                |   5 +
 src/PeerStorage.h                             |  21 +-
 src/Piece.cc                                  |  73 +++++-
 src/Piece.h                                   |  89 +++----
 src/PieceHashCheckIntegrityEntry.cc           |   5 +-
 src/PieceHashCheckIntegrityEntry.h            |   4 +
 src/PieceHashMetalinkParserState.cc           |  12 +-
 src/PieceHashMetalinkParserState.h            |   8 +-
 src/PieceStorage.h                            |  43 ++--
 src/PiecedSegment.cc                          |  10 +-
 src/PiecedSegment.h                           |  12 +-
 src/PiecesMetalinkParserState.cc              |  14 +-
 src/PiecesMetalinkParserState.h               |   8 +-
 src/PostDownloadHandler.h                     |  11 +-
 src/PreDownloadHandler.h                      |   7 +-
 src/ProgressAwareEntry.h                      |   6 +
 src/Randomizer.h                              |   6 +
 src/Range.h                                   |   6 +
 src/RealtimeCommand.cc                        |   6 +
 src/RealtimeCommand.h                         |  12 +-
 src/RecoverableException.h                    |   8 +-
 src/Request.cc                                |  64 ++---
 src/Request.h                                 |  74 +++---
 src/RequestGroup.cc                           |  72 ++++--
 src/RequestGroup.h                            | 124 +++++-----
 src/RequestGroupAware.cc                      |   4 +
 src/RequestGroupAware.h                       |   4 +
 src/RequestGroupCriteria.h                    |   5 +
 src/RequestGroupEntry.cc                      |   4 +
 src/RequestGroupEntry.h                       |   9 +-
 src/RequestGroupMan.cc                        |  25 +-
 src/RequestGroupMan.h                         |  39 +--
 src/RequestSlot.cc                            |  21 +-
 src/RequestSlot.h                             |  21 +-
 src/ResourcesMetalinkParserState.cc           |  24 +-
 src/ResourcesMetalinkParserState.h            |   8 +-
 src/SeedCheckCommand.cc                       |  17 +-
 src/SeedCheckCommand.h                        |  21 +-
 src/SeedCriteria.h                            |   7 +-
 src/Segment.h                                 |  12 +-
 src/SegmentMan.cc                             |  14 +-
 src/SegmentMan.h                              |  55 +++--
 src/SegmentManFactory.h                       |  15 +-
 src/Sequence.h                                |  10 +-
 src/ServerHost.cc                             |   6 +-
 src/ServerHost.h                              |  12 +-
 src/ShaVisitor.cc                             |  96 --------
 src/ShaVisitor.h                              |  60 -----
 src/ShareRatioSeedCriteria.h                  |  14 +-
 src/SharedHandle.h                            |   6 +-
 src/SimpleBtMessage.cc                        |   7 +
 src/SimpleBtMessage.h                         |   4 +
 src/SimpleLogger.cc                           |  18 +-
 src/SimpleLogger.h                            |  15 +-
 src/SimpleRandomizer.cc                       |   4 +
 src/SimpleRandomizer.h                        |   4 +
 src/SingleFileAllocationIterator.cc           |   4 +
 src/SingleFileAllocationIterator.h            |   4 +
 ...ectory.cc => SingleFileDownloadContext.cc} |  90 ++++---
 src/SingleFileDownloadContext.h               | 102 +++-----
 src/SingletonHolder.h                         |   4 +
 src/SizeMetalinkParserState.cc                |  12 +-
 src/SizeMetalinkParserState.h                 |   8 +-
 src/SkipTagMetalinkParserState.cc             |  12 +-
 src/SkipTagMetalinkParserState.h              |   8 +-
 src/SleepCommand.cc                           |   6 +-
 src/SleepCommand.h                            |   7 +-
 src/Socket.h                                  |   4 +
 src/SocketCore.cc                             |  24 +-
 src/SocketCore.h                              |  19 +-
 src/SpeedCalc.cc                              |  16 +-
 src/SpeedCalc.h                               |   4 +
 src/StatCalc.h                                |  15 +-
 src/StreamCheckIntegrityEntry.cc              |   8 +-
 src/StreamCheckIntegrityEntry.h               |  13 +-
 src/StreamFileAllocationEntry.cc              |   5 +-
 src/StreamFileAllocationEntry.h               |  13 +-
 src/StreamUriListParser.h                     |  59 -----
 src/TagContainer.cc                           |  25 +-
 src/TagContainer.h                            |  23 +-
 src/TaggedItem.cc                             |  19 +-
 src/TaggedItem.h                              |  26 +-
 src/TimeA2.cc                                 |  32 +++
 src/TimeA2.h                                  |  26 +-
 src/TimeBasedCommand.cc                       |   4 +
 src/TimeBasedCommand.h                        |   4 +
 src/TimeSeedCriteria.h                        |   4 +
 src/TrackerWatcherCommand.cc                  |  27 +-
 src/TrackerWatcherCommand.h                   |  17 +-
 src/TransferEncoding.h                        |   6 +
 src/TransferStat.cc                           |   4 +
 src/TransferStat.h                            |   5 +
 src/TrueRequestGroupCriteria.h                |   4 +
 src/URLMetalinkParserState.cc                 |  12 +-
 src/URLMetalinkParserState.h                  |   8 +-
 src/UTPexExtensionMessage.cc                  |  24 +-
 src/UTPexExtensionMessage.h                   |  38 +--
 src/UnionSeedCriteria.h                       |  13 +-
 src/UnknownLengthPieceStorage.cc              |   8 +-
 src/UnknownLengthPieceStorage.h               |  49 ++--
 src/UriListParser.cc                          |  22 +-
 src/UriListParser.h                           |  20 +-
 src/Util.cc                                   | 211 ++++++++--------
 src/Util.h                                    | 109 +++++----
 src/VerificationMetalinkParserState.cc        |  22 +-
 src/VerificationMetalinkParserState.h         |   8 +-
 src/VersionMetalinkParserState.cc             |  12 +-
 src/VersionMetalinkParserState.h              |   8 +-
 src/XML2SAXMetalinkProcessor.cc               |  38 +--
 src/XML2SAXMetalinkProcessor.h                |  12 +-
 src/XORCloser.h                               |  10 +-
 src/a2algo.h                                  |   8 +
 src/a2functional.h                            |  43 +++-
 src/a2io.h                                    |   3 +
 src/array_fun.h                               |  23 ++
 src/common.h                                  |  52 +---
 src/main.cc                                   | 184 +++++++-------
 src/messageDigest.cc                          |   8 +-
 src/messageDigest.h                           |  22 +-
 src/option_processing.cc                      |  42 ++--
 src/version_usage.cc                          |  89 +++----
 test/AllTest.cc                               |   7 +-
 test/AlphaNumberDecoratorTest.cc              |  23 +-
 test/AnnounceListTest.cc                      | 121 ++++-----
 test/AuthConfigFactoryTest.cc                 |  40 +--
 test/BNodeTest.cc                             |  58 +++--
 test/Base64Test.cc                            |  90 +++----
 test/BencodeVisitorTest.cc                    |  26 +-
 test/BitfieldManTest.cc                       |  10 +-
 test/BtAllowedFastMessageTest.cc              |  14 +-
 test/BtBitfieldMessageTest.cc                 |  20 +-
 test/BtCancelMessageTest.cc                   |  25 +-
 test/BtChokeMessageTest.cc                    |  31 ++-
 test/BtDependencyTest.cc                      |  52 ++--
 test/BtExtendedMessageTest.cc                 |  47 ++--
 test/BtHandshakeMessageTest.cc                |  22 +-
 test/BtHaveAllMessageTest.cc                  |  10 +-
 test/BtHaveMessageTest.cc                     |  12 +-
 test/BtHaveNoneMessageTest.cc                 |  12 +-
 test/BtInterestedMessageTest.cc               |  12 +-
 test/BtKeepAliveMessageTest.cc                |   7 +-
 test/BtNotInterestedMessageTest.cc            |  12 +-
 test/BtPieceMessageTest.cc                    |  39 +--
 test/BtPortMessageTest.cc                     |  18 +-
 test/BtPostDownloadHandlerTest.cc             |  23 +-
 test/BtRegistryTest.cc                        |  25 +-
 test/BtRejectMessageTest.cc                   |  25 +-
 test/BtRequestMessageTest.cc                  |  61 +++--
 test/BtSuggestPieceMessageTest.cc             |   9 +-
 test/BtUnchokeMessageTest.cc                  |  14 +-
 test/ByteArrayDiskWriterTest.cc               |  20 +-
 test/ChunkedEncodingTest.cc                   |  17 +-
 test/CookieBoxFactoryTest.cc                  |  45 ++--
 test/CookieBoxTest.cc                         |  15 +-
 test/CookieParserTest.cc                      |  40 +--
 test/DHTAnnouncePeerMessageTest.cc            |  14 +-
 test/DHTAnnouncePeerReplyMessageTest.cc       |  12 +-
 test/DHTBucketTest.cc                         |  56 +++--
 test/DHTConnectionImplTest.cc                 |  14 +-
 test/DHTFindNodeMessageTest.cc                |  14 +-
 test/DHTFindNodeReplyMessageTest.cc           |  22 +-
 test/DHTGetPeersMessageTest.cc                |  12 +-
 test/DHTGetPeersReplyMessageTest.cc           |  30 ++-
 test/DHTIDCloserTest.cc                       |  17 +-
 test/DHTMessageFactoryImplTest.cc             |  62 ++---
 test/DHTMessageTrackerEntryTest.cc            |  16 +-
 test/DHTMessageTrackerTest.cc                 |  34 +--
 test/DHTNodeTest.cc                           |   6 +-
 test/DHTPeerAnnounceEntryTest.cc              |  39 +--
 test/DHTPeerAnnounceStorageTest.cc            |  15 +-
 test/DHTPingMessageTest.cc                    |  12 +-
 test/DHTPingReplyMessageTest.cc               |  12 +-
 test/DHTRoutingTableDeserializerTest.cc       |  22 +-
 test/DHTRoutingTableSerializerTest.cc         |  24 +-
 test/DHTRoutingTableTest.cc                   |  15 +-
 test/DHTTokenTrackerTest.cc                   |  10 +-
 test/DHTUnknownMessageTest.cc                 |  20 +-
 test/DataTest.cc                              |  10 +-
 test/DefaultAuthResolverTest.cc               |  15 +-
 test/DefaultBtAnnounceTest.cc                 | 101 ++++----
 test/DefaultBtContextTest.cc                  | 111 +++++----
 test/DefaultBtMessageDispatcherTest.cc        |  72 +++---
 test/DefaultBtMessageFactoryTest.cc           |  34 ++-
 test/DefaultBtProgressInfoFileTest.cc         |  89 +++----
 test/DefaultBtRequestFactoryTest.cc           |  61 +++--
 test/DefaultDiskWriterTest.cc                 |   3 +-
 test/DefaultExtensionMessageFactoryTest.cc    |  33 ++-
 test/DefaultPeerListProcessorTest.cc          |  24 +-
 test/DefaultPeerStorageTest.cc                |  60 +++--
 test/DefaultPieceStorageTest.cc               |  73 +++---
 test/DictionaryTest.cc                        |   5 +-
 test/DownloadHandlerFactoryTest.cc            |  29 ++-
 test/FeatureConfigTest.cc                     |   7 +-
 test/FileEntryTest.cc                         |  12 +-
 test/FileTest.cc                              |  20 +-
 test/FileUriListParserTest.cc                 |  49 ----
 test/FixedNumberRandomizer.h                  |   4 +
 test/GlowFileAllocatorTest.cc                 |   2 +-
 test/GrowSegmentTest.cc                       |   4 +-
 test/HandshakeExtensionMessageTest.cc         |  39 +--
 test/HelpItemTest.cc                          |   8 +-
 test/HttpHeaderProcessorTest.cc               |  55 +++--
 test/HttpHeaderTest.cc                        |   7 +-
 test/HttpRequestTest.cc                       |  64 ++---
 test/HttpResponseTest.cc                      |  89 +++----
 test/IteratableChecksumValidatorTest.cc       |  15 +-
 test/IteratableChunkChecksumValidatorTest.cc  |  13 +-
 test/ListTest.cc                              |   3 +-
 test/Makefile.am                              |   7 +-
 test/Makefile.in                              | 161 +++++++-----
 test/MessageDigestHelperTest.cc               |  16 +-
 test/MetaFileUtilTest.cc                      |   3 +-
 test/Metalink2RequestGroupTest.cc             |  55 +++--
 test/MetalinkEntryTest.cc                     |  39 +--
 test/MetalinkHelperTest.cc                    |  14 +-
 test/MetalinkParserControllerTest.cc          |  53 ++--
 test/MetalinkPostDownloadHandlerTest.cc       |  17 +-
 test/MetalinkProcessorTest.cc                 | 230 +++++++++---------
 test/MetalinkerTest.cc                        |  34 +--
 test/MockBtAnnounce.h                         |  16 +-
 test/MockBtContext.h                          |  44 ++--
 test/MockBtMessage.h                          |  10 +-
 test/MockBtMessageDispatcher.h                |  15 +-
 test/MockBtMessageFactory.h                   |  84 +++----
 test/MockBtProgressInfoFile.h                 |  10 +-
 test/MockBtRequestFactory.h                   |  15 +-
 test/MockDHTMessage.h                         |  17 +-
 test/MockDHTMessageCallback.h                 |   8 +-
 test/MockDHTMessageFactory.h                  |  94 +++----
 test/MockDHTTask.h                            |   8 +-
 test/MockDHTTaskFactory.h                     |  20 +-
 test/MockDHTTaskQueue.h                       |  16 +-
 test/MockExtensionMessage.h                   |  16 +-
 test/MockExtensionMessageFactory.h            |   9 +-
 test/MockPeerStorage.h                        |  25 +-
 test/MockPieceStorage.h                       |  45 ++--
 test/MultiDiskAdaptorTest.cc                  |  54 ++--
 test/MultiDiskWriterTest.cc                   |  32 +--
 test/MultiFileAllocationIteratorTest.cc       | 150 ++++++------
 test/NetrcAuthResolverTest.cc                 |  26 +-
 test/NetrcTest.cc                             |  55 +++--
 test/OptionHandlerTest.cc                     | 107 ++++----
 test/OptionTest.cc                            |   6 +-
 test/PStringBuildVisitorTest.cc               |  70 +++---
 test/ParameterizedStringParserTest.cc         |  91 +++----
 test/PeerMessageUtilTest.cc                   |   5 +-
 test/PeerTest.cc                              |   8 +-
 test/PieceTest.cc                             |  12 +-
 test/RequestGroupManTest.cc                   |  19 +-
 test/RequestGroupTest.cc                      |  26 +-
 test/RequestTest.cc                           | 224 ++++++++---------
 test/SegmentManTest.cc                        |  23 +-
 test/SegmentTest.cc                           |  14 +-
 test/SequenceTest.cc                          |   7 +-
 test/ShaVisitorTest.cc                        |  14 +-
 test/ShareRatioSeedCriteriaTest.cc            |  18 +-
 test/SharedHandleTest.cc                      |  13 +-
 test/SingleFileAllocationIteratorTest.cc      |  16 +-
 test/SingleFileDownloadContextTest.cc         |  21 +-
 test/SingletonHolderTest.cc                   |  22 +-
 test/SocketCoreTest.cc                        |  20 +-
 test/SpeedCalcTest.cc                         |   4 +-
 test/StreamUriListParserTest.cc               |  10 +-
 test/TagContainerTest.cc                      |  16 +-
 test/TaggedItemTest.cc                        |   6 +-
 test/TimeSeedCriteriaTest.cc                  |   6 +-
 test/TrackerWatcherCommandTest.cc             |   2 +-
 test/UTPexExtensionMessageTest.cc             |  76 +++---
 test/UriListParserTest.cc                     |  50 ++++
 test/UtilTest.cc                              | 227 ++++++++---------
 test/XORCloserTest.cc                         |   8 +-
 test/Xml2MetalinkProcessorTest.cc             |  48 ++--
 test/a2functionalTest.cc                      |  29 +--
 test/array_funTest.cc                         |  15 +-
 801 files changed, 12024 insertions(+), 8627 deletions(-)
 rename src/{Directory.h => AbstractAuthResolver.cc} (68%)
 create mode 100644 src/AbstractBtMessage.cc
 rename src/{DHTConnectionDecl.h => ByteArrayDiskWriterFactory.cc} (88%)
 delete mode 100644 src/DHTAbstractTaskDecl.h
 delete mode 100644 src/DHTBucketDecl.h
 delete mode 100644 src/DHTMessageCallbackDecl.h
 delete mode 100644 src/DHTMessageDecl.h
 delete mode 100644 src/DHTMessageDispatcherDecl.h
 delete mode 100644 src/DHTMessageEntryDecl.h
 delete mode 100644 src/DHTMessageFactoryDecl.h
 delete mode 100644 src/DHTMessageReceiverDecl.h
 delete mode 100644 src/DHTMessageTrackerDecl.h
 delete mode 100644 src/DHTMessageTrackerEntryDecl.h
 delete mode 100644 src/DHTNodeDecl.h
 delete mode 100644 src/DHTNodeLookupEntryDecl.h
 delete mode 100644 src/DHTPeerAnnounceEntryDecl.h
 delete mode 100644 src/DHTPeerAnnounceStorageDecl.h
 delete mode 100644 src/DHTRoutingTableDecl.h
 delete mode 100644 src/DHTTaskDecl.h
 delete mode 100644 src/DHTTaskFactoryDecl.h
 delete mode 100644 src/DHTTokenTrackerDecl.h
 rename src/{DHTTaskQueueDecl.h => DefaultDiskWriterFactory.cc} (88%)
 delete mode 100644 src/FileUriListParser.h
 delete mode 100644 src/ShaVisitor.cc
 delete mode 100644 src/ShaVisitor.h
 rename src/{Directory.cc => SingleFileDownloadContext.cc} (54%)
 delete mode 100644 src/StreamUriListParser.h
 delete mode 100644 test/FileUriListParserTest.cc
 create mode 100644 test/UriListParserTest.cc

diff --git a/ChangeLog b/ChangeLog
index ecc11af8..96d7ddbc 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2008-02-08  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
+
+	Removed "using namespace std;" from all sources. Appended std:: prefix to c++
+	standard classes.
+	Included string.h where mem* function are used.
+
 2008-02-06  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
 
 	Create directory before saving DHT routing table.
diff --git a/src/Directory.h b/src/AbstractAuthResolver.cc
similarity index 68%
rename from src/Directory.h
rename to src/AbstractAuthResolver.cc
index e3fb8cd9..83c419cc 100644
--- a/src/Directory.h
+++ b/src/AbstractAuthResolver.cc
@@ -32,29 +32,35 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
-#ifndef _D_DIRECTORY_H_
-#define _D_DIRECTORY_H_
+#include "AbstractAuthResolver.h"
+#include "AuthConfig.h"
 
-#include "common.h"
-#include <string>
-#include <deque>
+namespace aria2 {
 
-class Directory {
+AbstractAuthResolver::AbstractAuthResolver():
+  _userDefinedAuthConfig(0),
+  _defaultAuthConfig(new AuthConfig()) {}
 
-typedef deque<Directory*> Files;
+AbstractAuthResolver::~AbstractAuthResolver() {}
 
-private:
-  string name;
-  Files files;
-public:
-  Directory(const string& name);
-  Directory();
-  ~Directory();
+void AbstractAuthResolver::setUserDefinedAuthConfig(const AuthConfigHandle& authConfig)
+{
+  _userDefinedAuthConfig = authConfig;
+}
 
-  void createDir(const string& parentDir, bool recursive) const;
-  void addFile(Directory* directory);
-};
+AuthConfigHandle AbstractAuthResolver::getUserDefinedAuthConfig() const
+{
+  return _userDefinedAuthConfig;
+}
 
-typedef SharedHandle<Directory> DirectoryHandle;
+void AbstractAuthResolver::setDefaultAuthConfig(const AuthConfigHandle& authConfig)
+{
+  _defaultAuthConfig = authConfig;
+}
 
-#endif // _D_DIRECTORY_H_
+AuthConfigHandle AbstractAuthResolver::getDefaultAuthConfig() const
+{
+  return _defaultAuthConfig;
+}
+
+} // namespace aria2
diff --git a/src/AbstractAuthResolver.h b/src/AbstractAuthResolver.h
index 3944a362..bdf1370e 100644
--- a/src/AbstractAuthResolver.h
+++ b/src/AbstractAuthResolver.h
@@ -37,42 +37,31 @@
 
 #include "AuthResolver.h"
 
+namespace aria2 {
+
 class AbstractAuthResolver : public AuthResolver {
 protected:
 
-  AuthConfigHandle _userDefinedAuthConfig;
+  SharedHandle<AuthConfig> _userDefinedAuthConfig;
 
-  AuthConfigHandle _defaultAuthConfig;
+  SharedHandle<AuthConfig> _defaultAuthConfig;
 
 public:
-  AbstractAuthResolver():_userDefinedAuthConfig(0),
-			 _defaultAuthConfig(new AuthConfig())
-  {}
+  AbstractAuthResolver();
 
-  virtual ~AbstractAuthResolver() {}
+  virtual ~AbstractAuthResolver();
 
-  void setUserDefinedAuthConfig(const AuthConfigHandle& authConfig)
-  {
-    _userDefinedAuthConfig = authConfig;
-  }
+  void setUserDefinedAuthConfig(const SharedHandle<AuthConfig>& authConfig);
 
-  AuthConfigHandle getUserDefinedAuthConfig() const
-  {
-    return _userDefinedAuthConfig;
-  }
+  SharedHandle<AuthConfig> getUserDefinedAuthConfig() const;
 
-  void setDefaultAuthConfig(const AuthConfigHandle& authConfig)
-  {
-    _defaultAuthConfig = authConfig;
-  }
-
-  AuthConfigHandle getDefaultAuthConfig() const
-  {
-    return _defaultAuthConfig;
-  }
+  void setDefaultAuthConfig(const SharedHandle<AuthConfig>& authConfig);
 
+  SharedHandle<AuthConfig> getDefaultAuthConfig() const;
 };
 
 typedef SharedHandle<AbstractAuthResolver> AbstractAuthResolverHandle;
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_AUTH_RESOLVER_H_
diff --git a/src/AbstractBtEventListener.h b/src/AbstractBtEventListener.h
index 4b16f4f6..64a6427e 100644
--- a/src/AbstractBtEventListener.h
+++ b/src/AbstractBtEventListener.h
@@ -37,19 +37,23 @@
 
 #include "BtEventListener.h"
 
+namespace aria2 {
+
 class AbstractBtEventListener : public BtEventListener {
 public:
   virtual ~AbstractBtEventListener() {}
 
-  virtual bool canHandle(const BtEventHandle& event) = 0;
+  virtual bool canHandle(const SharedHandle<BtEvent>& event) = 0;
 
-  virtual void handleEventInternal(const BtEventHandle& event) = 0;
+  virtual void handleEventInternal(const SharedHandle<BtEvent>& event) = 0;
 
-  virtual void handleEvent(const BtEventHandle& event) {
+  virtual void handleEvent(const SharedHandle<BtEvent>& event) {
     if(canHandle(event)) {
       handleEventInternal(event);
     }
   }
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_BT_EVENT_LISTENER_H_
diff --git a/src/AbstractBtMessage.cc b/src/AbstractBtMessage.cc
new file mode 100644
index 00000000..9f243345
--- /dev/null
+++ b/src/AbstractBtMessage.cc
@@ -0,0 +1,134 @@
+/* <!-- copyright */
+/*
+ * aria2 - The high speed download utility
+ *
+ * Copyright (C) 2006 Tatsuhiro Tsujikawa
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+/* copyright --> */
+#include "AbstractBtMessage.h"
+#include "Peer.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "BtRegistry.h"
+#include "BtEventListener.h"
+#include "BtMessageValidator.h"
+#include "LogFactory.h"
+#include "Logger.h"
+
+namespace aria2 {
+
+AbstractBtMessage::AbstractBtMessage():sendingInProgress(false),
+				       invalidate(false),
+				       uploading(false),
+				       cuid(0),
+				       btContext(0),
+				       pieceStorage(0),
+				       peer(0),
+				       validator(0),
+				       logger(LogFactory::getInstance())
+{}
+
+AbstractBtMessage::~AbstractBtMessage() {}
+
+SharedHandle<Peer> AbstractBtMessage::getPeer() const
+{
+  return peer;
+}
+
+void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+bool AbstractBtMessage::validate(std::deque<std::string>& errors)
+{
+  if(validator.get()) {
+    return validator->validate(errors);
+  } else {
+    return true;
+  }
+}
+
+void AbstractBtMessage::handleEvent(const SharedHandle<BtEvent>& event)
+{
+  for(std::deque<SharedHandle<BtEventListener> >::iterator itr = listeners.begin();
+      itr != listeners.end(); ++itr) {
+    (*itr)->handleEvent(event);
+  }
+}
+
+void
+AbstractBtMessage::addEventListener(const SharedHandle<BtEventListener>& listener)
+{
+  listeners.push_back(listener);
+}
+
+void
+AbstractBtMessage::setBtMessageValidator(const SharedHandle<BtMessageValidator>& validator) {
+  this->validator = validator;
+}
+
+SharedHandle<BtMessageValidator> AbstractBtMessage::getBtMessageValidator() const
+{
+  return validator;
+}
+
+void AbstractBtMessage::setBtContext(const SharedHandle<BtContext>& btContext)
+{
+  this->btContext = btContext;
+  this->pieceStorage = PIECE_STORAGE(btContext);
+}
+
+SharedHandle<BtContext> AbstractBtMessage::getBtContext() const
+{
+  return btContext;
+}
+
+void AbstractBtMessage::setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher)
+{
+  this->dispatcher = dispatcher;
+}
+
+void AbstractBtMessage::setPeerConnection(const WeakHandle<PeerConnection>& peerConnection)
+{
+  this->peerConnection = peerConnection;
+}
+
+void AbstractBtMessage::setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory)
+{
+  this->messageFactory = factory;
+}
+
+void AbstractBtMessage::setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory)
+{
+  this->requestFactory = factory;
+}
+
+} // namespace aria2
diff --git a/src/AbstractBtMessage.h b/src/AbstractBtMessage.h
index 7a4315c0..16dfc3c2 100644
--- a/src/AbstractBtMessage.h
+++ b/src/AbstractBtMessage.h
@@ -36,18 +36,20 @@
 #define _D_ABSTRACT_BT_MESSAGE_H_
 
 #include "BtMessage.h"
-#include "Peer.h"
-#include "Piece.h"
-#include "LogFactory.h"
-#include "Logger.h"
-#include "BtEvent.h"
-#include "BtEventListener.h"
-#include "BtContext.h"
-#include "BtRegistry.h"
-#include "BtMessageDispatcher.h"
-#include "PeerConnection.h"
-#include "BtRequestFactory.h"
-#include "BtMessageFactory.h"
+#include <deque>
+
+namespace aria2 {
+
+class BtContext;
+class PieceStorage;
+class Peer;
+class BtMessageDispatcher;
+class BtMessageFactory;
+class BtRequestFactory;
+class PeerConnection;
+class BtMessageValidator;
+class BtEventListener;
+class Logger;
 
 class AbstractBtMessage : public BtMessage {
 protected:
@@ -56,35 +58,29 @@ protected:
   bool uploading;
   int32_t cuid;
 
-  BtContextHandle btContext;
+  SharedHandle<BtContext> btContext;
 
-  PieceStorageHandle pieceStorage;
+  SharedHandle<PieceStorage> pieceStorage;
 
-  PeerHandle peer;
+  SharedHandle<Peer> peer;
 
-  BtMessageDispatcherWeakHandle dispatcher;
+  WeakHandle<BtMessageDispatcher> dispatcher;
 
-  BtMessageFactoryWeakHandle messageFactory;
+  WeakHandle<BtMessageFactory> messageFactory;
 
-  BtRequestFactoryWeakHandle requestFactory;
+  WeakHandle<BtRequestFactory> requestFactory;
 
-  PeerConnectionWeakHandle peerConnection;
+  WeakHandle<PeerConnection> peerConnection;
+
+  SharedHandle<BtMessageValidator> validator;
+
+  std::deque<SharedHandle<BtEventListener> > listeners;
 
-  BtMessageValidatorHandle validator;
-  BtEventListeners listeners;
   const Logger* logger;
 public:
-  AbstractBtMessage():sendingInProgress(false),
-		      invalidate(false),
-		      uploading(false),
-		      cuid(0),
-		      btContext(0),
-		      pieceStorage(0),
-		      peer(0),
-		      validator(0),
-		      logger(LogFactory::getInstance())
-		      
-  {}
+  AbstractBtMessage();
+
+  virtual ~AbstractBtMessage();
 
   virtual bool isSendingInProgress() {
     return sendingInProgress;
@@ -118,72 +114,39 @@ public:
     this->cuid = cuid;
   }
 
-  PeerHandle getPeer() const {
-    return peer;
-  }
+  SharedHandle<Peer> getPeer() const;
 
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
   virtual void doReceivedAction() {}
 
-  virtual bool validate(Errors& errors) {
-    if(validator.get()) {
-      return validator->validate(errors);
-    } else {
-      return true;
-    }
-  }
+  virtual bool validate(std::deque<std::string>& errors);
   
   virtual void onQueued() {}
 
-  virtual void handleEvent(const BtEventHandle& event) {
-    for(BtEventListeners::iterator itr = listeners.begin();
-	itr != listeners.end(); ++itr) {
-      (*itr)->handleEvent(event);
-    }
-  }
+  virtual void handleEvent(const SharedHandle<BtEvent>& event);
 
-  void addEventListener(const BtEventListenerHandle& listener) {
-    listeners.push_back(listener);
-  }
+  void addEventListener(const SharedHandle<BtEventListener>& listener);
 
-  void setBtMessageValidator(const BtMessageValidatorHandle& validator) {
-    this->validator = validator;
-  }
+  void setBtMessageValidator(const SharedHandle<BtMessageValidator>& validator);
 
-  BtMessageValidatorHandle getBtMessageValidator() const {
-    return validator;
-  }
+  SharedHandle<BtMessageValidator> getBtMessageValidator() const;
 
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-    this->pieceStorage = PIECE_STORAGE(btContext);
-  }
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  BtContextHandle getBtContext() const {
-    return btContext;
-  }
+  SharedHandle<BtContext> getBtContext() const;
 
-  void setBtMessageDispatcher(const BtMessageDispatcherWeakHandle& dispatcher)
-  {
-    this->dispatcher = dispatcher;
-  }
+  void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher);
 
-  void setPeerConnection(const PeerConnectionWeakHandle& peerConnection) {
-    this->peerConnection = peerConnection;
-  }
+  void setPeerConnection(const WeakHandle<PeerConnection>& peerConnection);
 
-  void setBtMessageFactory(const BtMessageFactoryWeakHandle& factory) {
-    this->messageFactory = factory;
-  }
+  void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
 
-  void setBtRequestFactory(const BtRequestFactoryWeakHandle& factory) {
-    this->requestFactory = factory;
-  }
+  void setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory);
 };
 
 typedef SharedHandle<AbstractBtMessage> AbstractBtMessageHandle;
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_BT_MESSAGE_H_
diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index 321443f2..50245b02 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -33,26 +33,31 @@
  */
 /* copyright --> */
 #include "AbstractCommand.h"
+#include "RequestGroup.h"
+#include "Request.h"
+#include "DownloadEngine.h"
+#include "Option.h"
+#include "PeerStat.h"
 #include "SegmentMan.h"
-#include "NameResolver.h"
-#include "CUIDCounter.h"
+#include "Logger.h"
+#include "Segment.h"
 #include "DlAbortEx.h"
 #include "DlRetryEx.h"
 #include "DownloadFailureException.h"
 #include "InitiateConnectionCommandFactory.h"
-#include "Util.h"
-#include "message.h"
 #include "SleepCommand.h"
-#include "prefs.h"
+#include "NameResolver.h"
 #include "DNSCache.h"
 #include "StreamCheckIntegrityEntry.h"
-#include "PeerStat.h"
-#include "Segment.h"
-#include "Option.h"
 #include "PieceStorage.h"
+#include "Socket.h"
+#include "message.h"
+#include "prefs.h"
+
+namespace aria2 {
 
 AbstractCommand::AbstractCommand(int32_t cuid,
-				 const RequestHandle& req,
+				 const SharedHandle<Request>& req,
 				 RequestGroup* requestGroup,
 				 DownloadEngine* e,
 				 const SocketHandle& s):
@@ -66,6 +71,20 @@ AbstractCommand::AbstractCommand(int32_t cuid,
   _requestGroup->increaseStreamConnection();
 }
 
+AbstractCommand::AbstractCommand(int32_t cuid,
+				 const SharedHandle<Request>& req,
+				 RequestGroup* requestGroup,
+				 DownloadEngine* e):
+  Command(cuid), RequestGroupAware(requestGroup),
+  req(req), e(e), socket(new SocketCore()),
+  checkSocketIsReadable(false), checkSocketIsWritable(false),
+  nameResolverCheck(false)
+{ 
+  setReadCheckSocket(socket);
+  timeout = this->e->option->getAsInt(PREF_TIMEOUT);
+  _requestGroup->increaseStreamConnection();
+}
+
 AbstractCommand::~AbstractCommand() {
   disableReadCheckSocket();
   disableWriteCheckSocket();
@@ -239,9 +258,9 @@ void AbstractCommand::setWriteCheckSocket(const SocketHandle& socket) {
   }
 }
 
-bool AbstractCommand::resolveHostname(const string& hostname,
+bool AbstractCommand::resolveHostname(const std::string& hostname,
 				      const NameResolverHandle& resolver) {
-  string ipaddr = DNSCacheSingletonHolder::instance()->find(hostname);
+  std::string ipaddr = DNSCacheSingletonHolder::instance()->find(hostname);
   if(ipaddr.empty()) {
 #ifdef ENABLE_ASYNC_DNS
     switch(resolver->getStatus()) {
@@ -301,3 +320,5 @@ void AbstractCommand::prepareForNextAction(Command* nextCommand)
     new StreamCheckIntegrityEntry(req, _requestGroup, nextCommand);
   e->addCommand(_requestGroup->processCheckIntegrityEntry(entry, e));
 }
+
+} // namespace aria2
diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h
index cce0b15d..a92555e1 100644
--- a/src/AbstractCommand.h
+++ b/src/AbstractCommand.h
@@ -36,44 +36,44 @@
 #define _D_ABSTRACT_COMMAND_H_
 
 #include "Command.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
 #include "RequestGroupAware.h"
-#include "Socket.h"
+
+namespace aria2 {
 
 class Request;
-typedef SharedHandle<Request> RequestHandle;
 class DownloadEngine;
+class RequestGroup;
 class Segment;
-typedef SharedHandle<Segment> SegmentHandle;
-typedef deque<SegmentHandle> Segments;
 class NameResolver;
-typedef SharedHandle<NameResolver> NameResolverHandle;
-class BtProgressInfoFile;
-typedef SharedHandle<BtProgressInfoFile> BtProgressInfoFileHandle;
+class Exception;
+class SocketCore;
 
 class AbstractCommand : public Command, public RequestGroupAware {
 private:
   Time checkPoint;
   int32_t timeout;
 protected:
-  RequestHandle req;
+  SharedHandle<Request> req;
   DownloadEngine* e;
-  SocketHandle socket;
-  Segments _segments;
+  SharedHandle<SocketCore> socket;
+  std::deque<SharedHandle<Segment> > _segments;
 
   void tryReserved();
   virtual bool prepareForRetry(int32_t wait);
   virtual void onAbort(Exception* ex);
   virtual bool executeInternal() = 0;
 
-  void setReadCheckSocket(const SocketHandle& socket);
-  void setWriteCheckSocket(const SocketHandle& socket);
+  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
+  void setWriteCheckSocket(const SharedHandle<SocketCore>& socket);
   void disableReadCheckSocket();
   void disableWriteCheckSocket();
-  bool resolveHostname(const string& hostname, const NameResolverHandle& nameResolver);
+  bool resolveHostname(const std::string& hostname,
+		       const SharedHandle<NameResolver>& nameResolver);
 #ifdef ENABLE_ASYNC_DNS
-  void setNameResolverCheck(const NameResolverHandle& resolver);
-  void disableNameResolverCheck(const NameResolverHandle& resolver);
+  void setNameResolverCheck(const SharedHandle<NameResolver>& resolver);
+  void disableNameResolverCheck(const SharedHandle<NameResolver>& resolver);
   virtual bool nameResolveFinished() const;
 #endif // ENABLE_ASYNC_DNS
   void setTimeout(int32_t timeout) { this->timeout = timeout; }
@@ -83,14 +83,22 @@ protected:
 private:
   bool checkSocketIsReadable;
   bool checkSocketIsWritable;
-  SocketHandle readCheckTarget;
-  SocketHandle writeCheckTarget;
+  SharedHandle<SocketCore> readCheckTarget;
+  SharedHandle<SocketCore> writeCheckTarget;
   bool nameResolverCheck;
 
 public:
-  AbstractCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, const SocketHandle& s = SocketHandle());
+  AbstractCommand(int32_t cuid, const SharedHandle<Request>& req,
+		  RequestGroup* requestGroup, DownloadEngine* e,
+		  const SharedHandle<SocketCore>& s);
+
+  AbstractCommand(int32_t cuid, const SharedHandle<Request>& req,
+		  RequestGroup* requestGroup, DownloadEngine* e);
+
   virtual ~AbstractCommand();
   bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_COMMAND_H_
diff --git a/src/AbstractDiskWriter.cc b/src/AbstractDiskWriter.cc
index 72bce294..3fd54982 100644
--- a/src/AbstractDiskWriter.cc
+++ b/src/AbstractDiskWriter.cc
@@ -37,13 +37,13 @@
 #include "Util.h"
 #include "message.h"
 #include "LogFactory.h"
-#include "a2io.h"
+#include "Logger.h"
 #include "DlAbortEx.h"
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <fcntl.h>
+#include "a2io.h"
+#include <cerrno>
+#include <cassert>
+
+namespace aria2 {
 
 AbstractDiskWriter::AbstractDiskWriter():
   fd(-1),
@@ -54,7 +54,7 @@ AbstractDiskWriter::~AbstractDiskWriter()
   closeFile();
 }
 
-void AbstractDiskWriter::openFile(const string& filename, int64_t totalLength)
+void AbstractDiskWriter::openFile(const std::string& filename, int64_t totalLength)
 {
   File f(filename);
   if(f.exists()) {
@@ -72,7 +72,7 @@ void AbstractDiskWriter::closeFile()
   }
 }
 
-void AbstractDiskWriter::openExistingFile(const string& filename,
+void AbstractDiskWriter::openExistingFile(const std::string& filename,
 					  int64_t totalLength)
 {
   this->filename = filename;
@@ -86,7 +86,7 @@ void AbstractDiskWriter::openExistingFile(const string& filename,
   }
 }
 
-void AbstractDiskWriter::createFile(const string& filename, int32_t addFlags)
+void AbstractDiskWriter::createFile(const std::string& filename, int32_t addFlags)
 {
   this->filename = filename;
   assert(filename.size());
@@ -182,3 +182,5 @@ void AbstractDiskWriter::disableDirectIO()
   while(fcntl(fd, F_SETFL, flg&(~O_DIRECT)) == -1 && errno == EINTR);
 #endif // ENABLE_DIRECT_IO
 }
+
+} // namespace aria2
diff --git a/src/AbstractDiskWriter.h b/src/AbstractDiskWriter.h
index 8971484b..4d2b1b79 100644
--- a/src/AbstractDiskWriter.h
+++ b/src/AbstractDiskWriter.h
@@ -36,15 +36,19 @@
 #define _D_ABSTRACT_DISK_WRITER_H_
 
 #include "DiskWriter.h"
-#include "Logger.h"
+#include <string>
+
+namespace aria2 {
+
+class Logger;
 
 class AbstractDiskWriter : public DiskWriter {
 protected:
-  string filename;
+  std::string filename;
   int32_t fd;
   const Logger* logger;
 
-  void createFile(const string& filename, int32_t addFlags = 0);
+  void createFile(const std::string& filename, int32_t addFlags = 0);
 
 private:
   int32_t writeDataInternal(const unsigned char* data, int32_t len);
@@ -56,11 +60,11 @@ public:
   AbstractDiskWriter();
   virtual ~AbstractDiskWriter();
 
-  virtual void openFile(const string& filename, int64_t totalLength = 0);
+  virtual void openFile(const std::string& filename, int64_t totalLength = 0);
 
   virtual void closeFile();
 
-  virtual void openExistingFile(const string& filename, int64_t totalLength = 0);
+  virtual void openExistingFile(const std::string& filename, int64_t totalLength = 0);
 
   virtual void writeData(const unsigned char* data, int32_t len, int64_t offset);
 
@@ -75,4 +79,6 @@ public:
   virtual void disableDirectIO();
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_DISK_WRITER_H_
diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc
index cd1f4a5a..a686d250 100644
--- a/src/AbstractProxyRequestCommand.cc
+++ b/src/AbstractProxyRequestCommand.cc
@@ -37,7 +37,13 @@
 #include "RequestGroup.h"
 #include "Request.h"
 #include "HttpConnection.h"
+#include "HttpRequest.h"
+#include "Segment.h"
+#include "Option.h"
 #include "prefs.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 AbstractProxyRequestCommand::AbstractProxyRequestCommand(int cuid,
 							 const RequestHandle& req,
@@ -66,3 +72,5 @@ bool AbstractProxyRequestCommand::executeInternal() {
   e->commands.push_back(getNextCommand());
   return true;
 }
+
+} // namespace aria2
diff --git a/src/AbstractProxyRequestCommand.h b/src/AbstractProxyRequestCommand.h
index 545cb6a2..53a80d39 100644
--- a/src/AbstractProxyRequestCommand.h
+++ b/src/AbstractProxyRequestCommand.h
@@ -37,23 +37,27 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class HttpConnection;
-typedef SharedHandle<HttpConnection> HttpConnectionHandle;
+class SocketCore;
 
 class AbstractProxyRequestCommand : public AbstractCommand {
 protected:
-  HttpConnectionHandle httpConnection;
+  SharedHandle<HttpConnection> httpConnection;
 
   virtual bool executeInternal();
 public:
   AbstractProxyRequestCommand(int cuid,
-			      const RequestHandle& req,
+			      const SharedHandle<Request>& req,
 			      RequestGroup* requestGroup,
 			      DownloadEngine* e,
-			      const SocketHandle& s);
+			      const SharedHandle<SocketCore>& s);
   virtual ~AbstractProxyRequestCommand();
 
   virtual Command* getNextCommand() = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_PROXY_REQUEST_COMMAND_H_
diff --git a/src/AbstractProxyResponseCommand.cc b/src/AbstractProxyResponseCommand.cc
index 1c25a0ca..e27ff382 100644
--- a/src/AbstractProxyResponseCommand.cc
+++ b/src/AbstractProxyResponseCommand.cc
@@ -35,13 +35,18 @@
 #include "AbstractProxyResponseCommand.h"
 #include "HttpConnection.h"
 #include "Request.h"
+#include "Segment.h"
 #include "RequestGroup.h"
 #include "DownloadEngine.h"
+#include "HttpRequest.h"
 #include "HttpResponse.h"
 #include "HttpRequestCommand.h"
+#include "Socket.h"
 #include "DlRetryEx.h"
 #include "message.h"
 
+namespace aria2 {
+
 AbstractProxyResponseCommand::AbstractProxyResponseCommand(int cuid,
 							   const RequestHandle& req,
 							   RequestGroup* requestGroup,
@@ -66,3 +71,5 @@ bool AbstractProxyResponseCommand::executeInternal() {
   e->commands.push_back(getNextCommand());
   return true;
 }
+
+} // namespace aria2
diff --git a/src/AbstractProxyResponseCommand.h b/src/AbstractProxyResponseCommand.h
index b0ef904d..28c00c99 100644
--- a/src/AbstractProxyResponseCommand.h
+++ b/src/AbstractProxyResponseCommand.h
@@ -37,24 +37,28 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class HttpConnection;
-typedef SharedHandle<HttpConnection> HttpConnectionHandle;
+class SocketCore;
 
 class AbstractProxyResponseCommand : public AbstractCommand {
 protected:
-  HttpConnectionHandle httpConnection;
+  SharedHandle<HttpConnection> httpConnection;
 
   virtual bool executeInternal();
 public:
   AbstractProxyResponseCommand(int cuid,
-			       const RequestHandle& req,
+			       const SharedHandle<Request>& req,
 			       RequestGroup* requestGroup,
-			       const HttpConnectionHandle& httpConnection,
+			       const SharedHandle<HttpConnection>& httpConnection,
 			       DownloadEngine* e,
-			       const SocketHandle& s);
+			       const SharedHandle<SocketCore>& s);
   virtual ~AbstractProxyResponseCommand();
 
   virtual Command* getNextCommand() = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_PROXY_RESPONSE_COMMAND_H_
diff --git a/src/AbstractSegmentManFactory.h b/src/AbstractSegmentManFactory.h
index cfcd8ea8..d796e07b 100644
--- a/src/AbstractSegmentManFactory.h
+++ b/src/AbstractSegmentManFactory.h
@@ -37,6 +37,10 @@
 
 #include "SegmentManFactory.h"
 
+namespace aria2 {
+
+class Option;
+
 class AbstractSegmentManFactory : public SegmentManFactory {
 protected:
   const Option* _option;
@@ -48,4 +52,6 @@ public:
 
 typedef SharedHandle<AbstractSegmentManFactory> AbstractSegmentManFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_SEGMENT_MAN_FACTORY_H_
diff --git a/src/AbstractSingleDiskAdaptor.cc b/src/AbstractSingleDiskAdaptor.cc
index bb9efe0f..ca634350 100644
--- a/src/AbstractSingleDiskAdaptor.cc
+++ b/src/AbstractSingleDiskAdaptor.cc
@@ -35,6 +35,15 @@
 #include "AbstractSingleDiskAdaptor.h"
 #include "File.h"
 #include "SingleFileAllocationIterator.h"
+#include "DiskWriter.h"
+
+namespace aria2 {
+
+AbstractSingleDiskAdaptor::AbstractSingleDiskAdaptor():
+  diskWriter(0),
+  totalLength(0) {}
+
+AbstractSingleDiskAdaptor::~AbstractSingleDiskAdaptor() {}
 
 void AbstractSingleDiskAdaptor::initAndOpenFile()
 {
@@ -71,12 +80,20 @@ bool AbstractSingleDiskAdaptor::fileExists()
   return File(getFilePath()).exists();
 }
 
+int64_t AbstractSingleDiskAdaptor::size() const
+{
+  return diskWriter->size();
+}
+
+void AbstractSingleDiskAdaptor::truncate(int64_t length)
+{
+  diskWriter->truncate(length);
+}
+
 FileAllocationIteratorHandle AbstractSingleDiskAdaptor::fileAllocationIterator()
 {
   SingleFileAllocationIteratorHandle h =
-    new SingleFileAllocationIterator(this,
-				     size(),
-				     totalLength);
+    new SingleFileAllocationIterator(this, size(), totalLength);
   h->init();
   return h;
 }
@@ -90,3 +107,30 @@ void AbstractSingleDiskAdaptor::disableDirectIO()
 {
   diskWriter->disableDirectIO();
 }
+
+bool AbstractSingleDiskAdaptor::directIOAllowed() const
+{
+  return diskWriter->directIOAllowed();
+}
+  
+void AbstractSingleDiskAdaptor::setDiskWriter(const DiskWriterHandle& diskWriter)
+{
+  this->diskWriter = diskWriter;
+}
+
+DiskWriterHandle AbstractSingleDiskAdaptor::getDiskWriter() const
+{
+  return diskWriter;
+}
+
+void AbstractSingleDiskAdaptor::setTotalLength(const int64_t& totalLength)
+{
+  this->totalLength = totalLength;
+}
+
+int64_t AbstractSingleDiskAdaptor::getTotalLength() const
+{
+  return totalLength;
+}
+
+} // namespace aria2
diff --git a/src/AbstractSingleDiskAdaptor.h b/src/AbstractSingleDiskAdaptor.h
index 01dac1af..3772a662 100644
--- a/src/AbstractSingleDiskAdaptor.h
+++ b/src/AbstractSingleDiskAdaptor.h
@@ -36,16 +36,20 @@
 #define _D_ABSTRACT_SINGLE_DISK_ADAPTOR_H_
 
 #include "DiskAdaptor.h"
-#include "DiskWriter.h"
+
+namespace aria2 {
+
+class DiskWriter;
+class FileAllocationIterator;
 
 class AbstractSingleDiskAdaptor : public DiskAdaptor {
 protected:
-  DiskWriterHandle diskWriter;
+  SharedHandle<DiskWriter> diskWriter;
   int64_t totalLength;
 public:
-  AbstractSingleDiskAdaptor():diskWriter(0), totalLength(0) {}
+  AbstractSingleDiskAdaptor();
 
-  virtual ~AbstractSingleDiskAdaptor() {}
+  virtual ~AbstractSingleDiskAdaptor();
 
   virtual void initAndOpenFile();
 
@@ -62,38 +66,27 @@ public:
 
   virtual bool fileExists();
 
-  virtual int64_t size() const
-  {
-    return diskWriter->size();
-  }
+  virtual int64_t size() const;
 
-  virtual void truncate(int64_t length)
-  {
-    diskWriter->truncate(length);
-  }
+  virtual void truncate(int64_t length);
   
-  virtual FileAllocationIteratorHandle fileAllocationIterator();
+  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator();
 
   virtual void enableDirectIO();
 
   virtual void disableDirectIO();
   
-  virtual bool directIOAllowed() const
-  {
-    return diskWriter->directIOAllowed();
-  }
+  virtual bool directIOAllowed() const;
   
-  void setDiskWriter(const DiskWriterHandle diskWriter) {
-    this->diskWriter = diskWriter;
-  }
+  void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter);
 
-  DiskWriterHandle getDiskWriter() const { return diskWriter; }
+  SharedHandle<DiskWriter> getDiskWriter() const;
 
-  void setTotalLength(const int64_t& totalLength) {
-    this->totalLength = totalLength;
-  }
+  void setTotalLength(const int64_t& totalLength);
 
-  int64_t getTotalLength() const { return totalLength; }
+  int64_t getTotalLength() const;
 };
 
+} // namespace aria2
+
 #endif // _D_ABSTRACT_SINGLE_DISK_ADAPTOR_H_
diff --git a/src/ActivePeerConnectionCommand.cc b/src/ActivePeerConnectionCommand.cc
index 4a8659a9..a181bc80 100644
--- a/src/ActivePeerConnectionCommand.cc
+++ b/src/ActivePeerConnectionCommand.cc
@@ -36,6 +36,15 @@
 #include "PeerInitiateConnectionCommand.h"
 #include "CUIDCounter.h"
 #include "message.h"
+#include "DownloadEngine.h"
+#include "BtContext.h"
+#include "PeerStorage.h"
+#include "PieceStorage.h"
+#include "BtRuntime.h"
+#include "Peer.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 ActivePeerConnectionCommand::ActivePeerConnectionCommand(int cuid,
 							 RequestGroup* requestGroup,
@@ -84,3 +93,5 @@ void ActivePeerConnectionCommand::connectToPeer(const PeerHandle& peer)
   logger->info(MSG_CONNECTING_TO_PEER,
 	       cuid, peer->ipaddr.c_str());
 }
+
+} // namespace aria2
diff --git a/src/ActivePeerConnectionCommand.h b/src/ActivePeerConnectionCommand.h
index 4877101e..ac8d7503 100644
--- a/src/ActivePeerConnectionCommand.h
+++ b/src/ActivePeerConnectionCommand.h
@@ -37,9 +37,13 @@
 
 #include "Command.h"
 #include "BtContextAwareCommand.h"
-#include "DownloadEngine.h"
-#include "TimeA2.h"
 #include "RequestGroupAware.h"
+#include "TimeA2.h"
+
+namespace aria2 {
+
+class DownloadEngine;
+class Peer;
 
 class ActivePeerConnectionCommand : public Command,
 				    public BtContextAwareCommand,
@@ -55,14 +59,14 @@ public:
   ActivePeerConnectionCommand(int cuid,
 			      RequestGroup* requestGroup,
 			      DownloadEngine* e,
-			      const BtContextHandle& btContext,
+			      const SharedHandle<BtContext>& btContext,
 			      int32_t interval);
      
   virtual ~ActivePeerConnectionCommand();
 
   virtual bool execute();
 
-  void connectToPeer(const PeerHandle& peer);
+  void connectToPeer(const SharedHandle<Peer>& peer);
 
   void setLowestSpeedLimit(int32_t speed)
   {
@@ -75,4 +79,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_ACTIVE_PEER_CONNECTION_COMMAND_H_
diff --git a/src/AlphaNumberDecorator.h b/src/AlphaNumberDecorator.h
index db1543f8..ff71c662 100644
--- a/src/AlphaNumberDecorator.h
+++ b/src/AlphaNumberDecorator.h
@@ -38,17 +38,19 @@
 #include "NumberDecorator.h"
 #include "DlAbortEx.h"
 
+namespace aria2 {
+
 class AlphaNumberDecorator : public NumberDecorator
 {
 private:
 
   int32_t _width;
 
-  string _zero;
+  std::string _zero;
 
-  string widen(const string& s, int32_t width)
+  std::string widen(const std::string& s, int32_t width)
   {
-    string t = s;
+    std::string t = s;
     while(t.size() < (size_t)width) {
       t.insert(0, _zero);
     }
@@ -61,7 +63,7 @@ public:
 
   virtual ~AlphaNumberDecorator() {}
 
-  virtual string decorate(int32_t number)
+  virtual std::string decorate(int32_t number)
   {
     if(number < 0) {
       throw new DlAbortEx("The number must be greater than 0.");
@@ -70,15 +72,17 @@ public:
       return widen(_zero, _width);
     }
     int32_t base = 26;
-    string x;
+    std::string x;
     while(number > 0) {
       int32_t r = number%base;
       char alpha = _zero[0]+r;
-      x.insert(0, string(1, alpha));
+      x.insert(0, std::string(1, alpha));
       number /= base;
     }
     return widen(x, _width);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_ALPHA_NUMBER_DECORATOR_H_
diff --git a/src/AnnounceList.cc b/src/AnnounceList.cc
index 3a8d6cb2..845f26e4 100644
--- a/src/AnnounceList.cc
+++ b/src/AnnounceList.cc
@@ -35,6 +35,9 @@
 #include "AnnounceList.h"
 #include "List.h"
 #include "Data.h"
+#include <algorithm>
+
+namespace aria2 {
 
 AnnounceList::AnnounceList(const MetaEntry* announceListEntry):
   currentTrackerInitialized(false) {
@@ -49,14 +52,14 @@ AnnounceList::AnnounceList(const AnnounceTiers& announceTiers):
 void AnnounceList::reconfigure(const MetaEntry* announceListEntry) {
   const List* l = dynamic_cast<const List*>(announceListEntry);
   if(l) {
-    for(MetaList::const_iterator itr = l->getList().begin();
+    for(std::deque<MetaEntry*>::const_iterator itr = l->getList().begin();
 	itr != l->getList().end(); itr++) {
       const List* elem = dynamic_cast<const List*>(*itr);
       if(!elem) {
 	continue;
       }
-      Strings urls;
-      for(MetaList::const_iterator elemItr = elem->getList().begin();
+      std::deque<std::string> urls;
+      for(std::deque<MetaEntry*>::const_iterator elemItr = elem->getList().begin();
 	  elemItr != elem->getList().end(); elemItr++) {
 	const Data* data = dynamic_cast<const Data*>(*elemItr);
 	if(data) {
@@ -72,8 +75,8 @@ void AnnounceList::reconfigure(const MetaEntry* announceListEntry) {
   }
 }
 
-void AnnounceList::reconfigure(const string& url) {
-  Strings urls;
+void AnnounceList::reconfigure(const std::string& url) {
+  std::deque<std::string> urls;
   urls.push_back(url);
   tiers.push_back(AnnounceTierHandle(new AnnounceTier(urls)));
   resetIterator();
@@ -89,7 +92,7 @@ void AnnounceList::resetIterator() {
   }
 }
 
-string AnnounceList::getAnnounce() const {
+std::string AnnounceList::getAnnounce() const {
   if(currentTrackerInitialized) {
     return *currentTracker;
   } else {
@@ -100,7 +103,7 @@ string AnnounceList::getAnnounce() const {
 void AnnounceList::announceSuccess() {
   if(currentTrackerInitialized) {
     (*currentTier)->nextEvent();
-    string url = *currentTracker;
+    std::string url = *currentTracker;
     (*currentTier)->urls.erase(currentTracker);
     (*currentTier)->urls.push_front(url);
     currentTier = tiers.begin();
@@ -138,7 +141,7 @@ void AnnounceList::setEvent(AnnounceTier::AnnounceEvent event) {
   }
 }
 
-string AnnounceList::getEventString() const {
+std::string AnnounceList::getEventString() const {
   if(currentTrackerInitialized) {
     switch((*currentTier)->event) {
     case AnnounceTier::STARTED:
@@ -203,10 +206,9 @@ template<class InputIterator, class Predicate>
 InputIterator
 find_wrap_if(InputIterator first, InputIterator last,
 	     InputIterator current, Predicate pred) {
-  InputIterator itr = find_if(current, last,
-			      pred);
+  InputIterator itr = std::find_if(current, last, pred);
   if(itr == last) {
-    itr = find_if(first, current, pred);
+    itr = std::find_if(first, current, pred);
   }
   return itr;
 }
@@ -228,7 +230,7 @@ void AnnounceList::moveToCompletedAllowedTier() {
 void AnnounceList::shuffle() {
   for(AnnounceTiers::iterator itr = tiers.begin();
       itr != tiers.end(); itr++) {
-    Strings& urls = (*itr)->urls;
+    std::deque<std::string>& urls = (*itr)->urls;
     random_shuffle(urls.begin(), urls.end());
   }
 }
@@ -260,3 +262,5 @@ bool AnnounceList::currentTierAcceptsCompletedEvent() const
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/AnnounceList.h b/src/AnnounceList.h
index 62d5a756..59011c57 100644
--- a/src/AnnounceList.h
+++ b/src/AnnounceList.h
@@ -36,26 +36,30 @@
 #define _D_ANNOUNCE_LIST_H_
 
 #include "common.h"
-#include "MetaEntry.h"
+#include "SharedHandle.h"
 #include "AnnounceTier.h"
 
+namespace aria2 {
+
+class MetaEntry;
+
 class AnnounceList {
 public:
 private:
-  AnnounceTiers tiers;
-  AnnounceTiers::iterator currentTier;
-  Strings::iterator currentTracker;
+  std::deque<SharedHandle<AnnounceTier> > tiers;
+  std::deque<SharedHandle<AnnounceTier> >::iterator currentTier;
+  std::deque<std::string>::iterator currentTracker;
   bool currentTrackerInitialized;
 
   void resetIterator();
-  void setCurrentTier(const AnnounceTiers::iterator& itr);
+  void setCurrentTier(const std::deque<SharedHandle<AnnounceTier> >::iterator& itr);
 public:
   AnnounceList():currentTrackerInitialized(false) {}
   AnnounceList(const MetaEntry* announceListEntry);
-  AnnounceList(const AnnounceTiers& tiers);
+  AnnounceList(const std::deque<SharedHandle<AnnounceTier> >& tiers);
 
   void reconfigure(const MetaEntry* announceListEntry);
-  void reconfigure(const string& url);
+  void reconfigure(const std::string& url);
 
   int32_t countTier() const {
     return tiers.size();
@@ -69,12 +73,12 @@ public:
   /**
    * Returns announce URL.
    */
-  string getAnnounce() const;
+  std::string getAnnounce() const;
 
   /**
    * Returns announce event, such as started, stopped, completed, etc.
    */
-  string getEventString() const;
+  std::string getEventString() const;
 
   AnnounceTier::AnnounceEvent getEvent() const;
 
@@ -125,4 +129,6 @@ public:
   bool currentTierAcceptsCompletedEvent() const;
 };
 
+} // namespace aria2
+
 #endif // _D_ANNOUNCE_LIST_H_
diff --git a/src/AnnounceTier.h b/src/AnnounceTier.h
index b211d177..2a706f07 100644
--- a/src/AnnounceTier.h
+++ b/src/AnnounceTier.h
@@ -36,6 +36,11 @@
 #define _D_ANNOUNCE_TIER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class AnnounceTier {
 public:
@@ -50,9 +55,9 @@ public:
   };
 
   AnnounceEvent event;
-  Strings urls;
+  std::deque<std::string> urls;
 
-  AnnounceTier(const Strings& urls):event(STARTED), urls(urls) {}
+  AnnounceTier(const std::deque<std::string>& urls):event(STARTED), urls(urls) {}
 
   void nextEvent() {
     switch(event) {
@@ -89,6 +94,8 @@ public:
 };
 
 typedef SharedHandle<AnnounceTier> AnnounceTierHandle;
-typedef deque<AnnounceTierHandle> AnnounceTiers;
+typedef std::deque<AnnounceTierHandle> AnnounceTiers;
+
+} // namespace aria2
 
 #endif // _D_ANNOUNCE_TIER_H_
diff --git a/src/AuthConfig.cc b/src/AuthConfig.cc
index 799d62bf..276cfef5 100644
--- a/src/AuthConfig.cc
+++ b/src/AuthConfig.cc
@@ -34,9 +34,12 @@
 /* copyright --> */
 #include "AuthConfig.h"
 
-ostream& operator<<(ostream& o, const AuthConfigHandle& authConfig)
+namespace aria2 {
+
+std::ostream& operator<<(std::ostream& o, const AuthConfigHandle& authConfig)
 {
   o << authConfig->getAuthText();
   return o;
 }
 
+} // namespace aria2
diff --git a/src/AuthConfig.h b/src/AuthConfig.h
index 343c824f..715a7036 100644
--- a/src/AuthConfig.h
+++ b/src/AuthConfig.h
@@ -36,29 +36,34 @@
 #define _D_AUTH_CONFIG_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <iosfwd>
+
+namespace aria2 {
 
 class AuthConfig {
 private:
-  string _authScheme;
-  string _user;
-  string _password;
+  std::string _authScheme;
+  std::string _user;
+  std::string _password;
 public:
 
   AuthConfig() {}
-  AuthConfig(const string& user, const string& password):
+  AuthConfig(const std::string& user, const std::string& password):
     _user(user), _password(password) {}
 
-  string getAuthText() const
+  std::string getAuthText() const
   {
     return _user+":"+_password;
   }
 
-  const string& getUser() const
+  const std::string& getUser() const
   {
     return _user;
   }
 
-  const string& getPassword() const
+  const std::string& getPassword() const
   {
     return _password;
   }
@@ -66,6 +71,8 @@ public:
 
 typedef SharedHandle<AuthConfig> AuthConfigHandle;
 
-ostream& operator<<(ostream& o, const AuthConfigHandle& authConfig);
+std::ostream& operator<<(std::ostream& o, const AuthConfigHandle& authConfig);
+
+} // namespace aria2
 
 #endif // _D_AUTH_CONFIG_H_
diff --git a/src/AuthConfigFactory.cc b/src/AuthConfigFactory.cc
index 1dfac71d..255c627e 100644
--- a/src/AuthConfigFactory.cc
+++ b/src/AuthConfigFactory.cc
@@ -41,6 +41,8 @@
 #include "prefs.h"
 #include "Request.h"
 
+namespace aria2 {
+
 AuthConfigFactory::AuthConfigFactory(const Option* option):
   _option(option), _netrc(0) {}
 
@@ -66,7 +68,7 @@ AuthConfigHandle AuthConfigFactory::createAuthConfigForHttpProxy(const RequestHa
   return createHttpProxyAuthResolver()->resolveAuthConfig(request->getHost());
 }
 
-AuthConfigHandle AuthConfigFactory::createAuthConfig(const string& user, const string& password) const
+AuthConfigHandle AuthConfigFactory::createAuthConfig(const std::string& user, const std::string& password) const
 {
   if(user.length() > 0) {
     return new AuthConfig(user, password);
@@ -122,3 +124,5 @@ void AuthConfigFactory::setNetrc(const NetrcHandle& netrc)
 {
   _netrc = netrc;
 }
+
+} // namespace aria2
diff --git a/src/AuthConfigFactory.h b/src/AuthConfigFactory.h
index a6b97c1f..44aa3dc0 100644
--- a/src/AuthConfigFactory.h
+++ b/src/AuthConfigFactory.h
@@ -36,30 +36,31 @@
 #define _D_AUTH_CONFIG_FACTORY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include "SingletonHolder.h"
+#include <string>
+
+namespace aria2 {
 
 class Option;
 class Netrc;
-typedef SharedHandle<Netrc> NetrcHandle;
 class AuthConfig;
-typedef SharedHandle<AuthConfig> AuthConfigHandle;
 class Request;
-typedef SharedHandle<Request> RequestHandle;
 class AuthResolver;
-typedef SharedHandle<AuthResolver> AuthResolverHandle;
 
 class AuthConfigFactory {
 private:
   const Option* _option;
 
-  NetrcHandle _netrc;
+  SharedHandle<Netrc> _netrc;
   
-  AuthConfigHandle createAuthConfig(const string& user, const string& password) const;
+  SharedHandle<AuthConfig> createAuthConfig(const std::string& user, const std::string& password) const;
 
-  AuthResolverHandle createHttpAuthResolver() const;
+  SharedHandle<AuthResolver> createHttpAuthResolver() const;
   
-  AuthResolverHandle createHttpProxyAuthResolver() const;
+  SharedHandle<AuthResolver> createHttpProxyAuthResolver() const;
   
-  AuthResolverHandle createFtpAuthResolver() const;
+  SharedHandle<AuthResolver> createFtpAuthResolver() const;
 
 public:
   
@@ -67,14 +68,16 @@ public:
 
   ~AuthConfigFactory();
 
-  AuthConfigHandle createAuthConfig(const RequestHandle& request) const;
+  SharedHandle<AuthConfig> createAuthConfig(const SharedHandle<Request>& request) const;
 
-  AuthConfigHandle createAuthConfigForHttpProxy(const RequestHandle& request) const;
+  SharedHandle<AuthConfig> createAuthConfigForHttpProxy(const SharedHandle<Request>& request) const;
 
-  void setNetrc(const NetrcHandle& netrc);
+  void setNetrc(const SharedHandle<Netrc>& netrc);
 };
 
 typedef SharedHandle<AuthConfigFactory> AuthConfigFactoryHandle;
 typedef SingletonHolder<AuthConfigFactoryHandle> AuthConfigFactorySingleton;
 
+} // namespace aria2
+
 #endif // _D_AUTH_CONFIG_FACTORY_H_
diff --git a/src/AuthResolver.h b/src/AuthResolver.h
index 8ad0c254..650f8d56 100644
--- a/src/AuthResolver.h
+++ b/src/AuthResolver.h
@@ -36,15 +36,22 @@
 #define _D_AUTH_RESOLVER_H_
 
 #include "common.h"
-#include "AuthConfig.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
+
+class AuthConfig;
 
 class AuthResolver {
 public:
   virtual ~AuthResolver() {}
 
-  virtual AuthConfigHandle resolveAuthConfig(const string& hostname) = 0;
+  virtual SharedHandle<AuthConfig> resolveAuthConfig(const std::string& hostname) = 0;
 };
 
 typedef SharedHandle<AuthResolver> AuthResolverHandle;
 
+} // namespace aria2
+
 #endif // _D_AUTH_RESOLVER_H_
diff --git a/src/AutoSaveCommand.cc b/src/AutoSaveCommand.cc
index 238eb655..703ed531 100644
--- a/src/AutoSaveCommand.cc
+++ b/src/AutoSaveCommand.cc
@@ -36,6 +36,8 @@
 #include "DownloadEngine.h"
 #include "RequestGroupMan.h"
 
+namespace aria2 {
+
 AutoSaveCommand::AutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval):
   TimeBasedCommand(cuid, e, interval) {}
 
@@ -52,3 +54,5 @@ void AutoSaveCommand::process()
 {
   _e->_requestGroupMan->save();
 }
+
+} // namespace aria2
diff --git a/src/AutoSaveCommand.h b/src/AutoSaveCommand.h
index e0a700c2..8ed07ba5 100644
--- a/src/AutoSaveCommand.h
+++ b/src/AutoSaveCommand.h
@@ -37,6 +37,8 @@
 
 #include "TimeBasedCommand.h"
 
+namespace aria2 {
+
 class AutoSaveCommand : public TimeBasedCommand
 {
 public:
@@ -49,4 +51,6 @@ public:
   virtual void process();
 };
 
+} // namespace aria2
+
 #endif // _D_AUTO_SAVE_COMMAND_H_
diff --git a/src/BNode.cc b/src/BNode.cc
index 6e8f7d69..e8275ab5 100644
--- a/src/BNode.cc
+++ b/src/BNode.cc
@@ -35,10 +35,16 @@
 #include "BNode.h"
 #include "DHTBucket.h"
 #include "DHTNode.h"
+#include <functional>
+#include <algorithm>
 
-BNode::BNode(const DHTBucketHandle& bucket):_bucket(bucket),
-					    _up(0),
-					    _left(0), _right(0) {}
+namespace aria2 {
+
+BNode::BNode(const SharedHandle<DHTBucket>& bucket):
+  _bucket(bucket),
+  _up(0),
+  _left(0),
+  _right(0) {}
 
 BNode::~BNode()
 {
@@ -46,7 +52,7 @@ BNode::~BNode()
   delete _right;
 }
 
-DHTBucketHandle BNode::getBucket() const
+SharedHandle<DHTBucket> BNode::getBucket() const
 {
   return _bucket;
 }
@@ -83,7 +89,7 @@ void BNode::setUp(BNode* up)
   _up = up;
 }
 
-void BNode::setBucket(const DHTBucketHandle& bucket)
+void BNode::setBucket(const SharedHandle<DHTBucket>& bucket)
 {
   _bucket = bucket;
 }
@@ -117,7 +123,7 @@ BNode* BNode::findBNodeFor(BNode* b, const unsigned char* key)
   return 0;
 }
 
-DHTBucketHandle BNode::findBucketFor(BNode* b, const unsigned char* key)
+SharedHandle<DHTBucket> BNode::findBucketFor(BNode* b, const unsigned char* key)
 {
   BNode* bnode = findBNodeFor(b, key);
   if(bnode) {
@@ -128,22 +134,22 @@ DHTBucketHandle BNode::findBucketFor(BNode* b, const unsigned char* key)
 }
 
 
-DHTNodes BNode::findClosestKNodes(BNode* b, const unsigned char* key)
+std::deque<SharedHandle<DHTNode> > BNode::findClosestKNodes(BNode* b, const unsigned char* key)
 {
   BNode* bnode = findBNodeFor(b, key);
-  DHTNodes nodes;
+  std::deque<SharedHandle<DHTNode> > nodes;
   if(!bnode) {
     return nodes;
   }
   {
-    DHTBucketHandle bucket = bnode->getBucket();
-    DHTNodes goodNodes = bucket->getGoodNodes();
+    SharedHandle<DHTBucket> bucket = bnode->getBucket();
+    std::deque<SharedHandle<DHTNode> > goodNodes = bucket->getGoodNodes();
     nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
   }
   if(nodes.size() >= DHTBucket::K) {
     return nodes;
   }
-  BNodes visited;
+  std::deque<const BNode*> visited;
   visited.push_back(bnode);
 
   BNode* up = bnode->getUp();
@@ -156,16 +162,16 @@ DHTNodes BNode::findClosestKNodes(BNode* b, const unsigned char* key)
   }
   bnode = up;
 
-  const_mem_fun_t<BNode*, BNode> firstfunc = leftFirst?mem_fun(&BNode::getLeft):mem_fun(&BNode::getRight);
-  const_mem_fun_t<BNode*, BNode> secondfunc = leftFirst?mem_fun(&BNode::getRight):mem_fun(&BNode::getLeft);
+  std::const_mem_fun_t<BNode*, BNode> firstfunc = leftFirst?std::mem_fun(&BNode::getLeft):std::mem_fun(&BNode::getRight);
+  std::const_mem_fun_t<BNode*, BNode> secondfunc = leftFirst?std::mem_fun(&BNode::getRight):std::mem_fun(&BNode::getLeft);
   while(nodes.size() < DHTBucket::K) {
     
     if(!bnode->getLeft() && !bnode->getRight()) {
       bnode = bnode->getUp();
     } else {
-      if(find(visited.begin(), visited.end(), firstfunc(bnode)) == visited.end()) {
+      if(std::find(visited.begin(), visited.end(), firstfunc(bnode)) == visited.end()) {
 	bnode = firstfunc(bnode);
-      } else if(find(visited.begin(), visited.end(), secondfunc(bnode)) == visited.end()) {
+      } else if(std::find(visited.begin(), visited.end(), secondfunc(bnode)) == visited.end()) {
 	bnode = secondfunc(bnode);
       } else {
 	bnode = bnode->getUp();
@@ -176,9 +182,9 @@ DHTNodes BNode::findClosestKNodes(BNode* b, const unsigned char* key)
       break;
     }
     {
-      DHTBucketHandle bucket = bnode->getBucket();
+      SharedHandle<DHTBucket> bucket = bnode->getBucket();
       if(!bucket.isNull()) {
-	DHTNodes goodNodes = bucket->getGoodNodes();
+	std::deque<SharedHandle<DHTNode> > goodNodes = bucket->getGoodNodes();
 	size_t r = DHTBucket::K-nodes.size();
 	if(goodNodes.size() <= r) {
 	  nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
@@ -191,10 +197,10 @@ DHTNodes BNode::findClosestKNodes(BNode* b, const unsigned char* key)
   return nodes;
 }
 
-DHTBuckets BNode::enumerateBucket(const BNode* b)
+std::deque<SharedHandle<DHTBucket> > BNode::enumerateBucket(const BNode* b)
 {
-  DHTBuckets buckets;
-  deque<const BNode*> visited;
+  std::deque<SharedHandle<DHTBucket> > buckets;
+  std::deque<const BNode*> visited;
   visited.push_back(b);
   while(1) {
     if(!b) {
@@ -203,10 +209,10 @@ DHTBuckets BNode::enumerateBucket(const BNode* b)
     if(!b->getBucket().isNull()) {
       buckets.push_back(b->getBucket());
       b = b->getUp();
-    } else if(find(visited.begin(), visited.end(), b->getLeft()) == visited.end()) {
+    } else if(std::find(visited.begin(), visited.end(), b->getLeft()) == visited.end()) {
       b = b->getLeft();
       visited.push_back(b);
-    } else if(find(visited.begin(), visited.end(), b->getRight()) == visited.end()) {
+    } else if(std::find(visited.begin(), visited.end(), b->getRight()) == visited.end()) {
       b = b->getRight();
       visited.push_back(b);
     } else {
@@ -215,3 +221,5 @@ DHTBuckets BNode::enumerateBucket(const BNode* b)
   }
   return buckets;
 }
+
+} // namespace aria2
diff --git a/src/BNode.h b/src/BNode.h
index 4be3ac8f..5b75ee78 100644
--- a/src/BNode.h
+++ b/src/BNode.h
@@ -36,13 +36,17 @@
 #define _D_BNODE_H_
 
 #include "common.h"
-#include "DHTBucketDecl.h"
-#include "BNodeDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class DHTBucket;
+class DHTNode;
 
 class BNode {
 private:
-  DHTBucketHandle _bucket;
+  SharedHandle<DHTBucket> _bucket;
 
   BNode* _up;
 
@@ -51,13 +55,13 @@ private:
   BNode* _right;
 
 public:
-  BNode(const DHTBucketHandle& bucket = 0);
+  BNode(const SharedHandle<DHTBucket>& bucket = 0);
 
   ~BNode();
 
-  DHTBucketHandle getBucket() const;
+  SharedHandle<DHTBucket> getBucket() const;
 
-  void setBucket(const DHTBucketHandle& bucket);
+  void setBucket(const SharedHandle<DHTBucket>& bucket);
 
   BNode* getLeft() const;
 
@@ -75,11 +79,13 @@ public:
 
   static BNode* findBNodeFor(BNode* b, const unsigned char* key);
 
-  static DHTBucketHandle findBucketFor(BNode* b, const unsigned char* key);
+  static SharedHandle<DHTBucket> findBucketFor(BNode* b, const unsigned char* key);
 
-  static DHTNodes findClosestKNodes(BNode* b, const unsigned char* key);
+  static std::deque<SharedHandle<DHTNode> > findClosestKNodes(BNode* b, const unsigned char* key);
 
-  static DHTBuckets enumerateBucket(const BNode* b);
+  static std::deque<SharedHandle<DHTBucket> > enumerateBucket(const BNode* b);
 };
 
+} // namespace aria2
+
 #endif // _D_BNODE_H_
diff --git a/src/Base64.cc b/src/Base64.cc
index 6c5ee218..5a19185c 100644
--- a/src/Base64.cc
+++ b/src/Base64.cc
@@ -34,6 +34,8 @@
 /* copyright --> */
 #include "Base64.h"
 
+namespace aria2 {
+
 static const char CHAR_TABLE[] = {
   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
   'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
@@ -179,22 +181,24 @@ void Base64::decode(unsigned char*& result, size_t& rlength,
   delete [] nsrc;
 }
 
-string Base64::encode(const string& s)
+std::string Base64::encode(const std::string& s)
 {
   unsigned char* buf = 0;
   size_t len;
   encode(buf, len, s.c_str(), s.size());
-  string r(&buf[0], &buf[len]);
+  std::string r(&buf[0], &buf[len]);
   delete [] buf;
   return r;
 }
 
-string Base64::decode(const string& s)
+std::string Base64::decode(const std::string& s)
 {
   unsigned char* buf = 0;
   size_t len;
   decode(buf, len, s.c_str(), s.size());
-  string r(&buf[0], &buf[len]);
+  std::string r(&buf[0], &buf[len]);
   delete [] buf;
   return r;
 }
+
+} // namespace aria2
diff --git a/src/Base64.h b/src/Base64.h
index 3c64cade..50df9726 100644
--- a/src/Base64.h
+++ b/src/Base64.h
@@ -36,7 +36,7 @@
 #define _D_BASE64_H_
 #include <string>
 
-using namespace std;
+namespace aria2 {
 
 class Base64
 {
@@ -67,7 +67,7 @@ public:
     encode(result, rlength, (const unsigned char*)src, slength);
   }
 
-  static string encode(const string& s);
+  static std::string encode(const std::string& s);
 
   /**
    * Dencods base64 encoded src whose length is slength and stores them to
@@ -87,7 +87,9 @@ public:
     decode(result, rlength, (const unsigned char*)src, slength);
   }
 
-  static string decode(const string& s);
+  static std::string decode(const std::string& s);
 };
 
+} // namespace aria2
+
 #endif // _BASE64_H_
diff --git a/src/BencodeVisitor.cc b/src/BencodeVisitor.cc
index b21585ee..f8fc0446 100644
--- a/src/BencodeVisitor.cc
+++ b/src/BencodeVisitor.cc
@@ -37,6 +37,10 @@
 #include "List.h"
 #include "Dictionary.h"
 #include "Util.h"
+#include <functional>
+#include <algorithm>
+
+namespace aria2 {
 
 BencodeVisitor::BencodeVisitor() {}
 
@@ -54,8 +58,8 @@ void BencodeVisitor::visit(const Data* d)
 void BencodeVisitor::visit(const List* l)
 {
   _bencodedData += "l";
-  for_each(l->getList().begin(), l->getList().end(),
-	   bind2nd(mem_fun(&MetaEntry::accept), this));
+  std::for_each(l->getList().begin(), l->getList().end(),
+		std::bind2nd(std::mem_fun(&MetaEntry::accept), this));
   _bencodedData += "e";
 }
 
@@ -63,7 +67,7 @@ void BencodeVisitor::visit(const Dictionary* d)
 {
   _bencodedData += "d";
 
-  for(Order::const_iterator itr = d->getOrder().begin(); itr != d->getOrder().end(); ++itr) {
+  for(std::deque<std::string>::const_iterator itr = d->getOrder().begin(); itr != d->getOrder().end(); ++itr) {
     _bencodedData += Util::itos((int32_t)(*itr).size());
     _bencodedData += ":";
     _bencodedData += *itr;
@@ -82,3 +86,5 @@ void BencodeVisitor::visit(const MetaEntry* e)
     visit(reinterpret_cast<const Dictionary*>(e));
   }
 }
+
+} // namespace aria2
diff --git a/src/BencodeVisitor.h b/src/BencodeVisitor.h
index f473a78e..3e04bbf9 100644
--- a/src/BencodeVisitor.h
+++ b/src/BencodeVisitor.h
@@ -36,6 +36,9 @@
 #define _D_BENCODE_VISITOR_H_
 
 #include "MetaEntryVisitor.h"
+#include <string>
+
+namespace aria2 {
 
 class Data;
 class Dictionary;
@@ -44,7 +47,7 @@ class MetaEntry;
 
 class BencodeVisitor : public MetaEntryVisitor {
 private:
-  string _bencodedData;
+  std::string _bencodedData;
 public:
   BencodeVisitor();
   ~BencodeVisitor();
@@ -55,10 +58,12 @@ public:
 
   virtual void visit(const MetaEntry* e);
 
-  const string& getBencodedData() const
+  const std::string& getBencodedData() const
   {
     return _bencodedData;
   }
 };
 
+} // namespace aria2
+
 #endif // _D_BENCODE_VISITOR_H_
diff --git a/src/BinaryStream.h b/src/BinaryStream.h
index 335bc5c5..24b188d4 100644
--- a/src/BinaryStream.h
+++ b/src/BinaryStream.h
@@ -36,7 +36,9 @@
 #define _D_BINARY_STREAM_H_
 
 #include "common.h"
-#include "DlAbortEx.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class BinaryStream {
 public:
@@ -57,4 +59,6 @@ public:
 
 typedef SharedHandle<BinaryStream> BinaryStreamHandle;
 
+} // namespace aria2
+
 #endif // _D_BINARY_STREAM_H_
diff --git a/src/BitfieldMan.cc b/src/BitfieldMan.cc
index 2a4a04d2..aadc6025 100644
--- a/src/BitfieldMan.cc
+++ b/src/BitfieldMan.cc
@@ -33,9 +33,12 @@
  */
 /* copyright --> */
 #include "BitfieldMan.h"
+#include "Randomizer.h"
 #include "Util.h"
 #include "array_fun.h"
-#include <string.h>
+#include <cstring>
+
+namespace aria2 {
 
 BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
   :blockLength(blockLength),
@@ -99,12 +102,63 @@ BitfieldMan::BitfieldMan(const BitfieldMan& bitfieldMan)
   updateCache();
 }
 
+BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan)
+{
+  if(this != &bitfieldMan) {
+    blockLength = bitfieldMan.blockLength;
+    totalLength = bitfieldMan.totalLength;
+    blocks = bitfieldMan.blocks;
+    bitfieldLength = bitfieldMan.bitfieldLength;
+    filterEnabled = bitfieldMan.filterEnabled;
+
+    delete [] bitfield;
+    bitfield = new unsigned char[bitfieldLength];
+    memcpy(bitfield, bitfieldMan.bitfield, bitfieldLength);
+
+    delete [] useBitfield;
+    useBitfield = new unsigned char[bitfieldLength];
+    memcpy(useBitfield, bitfieldMan.useBitfield, bitfieldLength);
+
+    delete [] filterBitfield;
+    if(filterEnabled) {
+      filterBitfield = new unsigned char[bitfieldLength];
+      memcpy(filterBitfield, bitfieldMan.filterBitfield, bitfieldLength);
+    } else {
+      filterBitfield = 0;
+    }
+
+    updateCache();
+  }
+  return *this;
+}
+
 BitfieldMan::~BitfieldMan() {
   delete [] bitfield;
   delete [] useBitfield;
   delete [] filterBitfield;
 }
 
+int32_t BitfieldMan::getBlockLength() const
+{
+  return blockLength;
+}
+
+int32_t BitfieldMan::getLastBlockLength() const
+{
+  return totalLength-blockLength*(blocks-1);
+}
+
+int32_t BitfieldMan::getBlockLength(int32_t index) const
+{
+  if(index == blocks-1) {
+    return getLastBlockLength();
+  } else if(0 <= index && index < blocks-1) {
+    return getBlockLength();
+  } else {
+    return 0;
+  }
+}
+
 int32_t BitfieldMan::countSetBit(const unsigned char* bitfield, int32_t len) const {
   int32_t count = 0;
   int32_t size = sizeof(int32_t);
@@ -332,9 +386,9 @@ int32_t BitfieldMan::getSparseMissingUnusedIndex() const {
 }
 
 template<typename Array>
-BlockIndexes BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const
+std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const
 {
-  BlockIndexes missingIndexes;
+  std::deque<int32_t> missingIndexes;
   for(int32_t i = 0; i < bitfieldLength; ++i) {
     int32_t base = i*8;
     for(int32_t bi = 0; bi < 8 && base+bi < blocks; ++bi) {
@@ -347,7 +401,7 @@ BlockIndexes BitfieldMan::getAllMissingIndexes(const Array& bitfield, int32_t bi
   return missingIndexes;
 }
 
-BlockIndexes BitfieldMan::getAllMissingIndexes() const {
+std::deque<int32_t> BitfieldMan::getAllMissingIndexes() const {
   array_fun<unsigned char> bf = array_negate(bitfield);
   if(filterEnabled) {
     bf = array_and(bf, filterBitfield);
@@ -355,9 +409,9 @@ BlockIndexes BitfieldMan::getAllMissingIndexes() const {
   return getAllMissingIndexes(bf, bitfieldLength);
 }
 
-BlockIndexes BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, int32_t peerBitfieldLength) const {
+std::deque<int32_t> BitfieldMan::getAllMissingIndexes(const unsigned char* peerBitfield, int32_t peerBitfieldLength) const {
   if(bitfieldLength != peerBitfieldLength) {
-    return BlockIndexes();
+    return std::deque<int32_t>();
   }
   array_fun<unsigned char> bf = array_and(array_negate(bitfield),
 					  peerBitfield);
@@ -402,6 +456,11 @@ int32_t BitfieldMan::countFilteredBlockNow() const {
   }
 }
 
+int32_t BitfieldMan::getMaxIndex() const
+{
+  return blocks-1;
+}
+
 bool BitfieldMan::setBitInternal(unsigned char* bitfield, int32_t index, bool on) {
   if(blocks <= index) { return false; }
   unsigned char mask = 128 >> index%8;
@@ -485,6 +544,16 @@ void BitfieldMan::setBitfield(const unsigned char* bitfield, int32_t bitfieldLen
   updateCache();
 }
 
+const unsigned char* BitfieldMan::getBitfield() const
+{
+  return bitfield;
+}
+
+int32_t BitfieldMan::getBitfieldLength() const
+{
+  return bitfieldLength;
+}
+
 void BitfieldMan::clearAllBit() {
   memset(this->bitfield, 0, this->bitfieldLength);
   updateCache();
@@ -680,3 +749,15 @@ int64_t BitfieldMan::getMissingUnusedLength(int32_t startingIndex) const
   }
   return length;
 }
+
+void BitfieldMan::setRandomizer(const SharedHandle<Randomizer>& randomizer)
+{
+  this->randomizer = randomizer;
+}
+
+SharedHandle<Randomizer> BitfieldMan::getRandomizer() const
+{
+  return randomizer;
+}
+
+} // namespace aria2
diff --git a/src/BitfieldMan.h b/src/BitfieldMan.h
index 8e976413..b4509354 100644
--- a/src/BitfieldMan.h
+++ b/src/BitfieldMan.h
@@ -36,10 +36,12 @@
 #define _D_BITFIELD_MAN_H_
 
 #include "common.h"
-#include "Randomizer.h"
+#include "SharedHandle.h"
 #include <deque>
 
-typedef deque<int> BlockIndexes;
+namespace aria2 {
+
+class Randomizer;
 
 class BitfieldMan {
 private:
@@ -51,7 +53,7 @@ private:
   int32_t bitfieldLength;
   int32_t blocks;
   bool filterEnabled;
-  RandomizerHandle randomizer;
+  SharedHandle<Randomizer> randomizer;
 
   // for caching
   int32_t cachedNumMissingBlock;
@@ -72,7 +74,7 @@ private:
   int32_t getFirstMissingIndex(const Array& bitfield, int32_t bitfieldLength) const;
 
   template<typename Array>
-  BlockIndexes getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const;
+  std::deque<int32_t> getAllMissingIndexes(const Array& bitfield, int32_t bitfieldLength) const;
 
   bool isBitSetInternal(const unsigned char* bitfield, int32_t index) const;
   bool setBitInternal(unsigned char* bitfield, int32_t index, bool on);
@@ -87,50 +89,13 @@ public:
   BitfieldMan(const BitfieldMan& bitfieldMan);
   ~BitfieldMan();
 
-  BitfieldMan& operator=(const BitfieldMan& bitfieldMan) {
-    if(this != &bitfieldMan) {
-      blockLength = bitfieldMan.blockLength;
-      totalLength = bitfieldMan.totalLength;
-      blocks = bitfieldMan.blocks;
-      bitfieldLength = bitfieldMan.bitfieldLength;
-      filterEnabled = bitfieldMan.filterEnabled;
+  BitfieldMan& operator=(const BitfieldMan& bitfieldMan);
 
-      delete [] bitfield;
-      bitfield = new unsigned char[bitfieldLength];
-      memcpy(bitfield, bitfieldMan.bitfield, bitfieldLength);
+  int32_t getBlockLength() const;
 
-      delete [] useBitfield;
-      useBitfield = new unsigned char[bitfieldLength];
-      memcpy(useBitfield, bitfieldMan.useBitfield, bitfieldLength);
+  int32_t getLastBlockLength() const;
 
-      delete [] filterBitfield;
-      if(filterEnabled) {
-	filterBitfield = new unsigned char[bitfieldLength];
-	memcpy(filterBitfield, bitfieldMan.filterBitfield, bitfieldLength);
-      } else {
-	filterBitfield = 0;
-      }
-
-      updateCache();
-    }
-    return *this;
-  }
-
-  int32_t getBlockLength() const { return blockLength; }
-
-  int32_t getLastBlockLength() const {
-    return totalLength-blockLength*(blocks-1);
-  }
-
-  int32_t getBlockLength(int32_t index) const {
-    if(index == blocks-1) {
-      return getLastBlockLength();
-    } else if(0 <= index && index < blocks-1) {
-      return getBlockLength();
-    } else {
-      return 0;
-    }
-  }
+  int32_t getBlockLength(int32_t index) const;
 
   int64_t getTotalLength() const { return totalLength; }
 
@@ -173,11 +138,11 @@ public:
   /**
    * affected by filter
    */
-  BlockIndexes getAllMissingIndexes() const;
+  std::deque<int32_t> getAllMissingIndexes() const;
   /**
    * affected by filter
    */
-  BlockIndexes getAllMissingIndexes(const unsigned char* bitfield, int32_t len) const;
+  std::deque<int32_t> getAllMissingIndexes(const unsigned char* bitfield, int32_t len) const;
   /**
    * affected by filter
    */
@@ -203,8 +168,9 @@ public:
 
   bool isAllBitSet() const;
 
-  const unsigned char* getBitfield() const { return bitfield; }
-  int32_t getBitfieldLength() const { return bitfieldLength; }
+  const unsigned char* getBitfield() const;
+
+  int32_t getBitfieldLength() const;
 
   /**
    * affected by filter
@@ -217,7 +183,7 @@ public:
    */
   int32_t countFilteredBlockNow() const;
 
-  int32_t getMaxIndex() const { return blocks-1; }
+  int32_t getMaxIndex() const;
 
   void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength);
 
@@ -258,13 +224,9 @@ public:
    */
   int64_t getFilteredCompletedLengthNow() const;
 
-  void setRandomizer(const RandomizerHandle& randomizer) {
-    this->randomizer = randomizer;
-  }
+  void setRandomizer(const SharedHandle<Randomizer>& randomizer);
 
-  RandomizerHandle getRandomizer() const {
-    return randomizer;
-  }
+  SharedHandle<Randomizer> getRandomizer() const;
 
   void updateCache();
 
@@ -280,4 +242,6 @@ public:
 
 };
 
+} // namespace aria2
+
 #endif // _D_BITFIELD_MAN_H_
diff --git a/src/BitfieldManFactory.cc b/src/BitfieldManFactory.cc
index 20db54e8..e4a30f6e 100644
--- a/src/BitfieldManFactory.cc
+++ b/src/BitfieldManFactory.cc
@@ -33,8 +33,51 @@
  */
 /* copyright --> */
 #include "BitfieldManFactory.h"
-#include "SimpleRandomizer.h"
+#include "BitfieldMan.h"
+#include "Randomizer.h"
+
+namespace aria2 {
 
 BitfieldManFactoryHandle BitfieldManFactory::factory = 0;
 
+BitfieldManFactoryHandle BitfieldManFactory::getFactoryInstance()
+{
+  if(factory.isNull()) {
+    factory = new BitfieldManFactory();
+  }
+  return factory;
+}
+
 BitfieldManFactory::BitfieldManFactory():randomizer(0) {}
+
+BitfieldManFactory::~BitfieldManFactory() {}
+
+BitfieldMan*
+BitfieldManFactory::createBitfieldMan(int32_t blockLength, int64_t totalLength)
+{
+  BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength);
+  bitfieldMan->setRandomizer(randomizer);
+  return bitfieldMan;
+}
+
+void BitfieldManFactory::setDefaultRandomizer(const RandomizerHandle& randomizer) {
+  BitfieldManFactoryHandle factory = getFactoryInstance();
+  factory->setRandomizer(randomizer);
+}
+
+RandomizerHandle BitfieldManFactory::getDefaultRandomizer()
+{
+  return getFactoryInstance()->getRandomizer();
+}
+
+void BitfieldManFactory::setRandomizer(const RandomizerHandle& randomizer)
+{
+  this->randomizer = randomizer;
+}
+
+RandomizerHandle BitfieldManFactory::getRandomizer() const
+{
+  return randomizer;
+}
+
+} // namespace aria2
diff --git a/src/BitfieldManFactory.h b/src/BitfieldManFactory.h
index dfc86487..c9a1217a 100644
--- a/src/BitfieldManFactory.h
+++ b/src/BitfieldManFactory.h
@@ -36,52 +36,38 @@
 #define _D_BITFIELD_MAN_FACTORY_H_
 
 #include "common.h"
-#include "Randomizer.h"
-#include "BitfieldMan.h"
+#include "SharedHandle.h"
 
-class BitfieldManFactory;
+namespace aria2 {
 
-typedef SharedHandle<BitfieldManFactory> BitfieldManFactoryHandle;
+class Randomizer;
+class BitfieldMan;
 
 class BitfieldManFactory {
 private:
-  static BitfieldManFactoryHandle factory;
+  static SharedHandle<BitfieldManFactory> factory;
 
-  RandomizerHandle randomizer;
+  SharedHandle<Randomizer> randomizer;
 
   BitfieldManFactory();
 public:
-  ~BitfieldManFactory() {}
+  ~BitfieldManFactory();
 
-  static BitfieldManFactoryHandle getFactoryInstance() {
-    if(factory.isNull()) {
-      factory = new BitfieldManFactory();
-    }
-    return factory;
-  }
+  static SharedHandle<BitfieldManFactory> getFactoryInstance();
 
-  BitfieldMan* createBitfieldMan(int32_t blockLength, int64_t totalLength) {
-    BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength);
-    bitfieldMan->setRandomizer(randomizer);
-    return bitfieldMan;
-  }
+  BitfieldMan* createBitfieldMan(int32_t blockLength, int64_t totalLength);
 
-  static void setDefaultRandomizer(const RandomizerHandle& randomizer) {
-    BitfieldManFactoryHandle factory = getFactoryInstance();
-    factory->setRandomizer(randomizer);
-  }
+  static void setDefaultRandomizer(const SharedHandle<Randomizer>& randomizer);
 
-  static RandomizerHandle getDefaultRandomizer() {
-    return getFactoryInstance()->getRandomizer();
-  }
+  static SharedHandle<Randomizer> getDefaultRandomizer();
 
-  void setRandomizer(const RandomizerHandle& randomizer) {
-    this->randomizer = randomizer;
-  }
+  void setRandomizer(const SharedHandle<Randomizer>& randomizer);
 
-  RandomizerHandle getRandomizer() const {
-    return randomizer;
-  }
+  SharedHandle<Randomizer> getRandomizer() const;
 };
 
+typedef SharedHandle<BitfieldManFactory> BitfieldManFactoryHandle;
+
+} // namespace aria2
+
 #endif // _D_BITFIELD_MAN_FACTORY_H_
diff --git a/src/BtAbortOutstandingRequestEvent.h b/src/BtAbortOutstandingRequestEvent.h
index 6d334bae..53e077ba 100644
--- a/src/BtAbortOutstandingRequestEvent.h
+++ b/src/BtAbortOutstandingRequestEvent.h
@@ -37,21 +37,27 @@
 
 #include "BtEvent.h"
 
+namespace aria2 {
+
+class Piece;
+
 class BtAbortOutstandingRequestEvent : public BtEvent {
 private:
-  PieceHandle piece;
+  SharedHandle<Piece> piece;
 public:
-  BtAbortOutstandingRequestEvent(const PieceHandle& piece):piece(piece) {}
+  BtAbortOutstandingRequestEvent(const SharedHandle<Piece>& piece):piece(piece) {}
 
-  PieceHandle getPiece() const {
+  SharedHandle<Piece> getPiece() const {
     return piece;
   }
 
-  void setPiece(const PieceHandle& piece) {
+  void setPiece(const SharedHandle<Piece>& piece) {
     this->piece = piece;
   }
 };
 
 typedef SharedHandle<BtAbortOutstandingRequestEvent> BtAbortOutstandingRequestEventHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_ABORT_OUTSTANDING_REQUEST_EVENT_H_
diff --git a/src/BtAllowedFastMessage.cc b/src/BtAllowedFastMessage.cc
index cae4c8d1..7f3f29eb 100644
--- a/src/BtAllowedFastMessage.cc
+++ b/src/BtAllowedFastMessage.cc
@@ -37,6 +37,9 @@
 #include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtAllowedFastMessageHandle BtAllowedFastMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 5) {
@@ -84,6 +87,8 @@ void BtAllowedFastMessage::onSendComplete() {
   peer->addAmAllowedIndex(index);
 }
 
-string BtAllowedFastMessage::toString() const {
+std::string BtAllowedFastMessage::toString() const {
   return "allowed fast index="+Util::itos(index);
 }
+
+} // namespace aria2
diff --git a/src/BtAllowedFastMessage.h b/src/BtAllowedFastMessage.h
index 266b4a91..90900a43 100644
--- a/src/BtAllowedFastMessage.h
+++ b/src/BtAllowedFastMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtAllowedFastMessage;
 
 typedef SharedHandle<BtAllowedFastMessage> BtAllowedFastMessageHandle;
@@ -74,10 +76,12 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual void onSendComplete();
 
 };
 
+} // namespace aria2
+
 #endif // _D_BT_ALLOWED_FAST_MESSAGE_H_
diff --git a/src/BtAllowedFastMessageValidator.h b/src/BtAllowedFastMessageValidator.h
index e197d7c6..70083de8 100644
--- a/src/BtAllowedFastMessageValidator.h
+++ b/src/BtAllowedFastMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtAllowedFastMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtAllowedFastMessageValidator : public BtMessageValidator {
 private:
@@ -57,4 +60,6 @@ public:
 
 typedef SharedHandle<BtAllowedFastMessageValidator> BtAllowedFastMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_ALLOWED_FAST_MESSAGE_VALIDATOR_H_
diff --git a/src/BtAnnounce.h b/src/BtAnnounce.h
index 4288a6e4..8a9f647f 100644
--- a/src/BtAnnounce.h
+++ b/src/BtAnnounce.h
@@ -36,6 +36,10 @@
 #define _D_BT_ANNOUNCE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
 
 class BtAnnounce {
 public:
@@ -57,7 +61,7 @@ public:
   /**
    * Returns announe URL with all necessary parameters included.
    */
-  virtual string getAnnounceUrl() = 0;
+  virtual std::string getAnnounceUrl() = 0;
 
   /**
    * Tells that the announce process has just started.
@@ -103,4 +107,6 @@ public:
 
 typedef SharedHandle<BtAnnounce> BtAnnounceHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_ANNOUNCE_H_
diff --git a/src/BtBitfieldMessage.cc b/src/BtBitfieldMessage.cc
index 294d8b51..19d2a4a9 100644
--- a/src/BtBitfieldMessage.cc
+++ b/src/BtBitfieldMessage.cc
@@ -37,6 +37,10 @@
 #include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+#include <cstring>
+
+namespace aria2 {
 
 void BtBitfieldMessage::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) {
   if(this->bitfield == bitfield) {
@@ -90,6 +94,8 @@ int32_t BtBitfieldMessage::getMessageLength() {
   return msgLength;
 }
 
-string BtBitfieldMessage::toString() const {
+std::string BtBitfieldMessage::toString() const {
   return "bitfield "+Util::toHex(bitfield, bitfieldLength);
 }
+
+} // namespace aria2
diff --git a/src/BtBitfieldMessage.h b/src/BtBitfieldMessage.h
index 283e3e10..d9361b38 100644
--- a/src/BtBitfieldMessage.h
+++ b/src/BtBitfieldMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtBitfieldMessage;
 
 typedef SharedHandle<BtBitfieldMessage> BtBitfieldMessageHandle;
@@ -90,7 +92,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_BITFIELD_MESSAGE_H_
diff --git a/src/BtBitfieldMessageValidator.h b/src/BtBitfieldMessageValidator.h
index 6d69d622..15eb5c18 100644
--- a/src/BtBitfieldMessageValidator.h
+++ b/src/BtBitfieldMessageValidator.h
@@ -38,6 +38,8 @@
 #include "BtMessageValidator.h"
 #include "BtBitfieldMessage.h"
 
+namespace aria2 {
+
 class BtBitfieldMessageValidator : public BtMessageValidator {
 private:
   const BtBitfieldMessage* message;
@@ -58,4 +60,7 @@ public:
 };
 
 typedef SharedHandle<BtBitfieldMessageValidator> BtBitfieldMessageValidatorHandle;
+
+} // namespace aria2
+
 #endif // _D_BT_BITFIELD_MESSAGE_VALIDATOR_H_
diff --git a/src/BtCancelMessage.cc b/src/BtCancelMessage.cc
index b5df0433..63d4a44a 100644
--- a/src/BtCancelMessage.cc
+++ b/src/BtCancelMessage.cc
@@ -37,6 +37,9 @@
 #include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "BtMessageDispatcher.h"
+
+namespace aria2 {
 
 BtCancelMessageHandle BtCancelMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 13) {
@@ -82,7 +85,9 @@ int32_t BtCancelMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtCancelMessage::toString() const {
+std::string BtCancelMessage::toString() const {
   return "cancel index="+Util::itos(index)+", begin="+Util::itos(begin)+
     ", length="+Util::itos(length);
 }
+
+} // namespace aria2
diff --git a/src/BtCancelMessage.h b/src/BtCancelMessage.h
index 8d91a04d..babefe3e 100644
--- a/src/BtCancelMessage.h
+++ b/src/BtCancelMessage.h
@@ -36,7 +36,8 @@
 #define _D_BT_CANCEL_MESSAGE_H_
 
 #include "SimpleBtMessage.h"
-#include "message.h"
+
+namespace aria2 {
 
 class BtCancelMessage;
 
@@ -86,7 +87,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_CANCEL_MESSAGE_H_
diff --git a/src/BtCancelMessageValidator.h b/src/BtCancelMessageValidator.h
index 26ed9c50..23fa77b4 100644
--- a/src/BtCancelMessageValidator.h
+++ b/src/BtCancelMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtCancelMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtCancelMessageValidator : public BtMessageValidator {
 private:
@@ -64,4 +67,6 @@ public:
 
 typedef SharedHandle<BtCancelMessageValidator> BtCancelMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_CANCEL_MESSAGE_VALIDATOR_H_
diff --git a/src/BtCancelSendingPieceEvent.h b/src/BtCancelSendingPieceEvent.h
index 03f6320f..ced34bb6 100644
--- a/src/BtCancelSendingPieceEvent.h
+++ b/src/BtCancelSendingPieceEvent.h
@@ -37,6 +37,8 @@
 
 #include "BtEvent.h"
 
+namespace aria2 {
+
 class BtCancelSendingPieceEvent : public BtEvent {
 private:
   int32_t index;
@@ -75,4 +77,6 @@ public:
 
 typedef SharedHandle<BtCancelSendingPieceEvent> BtCancelSendingPieceEventHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_CANCEL_SENDING_PIECE_EVENT_H_
diff --git a/src/BtCheckIntegrityEntry.cc b/src/BtCheckIntegrityEntry.cc
index 1481e86e..fcde4b8f 100644
--- a/src/BtCheckIntegrityEntry.cc
+++ b/src/BtCheckIntegrityEntry.cc
@@ -33,15 +33,15 @@
  */
 /* copyright --> */
 #include "BtCheckIntegrityEntry.h"
-#include "BtSetup.h"
 #include "BtFileAllocationEntry.h"
-#include "CUIDCounter.h"
 #include "RequestGroup.h"
 #include "PieceStorage.h"
 #include "DownloadEngine.h"
 #include "FileAllocationMan.h"
 #include "DiskAdaptor.h"
 
+namespace aria2 {
+
 BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup):
   PieceHashCheckIntegrityEntry(requestGroup, 0) {}
 
@@ -68,3 +68,5 @@ Commands BtCheckIntegrityEntry::onDownloadFinished(DownloadEngine* e)
   // behavior.
   return onDownloadIncomplete(e);
 }
+
+} // namespace aria2
diff --git a/src/BtCheckIntegrityEntry.h b/src/BtCheckIntegrityEntry.h
index 977d3ecf..9625b9cb 100644
--- a/src/BtCheckIntegrityEntry.h
+++ b/src/BtCheckIntegrityEntry.h
@@ -37,17 +37,21 @@
 
 #include "PieceHashCheckIntegrityEntry.h"
 
+namespace aria2 {
+
 class BtCheckIntegrityEntry : public PieceHashCheckIntegrityEntry {
 public:
   BtCheckIntegrityEntry(RequestGroup* requestGroup);
 
   virtual ~BtCheckIntegrityEntry();
 
-  virtual Commands onDownloadFinished(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadFinished(DownloadEngine* e);
 
-  virtual Commands onDownloadIncomplete(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadIncomplete(DownloadEngine* e);
 };
 
 typedef SharedHandle<BtCheckIntegrityEntry> BtCheckIntegrityEntryHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/BtChokeMessage.cc b/src/BtChokeMessage.cc
index 6ba9d211..7b9eda8a 100644
--- a/src/BtChokeMessage.cc
+++ b/src/BtChokeMessage.cc
@@ -36,6 +36,11 @@
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+#include "BtMessageDispatcher.h"
+#include "BtRequestFactory.h"
+
+namespace aria2 {
 
 BtChokeMessageHandle BtChokeMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -83,6 +88,8 @@ void BtChokeMessage::onSendComplete() {
   dispatcher->doChokingAction();
 }
 
-string BtChokeMessage::toString() const {
+std::string BtChokeMessage::toString() const {
   return "choke";
 }
+
+} // namespace aria2
diff --git a/src/BtChokeMessage.h b/src/BtChokeMessage.h
index d30267b1..35b5c98a 100644
--- a/src/BtChokeMessage.h
+++ b/src/BtChokeMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtChokeMessage;
 
 typedef SharedHandle<BtChokeMessage> BtChokeMessageHandle;
@@ -63,7 +65,7 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   static BtChokeMessageHandle create(const unsigned char* data, int32_t dataLength);
 
@@ -72,4 +74,6 @@ public:
   virtual void onSendComplete();
 };
 
+} // namespace aria2
+
 #endif // _D_CHOKE_MESSAGE_H_
diff --git a/src/BtChokedEvent.h b/src/BtChokedEvent.h
index 8fbd293e..0d8fd914 100644
--- a/src/BtChokedEvent.h
+++ b/src/BtChokedEvent.h
@@ -36,10 +36,15 @@
 #define _D_BT_CHOKED_EVENT_H_
 
 #include "BtEvent.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class BtChokedEvent : public BtEvent {
 };
 
 typedef SharedHandle<BtChokedEvent> BtChokedEventHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_CHOKED_EVENT_H_
diff --git a/src/BtChokingEvent.h b/src/BtChokingEvent.h
index 36d852dd..8d8abd97 100644
--- a/src/BtChokingEvent.h
+++ b/src/BtChokingEvent.h
@@ -37,9 +37,13 @@
 
 #include "BtEvent.h"
 
+namespace aria2 {
+
 class BtChokingEvent : public BtEvent {
 };
 
 typedef SharedHandle<BtChokingEvent> BtChokingEventHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_CHOKING_EVENT_H_
diff --git a/src/BtConstants.h b/src/BtConstants.h
index d233a53a..b3995bca 100644
--- a/src/BtConstants.h
+++ b/src/BtConstants.h
@@ -38,6 +38,16 @@
 #include "common.h"
 #include <map>
 
-typedef map<string, uint8_t> Extensions;
+typedef std::map<std::string, uint8_t> Extensions;
+
+#define PEER_ID_LENGTH 20
+
+#define INFO_HASH_LENGTH 20
+
+#define MAX_PEER_ERROR 5
+
+#define MAX_PEERS 55
+
+#define DEFAULT_LATENCY 1500
 
 #endif // _D_BT_CONSTANTS_
diff --git a/src/BtContext.h b/src/BtContext.h
index c48dff74..462c9352 100644
--- a/src/BtContext.h
+++ b/src/BtContext.h
@@ -38,14 +38,9 @@
 #include "DownloadContext.h"
 #include "BtContextDecl.h"
 
-#define INFO_HASH_LENGTH 20
-#define MAX_PEER_ERROR 5
-#define MAX_PEERS 55
+namespace aria2 {
 
 class AnnounceTier;
-typedef SharedHandle<AnnounceTier> AnnounceTierHandle;
-typedef deque<AnnounceTierHandle> AnnounceTiers;
-
 class RequestGroup;
 
 class BtContext:public DownloadContext {
@@ -60,11 +55,12 @@ public:
 
   virtual int32_t getInfoHashLength() const = 0;
 
-  virtual string getInfoHashAsString() const = 0;
+  virtual std::string getInfoHashAsString() const = 0;
 
-  virtual AnnounceTiers getAnnounceTiers() const = 0;
+  virtual std::deque<SharedHandle<AnnounceTier> >
+  getAnnounceTiers() const = 0;
 
-  virtual void load(const string& torrentFile) = 0;
+  virtual void load(const std::string& torrentFile) = 0;
 
   /**
    * Returns the peer id of localhost, 20 byte length
@@ -76,10 +72,13 @@ public:
     return _private;
   }
 
-  virtual Integers computeFastSet(const string& ipaddr, int32_t fastSetSize) = 0;
+  virtual std::deque<int32_t>
+  computeFastSet(const std::string& ipaddr, int32_t fastSetSize) = 0;
   
   virtual RequestGroup* getOwnerRequestGroup() = 0;
 
 };
 
+} // namespace aria2
+
 #endif // _D_BT_CONTEXT_H_
diff --git a/src/BtContextAwareCommand.cc b/src/BtContextAwareCommand.cc
index ccc42f0b..8d88138f 100644
--- a/src/BtContextAwareCommand.cc
+++ b/src/BtContextAwareCommand.cc
@@ -34,6 +34,14 @@
 /* copyright --> */
 #include "BtContextAwareCommand.h"
 #include "BtRegistry.h"
+#include "BtContext.h"
+#include "BtRuntime.h"
+#include "PieceStorage.h"
+#include "PeerStorage.h"
+#include "BtAnnounce.h"
+#include "BtProgressInfoFile.h"
+
+namespace aria2 {
 
 BtContextAwareCommand::BtContextAwareCommand(const BtContextHandle& btContext):
   btContext(btContext),
@@ -44,3 +52,5 @@ BtContextAwareCommand::BtContextAwareCommand(const BtContextHandle& btContext):
   btProgressInfoFile(BT_PROGRESS_INFO_FILE(btContext)) {}
 
 BtContextAwareCommand::~BtContextAwareCommand() {}
+
+} // namespace aria2
diff --git a/src/BtContextAwareCommand.h b/src/BtContextAwareCommand.h
index 3baf2ea7..bdef4f0d 100644
--- a/src/BtContextAwareCommand.h
+++ b/src/BtContextAwareCommand.h
@@ -36,26 +36,32 @@
 #define _D_BT_CONTEXT_AWARE_COMMAND_H_
 
 #include "common.h"
-#include "BtContext.h"
-#include "BtRuntime.h"
-#include "PieceStorage.h"
-#include "PeerStorage.h"
-#include "BtAnnounce.h"
-#include "BtProgressInfoFile.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class BtContext;
+class BtRuntime;
+class PieceStorage;
+class PeerStorage;
+class BtAnnounce;
+class BtProgressInfoFile;
 
 class BtContextAwareCommand
 {
 protected:
-  BtContextHandle btContext;
-  BtRuntimeHandle btRuntime;
-  PieceStorageHandle pieceStorage;
-  PeerStorageHandle peerStorage;
-  BtAnnounceHandle btAnnounce;
-  BtProgressInfoFileHandle btProgressInfoFile;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<BtRuntime> btRuntime;
+  SharedHandle<PieceStorage> pieceStorage;
+  SharedHandle<PeerStorage> peerStorage;
+  SharedHandle<BtAnnounce> btAnnounce;
+  SharedHandle<BtProgressInfoFile> btProgressInfoFile;
 public:
-  BtContextAwareCommand(const BtContextHandle& btContext);
+  BtContextAwareCommand(const SharedHandle<BtContext>& btContext);
 
   virtual ~BtContextAwareCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_BT_CONTEXT_AWARE_COMMAND_H_
diff --git a/src/BtContextDecl.h b/src/BtContextDecl.h
index 2cc3b5cf..e33927fe 100644
--- a/src/BtContextDecl.h
+++ b/src/BtContextDecl.h
@@ -37,7 +37,11 @@
 
 #include "SharedHandle.h"
 
+namespace aria2 {
+
 class BtContext;
 typedef SharedHandle<BtContext> BtContextHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_CONTEXT_DECL_H_
diff --git a/src/BtDependency.cc b/src/BtDependency.cc
index 6c0bda48..63728a6e 100644
--- a/src/BtDependency.cc
+++ b/src/BtDependency.cc
@@ -36,6 +36,7 @@
 #include "RequestGroup.h"
 #include "Option.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "DefaultBtContext.h"
 #include "RecoverableException.h"
 #include "message.h"
@@ -43,6 +44,9 @@
 #include "Util.h"
 #include "PieceStorage.h"
 #include "DiskAdaptor.h"
+#include "File.h"
+
+namespace aria2 {
 
 BtDependency::BtDependency(const RequestGroupWeakHandle& dependant,
 			   const RequestGroupHandle& dependee,
@@ -64,7 +68,7 @@ bool BtDependency::resolve()
     try {
       DiskAdaptorHandle diskAdaptor = dependee->getPieceStorage()->getDiskAdaptor();
       diskAdaptor->openExistingFile();
-      string content = Util::toString(diskAdaptor);
+      std::string content = Util::toString(diskAdaptor);
       btContext->loadFromMemory(content.c_str(), content.size(),
 				File(dependee->getFilePath()).getBasename());
       if(_option->defined(PREF_PEER_ID_PREFIX)) {
@@ -93,3 +97,5 @@ bool BtDependency::resolve()
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/BtDependency.h b/src/BtDependency.h
index 4a98ad9c..dcbfad51 100644
--- a/src/BtDependency.h
+++ b/src/BtDependency.h
@@ -37,22 +37,22 @@
 
 #include "Dependency.h"
 
+namespace aria2 {
+
 class RequestGroup;
-typedef WeakHandle<RequestGroup> RequestGroupWeakHandle;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
 class Option;
 class Logger;
 
 class BtDependency : public Dependency
 {
 private:
-  RequestGroupWeakHandle _dependant;
-  RequestGroupHandle _dependee;
+  WeakHandle<RequestGroup> _dependant;
+  SharedHandle<RequestGroup> _dependee;
   const Option* _option;
   const Logger* _logger;
 public:
-  BtDependency(const RequestGroupWeakHandle& dependant,
-	       const RequestGroupHandle& dependee,
+  BtDependency(const WeakHandle<RequestGroup>& dependant,
+	       const SharedHandle<RequestGroup>& dependee,
 	       const Option* option);
 
   virtual ~BtDependency();
@@ -62,4 +62,6 @@ public:
 
 typedef SharedHandle<BtDependency> BtDependencyHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_DEPENDENCY_H_
diff --git a/src/BtEvent.h b/src/BtEvent.h
index fd80729a..c40d175f 100644
--- a/src/BtEvent.h
+++ b/src/BtEvent.h
@@ -36,7 +36,9 @@
 #define _D_BT_EVENT_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 
+namespace aria2 {
 class BtEvent {
 public:
   virtual ~BtEvent() {}
@@ -44,4 +46,6 @@ public:
 
 typedef SharedHandle<BtEvent> BtEventHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_EVENT_H_
diff --git a/src/BtEventListener.h b/src/BtEventListener.h
index 2d99c910..25e60d2b 100644
--- a/src/BtEventListener.h
+++ b/src/BtEventListener.h
@@ -36,16 +36,23 @@
 #define _D_BT_EVENT_LISTENER_H_
 
 #include "common.h"
-#include "BtEvent.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class BtEvent;
 
 class BtEventListener {
 public:
   virtual ~BtEventListener() {}
 
-  virtual void handleEvent(const BtEventHandle& event) = 0;
+  virtual void handleEvent(const SharedHandle<BtEvent>& event) = 0;
 };
 
 typedef SharedHandle<BtEventListener> BtEventListenerHandle;
-typedef deque<BtEventListenerHandle> BtEventListeners;
+typedef std::deque<BtEventListenerHandle> BtEventListeners;
+
+} // namespace aria2
 
 #endif // _D_BT_EVENT_LISTENER_H_
diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc
index 257e45a2..b138d667 100644
--- a/src/BtExtendedMessage.cc
+++ b/src/BtExtendedMessage.cc
@@ -34,11 +34,24 @@
 /* copyright --> */
 #include "BtExtendedMessage.h"
 #include "BtRegistry.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtMessageReceiver.h"
+#include "BtMessageDispatcher.h"
+#include "BtRequestFactory.h"
+#include "PeerConnection.h"
 #include "ExtensionMessage.h"
+#include "ExtensionMessageFactory.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include "BtContext.h"
 #include "DlAbortEx.h"
 #include "message.h"
 #include "Util.h"
+#include <cassert>
+#include <cstring>
+
+namespace aria2 {
 
 BtExtendedMessage::BtExtendedMessage(const ExtensionMessageHandle& extensionMessage):_extensionMessage(extensionMessage), _msg(0), _msgLength(0)
 {}
@@ -57,7 +70,7 @@ const unsigned char* BtExtendedMessage::getMessage() {
      * extpayload --- extpayload, nbytes
      * total: 6+extpayload.length bytes
      */
-    string payload = _extensionMessage->getBencodedData();
+    std::string payload = _extensionMessage->getBencodedData();
     _msgLength = 6+payload.size();
     _msg = new unsigned char[_msgLength];
     PeerMessageUtil::createPeerMessageString(_msg, _msgLength, 2+payload.size(), ID);
@@ -77,7 +90,7 @@ bool BtExtendedMessage::sendPredicate() const
   return peer->isExtendedMessagingEnabled();
 }
 
-string BtExtendedMessage::toString() const {
+std::string BtExtendedMessage::toString() const {
   return "extended "+_extensionMessage->toString();
 }
 
@@ -113,3 +126,5 @@ ExtensionMessageHandle BtExtendedMessage::getExtensionMessage() const
 {
   return _extensionMessage;
 }
+
+} // namespace aria2
diff --git a/src/BtExtendedMessage.h b/src/BtExtendedMessage.h
index df7e49a0..12a16fe4 100644
--- a/src/BtExtendedMessage.h
+++ b/src/BtExtendedMessage.h
@@ -36,28 +36,30 @@
 #define _D_BT_EXTENDED_MESSAGE_H_
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
+class ExtensionMessage;
+
 class BtExtendedMessage;
 typedef SharedHandle<BtExtendedMessage> BtExtendedMessageHandle;
-class ExtensionMessage;
-typedef SharedHandle<ExtensionMessage> ExtensionMessageHandle;
 
 class BtExtendedMessage:public SimpleBtMessage
 {
 private:
-  ExtensionMessageHandle _extensionMessage;
+  SharedHandle<ExtensionMessage> _extensionMessage;
 
   unsigned char* _msg;
 
   size_t _msgLength;
 public:
-  BtExtendedMessage(const ExtensionMessageHandle& extensionMessage = 0);
+  BtExtendedMessage(const SharedHandle<ExtensionMessage>& extensionMessage = 0);
 
   virtual ~BtExtendedMessage();
 
   static const uint8_t ID = 20;
 
-  static BtExtendedMessageHandle create(const BtContextHandle& btContext,
-					const PeerHandle& peer,
+  static BtExtendedMessageHandle create(const SharedHandle<BtContext>& btContext,
+					const SharedHandle<Peer>& peer,
 					const char* data,
 					size_t dataLength);
 
@@ -71,9 +73,11 @@ public:
 
   virtual bool sendPredicate() const;
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
-  ExtensionMessageHandle getExtensionMessage() const;
+  SharedHandle<ExtensionMessage> getExtensionMessage() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_EXTENDED_MESSAGE_H_
diff --git a/src/BtFileAllocationEntry.cc b/src/BtFileAllocationEntry.cc
index 3a5e9b9c..c27ea4c1 100644
--- a/src/BtFileAllocationEntry.cc
+++ b/src/BtFileAllocationEntry.cc
@@ -38,6 +38,8 @@
 #include "Command.h"
 #include "DownloadEngine.h"
 
+namespace aria2 {
+
 BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup):
   FileAllocationEntry(requestGroup, 0) {}
 
@@ -52,3 +54,5 @@ Commands BtFileAllocationEntry::prepareForNextAction(DownloadEngine* e)
   }
   return commands;
 }
+
+} // namespace aria2
diff --git a/src/BtFileAllocationEntry.h b/src/BtFileAllocationEntry.h
index ab80954c..f9acb864 100644
--- a/src/BtFileAllocationEntry.h
+++ b/src/BtFileAllocationEntry.h
@@ -37,10 +37,7 @@
 
 #include "FileAllocationEntry.h"
 
-class RequestGroup;
-class DownloadEngine;
-class Command;
-typedef deque<Command*> Commands;
+namespace aria2 {
 
 class BtFileAllocationEntry : public FileAllocationEntry {
 public:
@@ -48,9 +45,11 @@ public:
 
   virtual ~BtFileAllocationEntry();
 
-  virtual Commands prepareForNextAction(DownloadEngine* e);
+  virtual std::deque<Command*> prepareForNextAction(DownloadEngine* e);
 };
 
 typedef SharedHandle<BtFileAllocationEntry> BtFileAllocationEntryHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/BtHandshakeMessage.cc b/src/BtHandshakeMessage.cc
index c79e2119..279a925b 100644
--- a/src/BtHandshakeMessage.cc
+++ b/src/BtHandshakeMessage.cc
@@ -35,6 +35,10 @@
 #include "BtHandshakeMessage.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
+#include "BtConstants.h"
+#include <cstring>
+
+namespace aria2 {
 
 const unsigned char* BtHandshakeMessage::BT_PSTR = (const unsigned char*)"BitTorrent protocol";
 
@@ -65,8 +69,10 @@ void BtHandshakeMessage::init() {
   this->reserved[5] |= 0x10;
 }
 
-BtHandshakeMessageHandle BtHandshakeMessage::create(const unsigned char* data, int32_t dataLength) {
-  BtHandshakeMessageHandle message = new BtHandshakeMessage();
+SharedHandle<BtHandshakeMessage>
+BtHandshakeMessage::create(const unsigned char* data, int32_t dataLength)
+{
+  SharedHandle<BtHandshakeMessage> message = new BtHandshakeMessage();
   message->pstrlen = data[0];
   memcpy(message->pstr, &data[1], PSTR_LENGTH);
   memcpy(message->reserved, &data[20], RESERVED_LENGTH);
@@ -91,7 +97,7 @@ int32_t BtHandshakeMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtHandshakeMessage::toString() const {
+std::string BtHandshakeMessage::toString() const {
   return "handshake peerId="+
     Util::urlencode(peerId, PEER_ID_LENGTH)+
     ", reserved="+Util::toHex(reserved, RESERVED_LENGTH);
@@ -111,3 +117,14 @@ bool BtHandshakeMessage::isDHTEnabled() const
   return reserved[7]&0x01;
 }
 
+void BtHandshakeMessage::setInfoHash(const unsigned char* infoHash)
+{
+  memcpy(this->infoHash, infoHash, INFO_HASH_LENGTH);
+}
+
+void BtHandshakeMessage::setPeerId(const unsigned char* peerId)
+{
+  memcpy(this->peerId, peerId, PEER_ID_LENGTH);
+}
+
+} // namespace aria2
diff --git a/src/BtHandshakeMessage.h b/src/BtHandshakeMessage.h
index bbf9afa3..f01d9407 100644
--- a/src/BtHandshakeMessage.h
+++ b/src/BtHandshakeMessage.h
@@ -37,9 +37,7 @@
 
 #include "SimpleBtMessage.h"
 
-class BtHandshakeMessage;
-
-typedef SharedHandle<BtHandshakeMessage> BtHandshakeMessageHandle;
+namespace aria2 {
 
 class BtHandshakeMessage : public SimpleBtMessage {
 public:
@@ -63,7 +61,8 @@ public:
    */
   BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId);
 
-  static BtHandshakeMessageHandle create(const unsigned char* data, int32_t dataLength);
+  static SharedHandle<BtHandshakeMessage>
+  create(const unsigned char* data, int32_t dataLength);
 
   virtual ~BtHandshakeMessage() {
     delete [] msg;
@@ -83,7 +82,7 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   bool isFastExtensionSupported() const;
 
@@ -116,17 +115,15 @@ public:
     return infoHash;
   }
 
-  void setInfoHash(const unsigned char* infoHash) {
-    memcpy(this->infoHash, infoHash, INFO_HASH_LENGTH);
-  }
+  void setInfoHash(const unsigned char* infoHash);
 
   const unsigned char* getPeerId() const {
     return peerId;
   }
 
-  void setPeerId(const unsigned char* peerId) {
-    memcpy(this->peerId, peerId, PEER_ID_LENGTH);
-  }
+  void setPeerId(const unsigned char* peerId);
 };
 
+} // namespace aria2
+
 #endif // _D_HANDSHAKE_MESSAGE_H_
diff --git a/src/BtHandshakeMessageValidator.h b/src/BtHandshakeMessageValidator.h
index e06d224b..2bdcef67 100644
--- a/src/BtHandshakeMessageValidator.h
+++ b/src/BtHandshakeMessageValidator.h
@@ -38,6 +38,10 @@
 #include "BtMessageValidator.h"
 #include "BtHandshakeMessage.h"
 #include "Util.h"
+#include "PeerMessageUtil.h"
+#include <cstring>
+
+namespace aria2 {
 
 class BtHandshakeMessageValidator : public BtMessageValidator {
 private:
@@ -72,4 +76,6 @@ public:
 
 typedef SharedHandle<BtHandshakeMessageValidator> BtHandshakeMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_HANDSHAKE_MESSAGE_VALIDATOR_H_
diff --git a/src/BtHaveAllMessage.cc b/src/BtHaveAllMessage.cc
index d1706c2d..6933286b 100644
--- a/src/BtHaveAllMessage.cc
+++ b/src/BtHaveAllMessage.cc
@@ -36,6 +36,9 @@
 #include "DlAbortEx.h"
 #include "PeerMessageUtil.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtHaveAllMessageHandle BtHaveAllMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -76,6 +79,8 @@ int32_t BtHaveAllMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtHaveAllMessage::toString() const {
+std::string BtHaveAllMessage::toString() const {
   return "have all";
 }
+
+} // namespace aria2
diff --git a/src/BtHaveAllMessage.h b/src/BtHaveAllMessage.h
index 6fe804da..cfdcd9b7 100644
--- a/src/BtHaveAllMessage.h
+++ b/src/BtHaveAllMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtHaveAllMessage;
 
 typedef SharedHandle<BtHaveAllMessage> BtHaveAllMessageHandle;
@@ -65,7 +67,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_HAVE_ALL_MESSAGE_H_
diff --git a/src/BtHaveMessage.cc b/src/BtHaveMessage.cc
index fb6fef00..aeb9aab8 100644
--- a/src/BtHaveMessage.cc
+++ b/src/BtHaveMessage.cc
@@ -37,6 +37,9 @@
 #include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtHaveMessageHandle BtHaveMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 5) {
@@ -76,6 +79,8 @@ int32_t BtHaveMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtHaveMessage::toString() const {
+std::string BtHaveMessage::toString() const {
   return "have index="+Util::itos(index);
 }
+
+} // namespace aria2
diff --git a/src/BtHaveMessage.h b/src/BtHaveMessage.h
index e2bc337a..493873d2 100644
--- a/src/BtHaveMessage.h
+++ b/src/BtHaveMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtHaveMessage;
 
 typedef SharedHandle<BtHaveMessage> BtHaveMessageHandle;
@@ -71,7 +73,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_HAVE_MESSAGE_H_
diff --git a/src/BtHaveMessageValidator.h b/src/BtHaveMessageValidator.h
index 0f7017cf..9eaf3a1f 100644
--- a/src/BtHaveMessageValidator.h
+++ b/src/BtHaveMessageValidator.h
@@ -39,6 +39,8 @@
 #include "BtHaveMessage.h"
 #include "PeerMessageUtil.h"
 
+namespace aria2 {
+
 class BtHaveMessageValidator : public BtMessageValidator {
 private:
   const BtHaveMessage* message;
@@ -57,4 +59,6 @@ public:
 
 };
 
+} // namespace aria2
+
 #endif // _D_BT_HAVE_MESSAGE_VALIDATOR_H_
diff --git a/src/BtHaveNoneMessage.cc b/src/BtHaveNoneMessage.cc
index 7f09ba15..ace41fd7 100644
--- a/src/BtHaveNoneMessage.cc
+++ b/src/BtHaveNoneMessage.cc
@@ -36,6 +36,9 @@
 #include "DlAbortEx.h"
 #include "PeerMessageUtil.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtHaveNoneMessageHandle BtHaveNoneMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -75,6 +78,8 @@ int32_t BtHaveNoneMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtHaveNoneMessage::toString() const {
+std::string BtHaveNoneMessage::toString() const {
   return "have none";
 }
+
+} // namespace aria2
diff --git a/src/BtHaveNoneMessage.h b/src/BtHaveNoneMessage.h
index 29752362..b9f4cf34 100644
--- a/src/BtHaveNoneMessage.h
+++ b/src/BtHaveNoneMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtHaveNoneMessage;
 
 typedef SharedHandle<BtHaveNoneMessage> BtHaveNoneMessageHandle;
@@ -65,7 +67,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_HAVE_NONE_MESSAGE_H_
diff --git a/src/BtInteractive.h b/src/BtInteractive.h
index cdf6bd9d..abffb98e 100644
--- a/src/BtInteractive.h
+++ b/src/BtInteractive.h
@@ -36,7 +36,11 @@
 #define _D_BT_INTERACTIVE_H_
 
 #include "common.h"
-#include "BtMessage.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class BtMessage;
 
 class BtInteractive {
 public:
@@ -44,9 +48,9 @@ public:
 
   virtual void initiateHandshake() = 0;
 
-  virtual BtMessageHandle receiveHandshake(bool quickReply = false) = 0;
+  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false) = 0;
 
-  virtual BtMessageHandle receiveAndSendHandshake() = 0;
+  virtual SharedHandle<BtMessage> receiveAndSendHandshake() = 0;
 
   virtual void doPostHandshakeProcessing() = 0;
 
@@ -63,4 +67,6 @@ public:
 
 typedef SharedHandle<BtInteractive> BtInteractiveHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_INTERACTIVE_H_
diff --git a/src/BtInterestedMessage.cc b/src/BtInterestedMessage.cc
index 5ae06bb0..0acdd354 100644
--- a/src/BtInterestedMessage.cc
+++ b/src/BtInterestedMessage.cc
@@ -36,6 +36,9 @@
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtInterestedMessageHandle BtInterestedMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -80,6 +83,8 @@ void BtInterestedMessage::onSendComplete() {
   peer->amInterested = true;
 }
 
-string BtInterestedMessage::toString() const {
+std::string BtInterestedMessage::toString() const {
   return "interested";
 }
+
+} // namespace aria2
diff --git a/src/BtInterestedMessage.h b/src/BtInterestedMessage.h
index 0aea3efc..b3a93dac 100644
--- a/src/BtInterestedMessage.h
+++ b/src/BtInterestedMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtInterestedMessage;
 
 typedef SharedHandle<BtInterestedMessage> BtInterestedMessageHandle;
@@ -65,11 +67,13 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual bool sendPredicate() const;
 
   virtual void onSendComplete();
 };
 
+} // namespace aria2
+
 #endif // _D_BT_INTERESTED_MESSAGE_H_
diff --git a/src/BtKeepAliveMessage.cc b/src/BtKeepAliveMessage.cc
index 24a084a3..f7cb1908 100644
--- a/src/BtKeepAliveMessage.cc
+++ b/src/BtKeepAliveMessage.cc
@@ -34,6 +34,8 @@
 /* copyright --> */
 #include "BtKeepAliveMessage.h"
 
+namespace aria2 {
+
 int32_t BtKeepAliveMessage::MESSAGE_LENGTH = 4;
 
 const unsigned char* BtKeepAliveMessage::getMessage() {
@@ -51,3 +53,5 @@ const unsigned char* BtKeepAliveMessage::getMessage() {
 int32_t BtKeepAliveMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
+
+} // namespace aria2
diff --git a/src/BtKeepAliveMessage.h b/src/BtKeepAliveMessage.h
index f9f4a065..86948bb0 100644
--- a/src/BtKeepAliveMessage.h
+++ b/src/BtKeepAliveMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtKeepAliveMessage;
 
 typedef SharedHandle<BtKeepAliveMessage> BtKeepAliveMessageHandle;
@@ -63,9 +65,11 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const {
+  virtual std::string toString() const {
     return "keep alive";
   }
 };
 
+} // namespace aria2
+
 #endif // _D_BT_KEEP_ALIVE_MESSAGE_H_
diff --git a/src/BtMessage.h b/src/BtMessage.h
index 6134b2ae..7802b2cf 100644
--- a/src/BtMessage.h
+++ b/src/BtMessage.h
@@ -36,9 +36,13 @@
 #define _D_BT_MESSAGE_H_
 
 #include "common.h"
-#include "Piece.h"
-#include "BtMessageValidator.h"
-#include "BtEvent.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class BtEvent;
 
 class BtMessage {
 public:
@@ -56,17 +60,19 @@ public:
 
   virtual void send() = 0;
 
-  virtual bool validate(Errors& errors) = 0;
+  virtual bool validate(std::deque<std::string>& errors) = 0;
 
-  virtual void handleEvent(const BtEventHandle& event) = 0;
+  virtual void handleEvent(const SharedHandle<BtEvent>& event) = 0;
 
   virtual void onQueued() = 0;
 
-  virtual string toString() const = 0;
+  virtual std::string toString() const = 0;
 
 };
 
 typedef SharedHandle<BtMessage> BtMessageHandle;
-typedef deque<BtMessageHandle> BtMessages;
+typedef std::deque<BtMessageHandle> BtMessages;
+
+} // namespace aria2
 
 #endif // _D_BT_MESSAGE_H_
diff --git a/src/BtMessageDispatcher.h b/src/BtMessageDispatcher.h
index 5674cef1..8460aedc 100644
--- a/src/BtMessageDispatcher.h
+++ b/src/BtMessageDispatcher.h
@@ -36,25 +36,31 @@
 #define _D_BT_MESSAGE_DISPATCHER_H_
 
 #include "common.h"
-#include "Piece.h"
-#include "BtMessage.h"
+#include "SharedHandle.h"
 #include "RequestSlot.h"
+#include <deque>
+
+namespace aria2 {
+
+class Piece;
+class BtMessage;
 
 class BtMessageDispatcher {
 public:
   virtual ~BtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const BtMessageHandle& btMessage) = 0;
+  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) = 0;
 
-  virtual void addMessageToQueue(const BtMessages& btMessages) = 0;
+  virtual void
+  addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) = 0;
 
   virtual void sendMessages() = 0;
 
   virtual void doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length) = 0;
 
-  virtual void doCancelSendingPieceAction(const PieceHandle& piece) = 0;
+  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) = 0;
 
-  virtual void doAbortOutstandingRequestAction(const PieceHandle& piece) = 0;
+  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece) = 0;
 
   virtual void doChokedAction() = 0;
 
@@ -79,4 +85,7 @@ public:
 
 typedef SharedHandle<BtMessageDispatcher> BtMessageDispatcherHandle;
 typedef WeakHandle<BtMessageDispatcher> BtMessageDispatcherWeakHandle;
+
+} // namespace aria2
+
 #endif // _D_BT_MESSAGE_DISPATCHER_H_
diff --git a/src/BtMessageFactory.h b/src/BtMessageFactory.h
index 24fac205..6c1ab678 100644
--- a/src/BtMessageFactory.h
+++ b/src/BtMessageFactory.h
@@ -36,63 +36,69 @@
 #define _D_BT_MESSAGE_FACTORY_H_
 
 #include "common.h"
-#include "BtMessage.h"
-#include "Piece.h"
+#include "SharedHandle.h"
 
+namespace aria2 {
+
+class BtMessage;
+class Piece;
 class ExtensionMessage;
-typedef SharedHandle<ExtensionMessage> ExensionMessageHandle;
 
 class BtMessageFactory {
 public:
   virtual ~BtMessageFactory() {}
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createBtMessage(const unsigned char* msg, int32_t msgLength) = 0;
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* msg, int32_t msgLength) = 0;
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* infoHash,
 			 const unsigned char* peerId) = 0;
 
-  virtual BtMessageHandle
-  createRequestMessage(const PieceHandle& piece, int32_t blockIndex) = 0;
+  virtual SharedHandle<BtMessage>
+  createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex) = 0;
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createCancelMessage(int32_t index, int32_t begin, int32_t length) = 0;
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createPieceMessage(int32_t index, int32_t begin, int32_t length) = 0;
 
-  virtual BtMessageHandle createHaveMessage(int32_t index) = 0;
+  virtual SharedHandle<BtMessage> createHaveMessage(int32_t index) = 0;
 
-  virtual BtMessageHandle createChokeMessage() = 0;
+  virtual SharedHandle<BtMessage> createChokeMessage() = 0;
 
-  virtual BtMessageHandle createUnchokeMessage() = 0;
+  virtual SharedHandle<BtMessage> createUnchokeMessage() = 0;
   
-  virtual BtMessageHandle createInterestedMessage() = 0;
+  virtual SharedHandle<BtMessage> createInterestedMessage() = 0;
 
-  virtual BtMessageHandle createNotInterestedMessage() = 0;
+  virtual SharedHandle<BtMessage> createNotInterestedMessage() = 0;
 
-  virtual BtMessageHandle createBitfieldMessage() = 0;
+  virtual SharedHandle<BtMessage> createBitfieldMessage() = 0;
 
-  virtual BtMessageHandle createKeepAliveMessage() = 0;
+  virtual SharedHandle<BtMessage> createKeepAliveMessage() = 0;
   
-  virtual BtMessageHandle createHaveAllMessage() = 0;
+  virtual SharedHandle<BtMessage> createHaveAllMessage() = 0;
 
-  virtual BtMessageHandle createHaveNoneMessage() = 0;
+  virtual SharedHandle<BtMessage> createHaveNoneMessage() = 0;
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createRejectMessage(int32_t index, int32_t begin, int32_t length) = 0;
 
-  virtual BtMessageHandle createAllowedFastMessage(int32_t index) = 0;
+  virtual SharedHandle<BtMessage> createAllowedFastMessage(int32_t index) = 0;
 
-  virtual BtMessageHandle createPortMessage(uint16_t port) = 0;
+  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port) = 0;
 
-  virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle& msg) = 0;
+  virtual SharedHandle<BtMessage>
+  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& msg) = 0;
 };
 
 typedef SharedHandle<BtMessageFactory> BtMessageFactoryHandle;
 typedef WeakHandle<BtMessageFactory> BtMessageFactoryWeakHandle;
+
+} // namespace aria2
+
 #endif // _D_BT_MESSAGE_FACTORY_H_
diff --git a/src/BtMessageReceiver.h b/src/BtMessageReceiver.h
index 15315e75..f4c6d6ca 100644
--- a/src/BtMessageReceiver.h
+++ b/src/BtMessageReceiver.h
@@ -36,20 +36,26 @@
 #define _D_BT_MESSAGE_RECEIVER_H_
 
 #include "common.h"
-#include "BtMessage.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class BtMessage;
 
 class BtMessageReceiver {
 public:
   virtual ~BtMessageReceiver() {}
 
-  virtual BtMessageHandle receiveHandshake(bool quickReply = false) = 0;
+  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false) = 0;
 
-  virtual BtMessageHandle receiveAndSendHandshake() = 0;
+  virtual SharedHandle<BtMessage> receiveAndSendHandshake() = 0;
 
-  virtual BtMessageHandle receiveMessage() = 0;
+  virtual SharedHandle<BtMessage> receiveMessage() = 0;
 };
 
 typedef SharedHandle<BtMessageReceiver> BtMessageReceiverHandle;
 typedef WeakHandle<BtMessageReceiver> BtMessageReceiverWeakHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_MESSAGE_RECEIVER_H_
diff --git a/src/BtMessageValidator.h b/src/BtMessageValidator.h
index 5298fde4..79e8cd7b 100644
--- a/src/BtMessageValidator.h
+++ b/src/BtMessageValidator.h
@@ -36,9 +36,13 @@
 #define _D_BT_MESSAGE_VALIDATOR_H_
 
 #include "common.h"
-#include "BtMessage.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
 
-typedef Strings Errors;
+namespace aria2 {
+
+typedef std::deque<std::string> Errors;
 
 class BtMessageValidator {
 public:
@@ -49,4 +53,6 @@ public:
 
 typedef SharedHandle<BtMessageValidator> BtMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_MESSAGE_VALIDATOR_H_
diff --git a/src/BtNotInterestedMessage.cc b/src/BtNotInterestedMessage.cc
index d6521224..79436a2f 100644
--- a/src/BtNotInterestedMessage.cc
+++ b/src/BtNotInterestedMessage.cc
@@ -36,6 +36,9 @@
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtNotInterestedMessageHandle BtNotInterestedMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -80,6 +83,8 @@ void BtNotInterestedMessage::onSendComplete() {
   peer->amInterested = false;
 }
 
-string BtNotInterestedMessage::toString() const {
+std::string BtNotInterestedMessage::toString() const {
   return "not interested";
 }
+
+} // namespace aria2
diff --git a/src/BtNotInterestedMessage.h b/src/BtNotInterestedMessage.h
index 0106c160..f39fcdec 100644
--- a/src/BtNotInterestedMessage.h
+++ b/src/BtNotInterestedMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtNotInterestedMessage;
 
 typedef SharedHandle<BtNotInterestedMessage> BtNotInterestedMessageHandle;
@@ -65,11 +67,13 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual bool sendPredicate() const;
 
   virtual void onSendComplete();
 };
 
+} // namespace aria2
+
 #endif // _D_BT_NOT_INTERESTED_MESSAGE_H_
diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc
index a8def5ce..4c899145 100644
--- a/src/BtPieceMessage.cc
+++ b/src/BtPieceMessage.cc
@@ -41,6 +41,18 @@
 #include "BtCancelSendingPieceEvent.h"
 #include "MessageDigestHelper.h"
 #include "DiskAdaptor.h"
+#include "Logger.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "PeerConnection.h"
+#include <cstring>
+
+namespace aria2 {
 
 void BtPieceMessage::setBlock(const unsigned char* block, int32_t blockLength) {
   delete [] this->block;
@@ -184,7 +196,7 @@ int32_t BtPieceMessage::sendPieceData(int64_t offset, int32_t length) const {
   return writtenLength;
 }
 
-string BtPieceMessage::toString() const {
+std::string BtPieceMessage::toString() const {
   return "piece index="+Util::itos(index)+", begin="+Util::itos(begin)+
     ", length="+Util::itos(blockLength);
 }
@@ -282,3 +294,5 @@ void BtPieceMessage::handleCancelSendingPieceEvent(const BtEventHandle& event) {
     invalidate = true;
   } 
 }
+
+} // namespace aria2
diff --git a/src/BtPieceMessage.h b/src/BtPieceMessage.h
index 5f038e2f..f6c08864 100644
--- a/src/BtPieceMessage.h
+++ b/src/BtPieceMessage.h
@@ -36,11 +36,12 @@
 #define _D_BT_PIECE_MESSAGE_H_
 
 #include "AbstractBtMessage.h"
-#include "BtContext.h"
-#include "PieceStorage.h"
-#include "BtEvent.h"
 #include "AbstractBtEventListener.h"
 
+namespace aria2 {
+
+class BtEvent;
+class Piece;
 class BtPieceMessage;
 
 typedef SharedHandle<BtPieceMessage> BtPieceMessageHandle;
@@ -57,13 +58,13 @@ private:
 
   static int32_t MESSAGE_HEADER_LENGTH;
 
-  bool checkPieceHash(const PieceHandle& piece);
+  bool checkPieceHash(const SharedHandle<Piece>& piece);
 
-  void onNewPiece(const PieceHandle& piece);
+  void onNewPiece(const SharedHandle<Piece>& piece);
 
-  void onWrongPiece(const PieceHandle& piece);
+  void onWrongPiece(const SharedHandle<Piece>& piece);
 
-  void erasePieceOnDisk(const PieceHandle& piece);
+  void erasePieceOnDisk(const SharedHandle<Piece>& piece);
 
   int32_t sendPieceData(int64_t offset, int32_t length) const;
 
@@ -73,9 +74,9 @@ private:
   public:
     BtChokingEventListener(BtPieceMessage* message):message(message) {}
 
-    virtual bool canHandle(const BtEventHandle& btEvent);
+    virtual bool canHandle(const SharedHandle<BtEvent>& btEvent);
 
-    virtual void handleEventInternal(const BtEventHandle& btEvent);
+    virtual void handleEventInternal(const SharedHandle<BtEvent>& btEvent);
   };
 
   typedef SharedHandle<BtChokingEventListener> BtChokingEventListenerHandle;
@@ -86,9 +87,9 @@ private:
   public:
     BtCancelSendingPieceEventListener(BtPieceMessage* message):message(message) {}
 
-    virtual bool canHandle(const BtEventHandle& btEvent);
+    virtual bool canHandle(const SharedHandle<BtEvent>& btEvent);
 
-    virtual void handleEventInternal(const BtEventHandle& btEvent);
+    virtual void handleEventInternal(const SharedHandle<BtEvent>& btEvent);
   };
 
   typedef SharedHandle<BtCancelSendingPieceEventListener> BtCancelSendingPieceEventListenerHandle;
@@ -142,11 +143,13 @@ public:
 
   virtual void send();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
-  void handleChokingEvent(const BtEventHandle& event);
+  void handleChokingEvent(const SharedHandle<BtEvent>& event);
   
-  void handleCancelSendingPieceEvent(const BtEventHandle& event);
+  void handleCancelSendingPieceEvent(const SharedHandle<BtEvent>& event);
 };
 
+} // namespace aria2
+
 #endif // _D_BT_PIECE_MESSAGE_H_
diff --git a/src/BtPieceMessageValidator.h b/src/BtPieceMessageValidator.h
index 6ecd554c..91765a7d 100644
--- a/src/BtPieceMessageValidator.h
+++ b/src/BtPieceMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtPieceMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtPieceMessageValidator : public BtMessageValidator {
 private:
@@ -61,4 +64,6 @@ public:
 
 typedef SharedHandle<BtPieceMessageValidator> BtPieceMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_PIECE_MESSAGE_VALIDATOR_H_
diff --git a/src/BtPortMessage.cc b/src/BtPortMessage.cc
index d81e7101..a094deae 100644
--- a/src/BtPortMessage.cc
+++ b/src/BtPortMessage.cc
@@ -37,11 +37,15 @@
 #include "DlAbortEx.h"
 #include "Util.h"
 #include "message.h"
+#include "Logger.h"
+#include "Peer.h"
 #include "DHTNode.h"
 #include "DHTTaskQueue.h"
 #include "DHTTaskFactory.h"
 #include "DHTTask.h"
 
+namespace aria2 {
+
 BtPortMessage::BtPortMessage(uint16_t port): _port(port), _msg(0) {}
 
 BtPortMessage::~BtPortMessage()
@@ -68,10 +72,10 @@ void BtPortMessage::doReceivedAction()
   if(!_taskFactory.isNull() && !_taskQueue.isNull()) {
     // node id is random at this point. When ping reply received, new DHTNode
     // instance created with proper node ID and is added to a routing table.
-    DHTNodeHandle node = new DHTNode();
+    SharedHandle<DHTNode> node = new DHTNode();
     node->setIPAddress(peer->ipaddr);
     node->setPort(_port);
-    DHTTaskHandle task = _taskFactory->createPingTask(node);
+    SharedHandle<DHTTask> task = _taskFactory->createPingTask(node);
     _taskQueue->addImmediateTask(task);
   } else {
     logger->info("DHT port message received while localhost didn't declare support it.");
@@ -97,7 +101,7 @@ int32_t BtPortMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtPortMessage::toString() const {
+std::string BtPortMessage::toString() const {
   return "port port="+Util::uitos(_port);
 }
 
@@ -110,3 +114,5 @@ void BtPortMessage::setTaskFactory(const WeakHandle<DHTTaskFactory>& taskFactory
 {
   _taskFactory = taskFactory;
 }
+
+} // namespace aria2
diff --git a/src/BtPortMessage.h b/src/BtPortMessage.h
index d500a446..1c8c075d 100644
--- a/src/BtPortMessage.h
+++ b/src/BtPortMessage.h
@@ -36,8 +36,11 @@
 #define _D_BT_PORT_MESSAGE_H_
 
 #include "SimpleBtMessage.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
+
+namespace aria2 {
+
+class DHTTaskQueue;
+class DHTTaskFactory;
 
 class BtPortMessage : public SimpleBtMessage {
 private:
@@ -67,11 +70,13 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   void setTaskQueue(const WeakHandle<DHTTaskQueue>& taskQueue);
 
   void setTaskFactory(const WeakHandle<DHTTaskFactory>& taskFactory);
 };
 
+} // namespace aria2
+
 #endif // _D_BT_PORT_MESSAGE_H_
diff --git a/src/BtPostDownloadHandler.cc b/src/BtPostDownloadHandler.cc
index 5aae5311..22e77dd3 100644
--- a/src/BtPostDownloadHandler.cc
+++ b/src/BtPostDownloadHandler.cc
@@ -44,6 +44,9 @@
 #include "DiskAdaptor.h"
 #include "Util.h"
 #include "ContentTypeRequestGroupCriteria.h"
+#include "Exception.h"
+
+namespace aria2 {
 
 BtPostDownloadHandler::BtPostDownloadHandler()
 {
@@ -58,9 +61,9 @@ RequestGroups BtPostDownloadHandler::getNextRequestGroups(RequestGroup* requestG
   const Option* op = requestGroup->getOption();
   _logger->debug("Generating RequestGroups for Torrent file %s",
 		 requestGroup->getFilePath().c_str());
-  RequestGroupHandle rg = new RequestGroup(op, Strings());
+  RequestGroupHandle rg = new RequestGroup(op, std::deque<std::string>());
 
-  string content;
+  std::string content;
   try {
     requestGroup->getPieceStorage()->getDiskAdaptor()->openExistingFile();
     content = Util::toString(requestGroup->getPieceStorage()->getDiskAdaptor());
@@ -83,3 +86,5 @@ RequestGroups BtPostDownloadHandler::getNextRequestGroups(RequestGroup* requestG
   groups.push_back(rg);
   return groups;
 }
+
+} // namespace aria2
diff --git a/src/BtPostDownloadHandler.h b/src/BtPostDownloadHandler.h
index 8dab5887..4d10f035 100644
--- a/src/BtPostDownloadHandler.h
+++ b/src/BtPostDownloadHandler.h
@@ -37,6 +37,8 @@
 
 #include "PostDownloadHandler.h"
 
+namespace aria2 {
+
 class BtPostDownloadHandler:public PostDownloadHandler
 {
 public:
@@ -44,8 +46,12 @@ public:
 
   virtual ~BtPostDownloadHandler();
 
-  virtual RequestGroups getNextRequestGroups(RequestGroup* requestGroup);
+  virtual std::deque<SharedHandle<RequestGroup> >
+  getNextRequestGroups(RequestGroup* requestGroup);
 };
 
 typedef SharedHandle<BtPostDownloadHandler> BtPostDownloadHandlerHandle;
+
+} // namespace aria2
+
 #endif // _D_BT_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/BtProgressInfoFile.h b/src/BtProgressInfoFile.h
index 968e5525..9ffc0b6e 100644
--- a/src/BtProgressInfoFile.h
+++ b/src/BtProgressInfoFile.h
@@ -36,12 +36,16 @@
 #define _D_BT_PROGRESS_INFO_FILE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
 
 class BtProgressInfoFile {
 public:
   virtual ~BtProgressInfoFile() {}
 
-  virtual string getFilename() = 0;
+  virtual std::string getFilename() = 0;
 
   virtual bool exists() = 0;
 
@@ -54,4 +58,6 @@ public:
 
 typedef SharedHandle<BtProgressInfoFile> BtProgressInfoFileHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_PROGRESS_INFO_FILE_H_
diff --git a/src/BtRegistry.cc b/src/BtRegistry.cc
index 3358da13..86e9c3b2 100644
--- a/src/BtRegistry.cc
+++ b/src/BtRegistry.cc
@@ -34,6 +34,21 @@
 /* copyright --> */
 #include "BtRegistry.h"
 #include "DlAbortEx.h"
+#include "BtContext.h"
+#include "PeerStorage.h"
+#include "PieceStorage.h"
+#include "BtAnnounce.h"
+#include "BtRuntime.h"
+#include "BtProgressInfoFile.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+
+namespace aria2 {
 
 BtContextMap BtRegistry::btContextMap;
 PeerStorageMap BtRegistry::peerStorageMap;
@@ -43,94 +58,94 @@ BtRuntimeMap BtRegistry::btRuntimeMap;
 BtProgressInfoFileMap BtRegistry::btProgressInfoFileMap;
 PeerObjectClusterRegistry BtRegistry::peerObjectClusterRegistry;
 
-PeerStorageHandle BtRegistry::getPeerStorage(const string& key)
+PeerStorageHandle BtRegistry::getPeerStorage(const std::string& key)
 {
   return peerStorageMap.getHandle(key);
 }
 
-void BtRegistry::registerPeerStorage(const string& key,
+void BtRegistry::registerPeerStorage(const std::string& key,
 				     const PeerStorageHandle& peerStorage)
 {
   peerStorageMap.registerHandle(key, peerStorage);
 }
 				  
 PieceStorageHandle
-BtRegistry::getPieceStorage(const string& key)
+BtRegistry::getPieceStorage(const std::string& key)
 {
   return pieceStorageMap.getHandle(key);
 }
 
 void
-BtRegistry::registerPieceStorage(const string& key,
+BtRegistry::registerPieceStorage(const std::string& key,
 				 const PieceStorageHandle& pieceStorage)
 {
   pieceStorageMap.registerHandle(key, pieceStorage);
 }
 
-BtRuntimeHandle BtRegistry::getBtRuntime(const string& key)
+BtRuntimeHandle BtRegistry::getBtRuntime(const std::string& key)
 {
   return btRuntimeMap.getHandle(key);
 }
 
 void
-BtRegistry::registerBtRuntime(const string& key,
+BtRegistry::registerBtRuntime(const std::string& key,
 			      const BtRuntimeHandle& btRuntime)
 {
   btRuntimeMap.registerHandle(key, btRuntime);
 }
 
-BtAnnounceHandle BtRegistry::getBtAnnounce(const string& key)
+BtAnnounceHandle BtRegistry::getBtAnnounce(const std::string& key)
 {
   return btAnnounceMap.getHandle(key);
 }
 
 void
-BtRegistry::registerBtAnnounce(const string& key,
+BtRegistry::registerBtAnnounce(const std::string& key,
 			       const BtAnnounceHandle& btAnnounce)
 {
   btAnnounceMap.registerHandle(key, btAnnounce);
 }
 
-BtProgressInfoFileHandle BtRegistry::getBtProgressInfoFile(const string& key)
+BtProgressInfoFileHandle BtRegistry::getBtProgressInfoFile(const std::string& key)
 {
   return btProgressInfoFileMap.getHandle(key);
 }
 
 void
-BtRegistry::registerBtProgressInfoFile(const string& key,
+BtRegistry::registerBtProgressInfoFile(const std::string& key,
 				       const BtProgressInfoFileHandle& btProgressInfoFile)
 {
   btProgressInfoFileMap.registerHandle(key, btProgressInfoFile);
 }
 
 BtContextHandle
-BtRegistry::getBtContext(const string& key)
+BtRegistry::getBtContext(const std::string& key)
 {
   return btContextMap.getHandle(key);
 }
 
 void
-BtRegistry::registerBtContext(const string& key,
+BtRegistry::registerBtContext(const std::string& key,
 			      const BtContextHandle& btContext)
 {
   btContextMap.registerHandle(key, btContext);
 }
 
 PeerObjectClusterHandle
-BtRegistry::getPeerObjectCluster(const string& key)
+BtRegistry::getPeerObjectCluster(const std::string& key)
 {
   return peerObjectClusterRegistry.getHandle(key);
 }
 
 void
-BtRegistry::registerPeerObjectCluster(const string& key,
+BtRegistry::registerPeerObjectCluster(const std::string& key,
 				      const PeerObjectClusterHandle& cluster)
 {
   peerObjectClusterRegistry.registerHandle(key, cluster);
 }
 
 void
-BtRegistry::unregisterPeerObjectCluster(const string& key)
+BtRegistry::unregisterPeerObjectCluster(const std::string& key)
 {
   peerObjectClusterRegistry.unregisterHandle(key);
 }
@@ -145,7 +160,7 @@ void BtRegistry::unregisterAll() {
   peerObjectClusterRegistry.clear();
 }
 
-void BtRegistry::unregister(const string& key)
+void BtRegistry::unregister(const std::string& key)
 {
   btContextMap.unregisterHandle(key);
   peerStorageMap.unregisterHandle(key);
@@ -155,3 +170,5 @@ void BtRegistry::unregister(const string& key)
   btProgressInfoFileMap.unregisterHandle(key);
   peerObjectClusterRegistry.unregisterHandle(key);
 }
+
+} // namespace aria2
diff --git a/src/BtRegistry.h b/src/BtRegistry.h
index 895001f1..10770150 100644
--- a/src/BtRegistry.h
+++ b/src/BtRegistry.h
@@ -36,27 +36,32 @@
 #define _D_BT_REGISTRY_H_
 
 #include "common.h"
-#include "BtContext.h"
-#include "PeerStorage.h"
-#include "PieceStorage.h"
-#include "BtAnnounce.h"
-#include "BtRuntime.h"
-#include "BtProgressInfoFile.h"
-#include "PeerObject.h"
+#include "SharedHandle.h"
 #include "HandleRegistry.h"
+#include <string>
 #include <map>
 
-typedef HandleRegistry<string, PeerStorage> PeerStorageMap;
-typedef HandleRegistry<string, PieceStorage> PieceStorageMap;
-typedef HandleRegistry<string, BtAnnounce> BtAnnounceMap;
-typedef HandleRegistry<string, BtRuntime> BtRuntimeMap;
-typedef HandleRegistry<string, BtProgressInfoFile> BtProgressInfoFileMap;
-typedef HandleRegistry<string, BtContext>  BtContextMap;
+namespace aria2 {
+
+class PeerStorage;
+class PieceStorage;
+class BtAnnounce;
+class BtRuntime;
+class BtProgressInfoFile;
+class BtContext;
+class PeerObject;
+
+typedef HandleRegistry<std::string, PeerStorage> PeerStorageMap;
+typedef HandleRegistry<std::string, PieceStorage> PieceStorageMap;
+typedef HandleRegistry<std::string, BtAnnounce> BtAnnounceMap;
+typedef HandleRegistry<std::string, BtRuntime> BtRuntimeMap;
+typedef HandleRegistry<std::string, BtProgressInfoFile> BtProgressInfoFileMap;
+typedef HandleRegistry<std::string, BtContext>  BtContextMap;
 
 // for BtMessageFactory
-typedef HandleRegistry<string, PeerObject> PeerObjectCluster;
+typedef HandleRegistry<std::string, PeerObject> PeerObjectCluster;
 typedef SharedHandle<PeerObjectCluster> PeerObjectClusterHandle;
-typedef HandleRegistry<string, PeerObjectCluster> PeerObjectClusterRegistry;
+typedef HandleRegistry<std::string, PeerObjectCluster> PeerObjectClusterRegistry;
 
 class BtRegistry {
 private:
@@ -70,44 +75,44 @@ private:
   static BtProgressInfoFileMap btProgressInfoFileMap;
   static PeerObjectClusterRegistry peerObjectClusterRegistry;
 public:
-  static BtContextHandle getBtContext(const string& key);
-  static void registerBtContext(const string& key,
-				const BtContextHandle& btContext);
+  static SharedHandle<BtContext> getBtContext(const std::string& key);
+  static void registerBtContext(const std::string& key,
+				const SharedHandle<BtContext>& btContext);
 
-  static PeerStorageHandle getPeerStorage(const string& key);
-  static void registerPeerStorage(const string& key,
-				  const PeerStorageHandle& peer);
+  static SharedHandle<PeerStorage> getPeerStorage(const std::string& key);
+  static void registerPeerStorage(const std::string& key,
+				  const SharedHandle<PeerStorage>& peer);
 				  
-  static PieceStorageHandle getPieceStorage(const string& key);
-  static void registerPieceStorage(const string& key,
-				   const PieceStorageHandle& pieceStorage);
+  static SharedHandle<PieceStorage> getPieceStorage(const std::string& key);
+  static void registerPieceStorage(const std::string& key,
+				   const SharedHandle<PieceStorage>& pieceStorage);
 
-  static BtRuntimeHandle getBtRuntime(const string& key);
-  static void registerBtRuntime(const string& key,
-				const BtRuntimeHandle& btRuntime);
+  static SharedHandle<BtRuntime> getBtRuntime(const std::string& key);
+  static void registerBtRuntime(const std::string& key,
+				const SharedHandle<BtRuntime>& btRuntime);
 
-  static BtAnnounceHandle getBtAnnounce(const string& key);
-  static void registerBtAnnounce(const string& key,
-				 const BtAnnounceHandle& btAnnounce);
+  static SharedHandle<BtAnnounce> getBtAnnounce(const std::string& key);
+  static void registerBtAnnounce(const std::string& key,
+				 const SharedHandle<BtAnnounce>& btAnnounce);
 
-  static BtProgressInfoFileHandle getBtProgressInfoFile(const string& key);
-  static void registerBtProgressInfoFile(const string& key,
-					 const BtProgressInfoFileHandle& btProgressInfoFile);
+  static SharedHandle<BtProgressInfoFile> getBtProgressInfoFile(const std::string& key);
+  static void registerBtProgressInfoFile(const std::string& key,
+					 const SharedHandle<BtProgressInfoFile>& btProgressInfoFile);
 
   // for PeerObject
   static PeerObjectClusterHandle
-  getPeerObjectCluster(const string& key);
+  getPeerObjectCluster(const std::string& key);
 
   static void
-  registerPeerObjectCluster(const string& key,
+  registerPeerObjectCluster(const std::string& key,
 			    const PeerObjectClusterHandle& cluster);
 
   static void
-  unregisterPeerObjectCluster(const string& key);
+  unregisterPeerObjectCluster(const std::string& key);
 
   static void unregisterAll();
 
-  static void unregister(const string& key);
+  static void unregister(const std::string& key);
 };
 
 #define PEER_STORAGE(btContext) \
@@ -149,4 +154,6 @@ PEER_OBJECT(btContext, peer)->peerConnection
 #define EXTENSION_MESSAGE_FACTORY(btContext, peer) \
 PEER_OBJECT(btContext, peer)->extensionMessageFactory
 
+} // namespace aria2
+
 #endif // _D_BT_REGISTRY_H_
diff --git a/src/BtRejectMessage.cc b/src/BtRejectMessage.cc
index 2ec5220f..d9c74d9a 100644
--- a/src/BtRejectMessage.cc
+++ b/src/BtRejectMessage.cc
@@ -37,6 +37,11 @@
 #include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+#include "RequestSlot.h"
+#include "BtMessageDispatcher.h"
+
+namespace aria2 {
 
 BtRejectMessageHandle BtRejectMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 13) {
@@ -94,7 +99,9 @@ int32_t BtRejectMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtRejectMessage::toString() const {
+std::string BtRejectMessage::toString() const {
   return "reject index="+Util::itos(index)+", begin="+Util::itos(begin)+
     ", length="+Util::itos(length);
 }
+
+} // namespace aria2
diff --git a/src/BtRejectMessage.h b/src/BtRejectMessage.h
index 359d001c..d5b92f5d 100644
--- a/src/BtRejectMessage.h
+++ b/src/BtRejectMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtRejectMessage;
 
 typedef SharedHandle<BtRejectMessage> BtRejectMessageHandle;
@@ -80,7 +82,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_REJECT_MESSAGE_H_
diff --git a/src/BtRejectMessageValidator.h b/src/BtRejectMessageValidator.h
index fc8e638b..49350d18 100644
--- a/src/BtRejectMessageValidator.h
+++ b/src/BtRejectMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtRejectMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtRejectMessageValidator : public BtMessageValidator {
 private:
@@ -65,4 +68,6 @@ public:
 
 typedef SharedHandle<BtRejectMessageValidator> BtRejectMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_REJECT_MESSAGE_VALIDATOR_H_
diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h
index 9cc07fcf..2d1f8c87 100644
--- a/src/BtRequestFactory.h
+++ b/src/BtRequestFactory.h
@@ -36,16 +36,21 @@
 #define _D_BT_REQUEST_FACTORY_H_
 
 #include "common.h"
-#include "BtMessage.h"
-#include "Piece.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class Piece;
+class BtMessage;
 
 class BtRequestFactory {
 public:
   virtual ~BtRequestFactory() {}
 
-  virtual void addTargetPiece(const PieceHandle& piece) = 0;
+  virtual void addTargetPiece(const SharedHandle<Piece>& piece) = 0;
 
-  virtual void removeTargetPiece(const PieceHandle& piece) = 0;
+  virtual void removeTargetPiece(const SharedHandle<Piece>& piece) = 0;
 
   virtual void removeAllTargetPiece() = 0;
 
@@ -60,16 +65,20 @@ public:
    * addTargetPiece() and returns them.
    * The number of objects returned is capped by max.
    */
-  virtual BtMessages createRequestMessages(int32_t max) = 0;
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessages(int32_t max) = 0;
 
   /**
    * Use this method in end game mode.
    *
    */
-  virtual BtMessages createRequestMessagesOnEndGame(int32_t max) = 0;
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessagesOnEndGame(int32_t max) = 0;
 };
 
 typedef SharedHandle<BtRequestFactory> BtRequestFactoryHandle;
 typedef WeakHandle<BtRequestFactory> BtRequestFactoryWeakHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_REQUEST_FACTORY_H_
diff --git a/src/BtRequestMessage.cc b/src/BtRequestMessage.cc
index d2494814..a07f83c3 100644
--- a/src/BtRequestMessage.cc
+++ b/src/BtRequestMessage.cc
@@ -38,6 +38,14 @@
 #include "DlAbortEx.h"
 #include "BtAbortOutstandingRequestEvent.h"
 #include "message.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageFactory.h"
+
+namespace aria2 {
 
 BtRequestMessageHandle BtRequestMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 13) {
@@ -97,7 +105,7 @@ int32_t BtRequestMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtRequestMessage::toString() const {
+std::string BtRequestMessage::toString() const {
   return "request index="+Util::itos(index)+", begin="+Util::itos(begin)+
     ", length="+Util::itos(length);
 }
@@ -124,3 +132,5 @@ void BtRequestMessage::handleAbortOutstandingRequestEvent(const BtEventHandle& e
     invalidate = true;
   }
 }
+
+} // namespace aria2
diff --git a/src/BtRequestMessage.h b/src/BtRequestMessage.h
index 2e526573..595a0d1f 100644
--- a/src/BtRequestMessage.h
+++ b/src/BtRequestMessage.h
@@ -36,10 +36,10 @@
 #define _D_BT_REQUEST_MESSAGE_H_
 
 #include "SimpleBtMessage.h"
-#include "BtContext.h"
-#include "PieceStorage.h"
 #include "AbstractBtEventListener.h"
 
+namespace aria2 {
+
 class BtRequestMessage;
 
 typedef SharedHandle<BtRequestMessage> BtRequestMessageHandle;
@@ -60,9 +60,9 @@ private:
   public:
     BtAbortOutstandingRequestEventListener(BtRequestMessage* message):message(message) {}
 
-    virtual bool canHandle(const BtEventHandle& event);
+    virtual bool canHandle(const SharedHandle<BtEvent>& event);
 
-    virtual void handleEventInternal(const BtEventHandle& event);
+    virtual void handleEventInternal(const SharedHandle<BtEvent>& event);
   };
 
   typedef SharedHandle<BtAbortOutstandingRequestEventListener> BtAbortOutstandingRequestEventListenerHandle;
@@ -108,11 +108,13 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual void onQueued();
 
-  virtual void handleAbortOutstandingRequestEvent(const BtEventHandle& event);
+  virtual void handleAbortOutstandingRequestEvent(const SharedHandle<BtEvent>& event);
 };
 
+} // namespace aria2
+
 #endif // _D_BT_REQUEST_MESSAGE_H_
diff --git a/src/BtRequestMessageValidator.h b/src/BtRequestMessageValidator.h
index 19ffa797..d2e6091a 100644
--- a/src/BtRequestMessageValidator.h
+++ b/src/BtRequestMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtRequestMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtRequestMessageValidator : public BtMessageValidator {
 private:
@@ -65,4 +68,6 @@ public:
 
 typedef SharedHandle<BtRequestMessageValidator> BtRequestMessageValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_REQUEST_MESSAGE_VALIDATOR_H_
diff --git a/src/BtRuntime.h b/src/BtRuntime.h
index 9bf7624d..5dd44a41 100644
--- a/src/BtRuntime.h
+++ b/src/BtRuntime.h
@@ -38,6 +38,8 @@
 #include "common.h"
 #include "BtConstants.h"
 
+namespace aria2 {
+
 #define MIN_PEERS 40
 
 class BtRuntime {
@@ -95,4 +97,6 @@ public:
 
 typedef SharedHandle<BtRuntime> BtRuntimeHandle;
 
+} // namespace aria2
+
 #endif // _D_BT_RUNTIME_H_
diff --git a/src/BtSetup.cc b/src/BtSetup.cc
index 666c1027..d6e3943d 100644
--- a/src/BtSetup.cc
+++ b/src/BtSetup.cc
@@ -46,8 +46,6 @@
 #include "UnionSeedCriteria.h"
 #include "TimeSeedCriteria.h"
 #include "ShareRatioSeedCriteria.h"
-#include "DefaultPieceStorage.h"
-#include "DefaultBtProgressInfoFile.h"
 #include "CUIDCounter.h"
 #include "prefs.h"
 #include "LogFactory.h"
@@ -59,6 +57,8 @@
 #include "DHTSetup.h"
 #include "DHTRegistry.h"
 
+namespace aria2 {
+
 BtSetup::BtSetup():_logger(LogFactory::getInstance()) {}
 
 Commands BtSetup::setup(RequestGroup* requestGroup,
@@ -129,3 +129,5 @@ Commands BtSetup::setup(RequestGroup* requestGroup,
   BT_RUNTIME(btContext)->setReady(true);
   return commands;
 }
+
+} // namespace aria2
diff --git a/src/BtSetup.h b/src/BtSetup.h
index 76efb4ed..3617e970 100644
--- a/src/BtSetup.h
+++ b/src/BtSetup.h
@@ -36,13 +36,15 @@
 #define _D_BT_SETUP_H_
 
 #include "common.h"
+#include <deque>
+
+namespace aria2 {
 
 class Logger;
 class RequestGroup;
 class DownloadEngine;
 class Option;
 class Command;
-typedef deque<Command*> Commands;
 
 class BtSetup {
 private:
@@ -50,9 +52,11 @@ private:
 public:
   BtSetup();
 
-  Commands setup(RequestGroup* requestGroup,
-		 DownloadEngine* e,
-		 const Option* option);
+  std::deque<Command*> setup(RequestGroup* requestGroup,
+			     DownloadEngine* e,
+			     const Option* option);
 };
 
+} // namespace aria2
+
 #endif // _D_BT_SETUP_H_
diff --git a/src/BtSuggestPieceMessage.cc b/src/BtSuggestPieceMessage.cc
index 04f7b6ff..181f3c80 100644
--- a/src/BtSuggestPieceMessage.cc
+++ b/src/BtSuggestPieceMessage.cc
@@ -38,6 +38,8 @@
 #include "DlAbortEx.h"
 #include "message.h"
 
+namespace aria2 {
+
 BtSuggestPieceMessageHandle BtSuggestPieceMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 5) {
     throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "suggest piece", dataLength, 5);
@@ -72,6 +74,8 @@ int32_t BtSuggestPieceMessage::getMessageLength() {
   return MESSAGE_LENGTH;
 }
 
-string BtSuggestPieceMessage::toString() const {
+std::string BtSuggestPieceMessage::toString() const {
   return "suggest piece index="+Util::itos(index);
 }
+
+} // namespace aria2
diff --git a/src/BtSuggestPieceMessage.h b/src/BtSuggestPieceMessage.h
index c348cb7e..3eed578f 100644
--- a/src/BtSuggestPieceMessage.h
+++ b/src/BtSuggestPieceMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtSuggestPieceMessage;
 
 typedef SharedHandle<BtSuggestPieceMessage> BtSuggestPieceMessageHandle;
@@ -73,7 +75,9 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_BT_SUGGEST_PIECE_MESSAGE_H_
diff --git a/src/BtSuggestPieceMessageValidator.h b/src/BtSuggestPieceMessageValidator.h
index 4274f1de..2d710c6d 100644
--- a/src/BtSuggestPieceMessageValidator.h
+++ b/src/BtSuggestPieceMessageValidator.h
@@ -37,6 +37,9 @@
 
 #include "BtMessageValidator.h"
 #include "BtSuggestPieceMessage.h"
+#include "PeerMessageUtil.h"
+
+namespace aria2 {
 
 class BtSuggestPieceMessageValidator : public BtMessageValidator {
 private:
@@ -57,4 +60,7 @@ public:
 };
 
 typedef SharedHandle<BtSuggestPieceMessageValidator> BtSuggestPieceMessageValidatorHandle;
+
+} // namespace aria2
+
 #endif // _D_BT_SUGGEST_PIECE_MESSAGE_VALIDATOR_H_
diff --git a/src/BtUnchokeMessage.cc b/src/BtUnchokeMessage.cc
index 2e12856e..949888f5 100644
--- a/src/BtUnchokeMessage.cc
+++ b/src/BtUnchokeMessage.cc
@@ -36,6 +36,9 @@
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
 #include "message.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 BtUnchokeMessageHandle BtUnchokeMessage::create(const unsigned char* data, int32_t dataLength) {
   if(dataLength != 1) {
@@ -80,6 +83,8 @@ void BtUnchokeMessage::onSendComplete() {
   peer->amChoking = false;
 }
 
-string BtUnchokeMessage::toString() const {
+std::string BtUnchokeMessage::toString() const {
   return "unchoke";
 }
+
+} // namespace aria2
diff --git a/src/BtUnchokeMessage.h b/src/BtUnchokeMessage.h
index abcbf951..10b8a709 100644
--- a/src/BtUnchokeMessage.h
+++ b/src/BtUnchokeMessage.h
@@ -37,6 +37,8 @@
 
 #include "SimpleBtMessage.h"
 
+namespace aria2 {
+
 class BtUnchokeMessage;
 
 typedef SharedHandle<BtUnchokeMessage> BtUnchokeMessageHandle;
@@ -64,11 +66,13 @@ public:
 
   virtual int32_t getMessageLength();
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual bool sendPredicate() const;
 
   virtual void onSendComplete();
 };
 
+} // namespace aria2
+
 #endif // _D_BT_UNCHOKE_MESSAGE_H_
diff --git a/src/ByteArrayDiskWriter.cc b/src/ByteArrayDiskWriter.cc
index e232ac5b..81dfe8eb 100644
--- a/src/ByteArrayDiskWriter.cc
+++ b/src/ByteArrayDiskWriter.cc
@@ -35,8 +35,9 @@
 #include "ByteArrayDiskWriter.h"
 #include "Util.h"
 
-ByteArrayDiskWriter::ByteArrayDiskWriter() {
-}
+namespace aria2 {
+
+ByteArrayDiskWriter::ByteArrayDiskWriter() {}
 
 ByteArrayDiskWriter::~ByteArrayDiskWriter() {}
 
@@ -45,21 +46,18 @@ void ByteArrayDiskWriter::clear()
   buf.str("");
 }
 
-void ByteArrayDiskWriter::initAndOpenFile(const string& filename,
+void ByteArrayDiskWriter::initAndOpenFile(const std::string& filename,
 					  int64_t totalLength)
 {
   clear();
 }
 
-void ByteArrayDiskWriter::openFile(const string& filename,
-				   int64_t totalLength)
-{
-}
+void ByteArrayDiskWriter::openFile(const std::string& filename,
+				   int64_t totalLength) {}
 
-void ByteArrayDiskWriter::closeFile()
-{}
+void ByteArrayDiskWriter::closeFile() {}
 
-void ByteArrayDiskWriter::openExistingFile(const string& filename,
+void ByteArrayDiskWriter::openExistingFile(const std::string& filename,
 					   int64_t totalLength)
 {
   openFile(filename);
@@ -68,20 +66,22 @@ void ByteArrayDiskWriter::openExistingFile(const string& filename,
 void ByteArrayDiskWriter::writeData(const unsigned char* data, int32_t dataLength, int64_t position)
 {
   if(size() < position) {
-    buf.seekp(size(), ios::beg);
+    buf.seekp(size(), std::ios::beg);
     for(int64_t i = size(); i < position; ++i) {
       buf.put('\0');
     }
   } else {
-    buf.seekp(position, ios::beg);
+    buf.seekp(position, std::ios::beg);
   }
   buf.write(reinterpret_cast<const char*>(data), dataLength);
 }
 
 int32_t ByteArrayDiskWriter::readData(unsigned char* data, int32_t len, int64_t position)
 {
-  buf.seekg(position, ios::beg);
+  buf.seekg(position, std::ios::beg);
   buf.read(reinterpret_cast<char*>(data), len);
   buf.clear();
   return buf.gcount();
 }
+
+} // namespace aria2
diff --git a/src/ByteArrayDiskWriter.h b/src/ByteArrayDiskWriter.h
index b63bdb4d..c5d24de5 100644
--- a/src/ByteArrayDiskWriter.h
+++ b/src/ByteArrayDiskWriter.h
@@ -38,22 +38,24 @@
 #include "DiskWriter.h"
 #include <sstream>
 
+namespace aria2 {
+
 class ByteArrayDiskWriter : public DiskWriter {
 private:
-  stringstream buf;
+  std::stringstream buf;
 
   void clear();
 public:
   ByteArrayDiskWriter();
   virtual ~ByteArrayDiskWriter();
 
-  virtual void initAndOpenFile(const string& filename, int64_t totalLength = 0);
+  virtual void initAndOpenFile(const std::string& filename, int64_t totalLength = 0);
 
-  virtual void openFile(const string& filename, int64_t totalLength = 0);
+  virtual void openFile(const std::string& filename, int64_t totalLength = 0);
 
   virtual void closeFile();
 
-  virtual void openExistingFile(const string& filename, int64_t totalLength = 0);
+  virtual void openExistingFile(const std::string& filename, int64_t totalLength = 0);
 
   virtual void writeData(const unsigned char* data, int32_t len, int64_t position);
   virtual int32_t readData(unsigned char* data, int32_t len, int64_t position);
@@ -75,11 +77,14 @@ public:
     return false;
   }
 
-  void setString(const string& s)
+  void setString(const std::string& s)
   {
     buf.str(s);
   }
 };
 
 typedef SharedHandle<ByteArrayDiskWriter> ByteArrayDiskWriterHandle;
+
+} // namespace aria2
+
 #endif // _D_BYTE_ARRAY_DISK_WRITER_H_
diff --git a/src/DHTConnectionDecl.h b/src/ByteArrayDiskWriterFactory.cc
similarity index 88%
rename from src/DHTConnectionDecl.h
rename to src/ByteArrayDiskWriterFactory.cc
index 8744ccf9..7de81707 100644
--- a/src/DHTConnectionDecl.h
+++ b/src/ByteArrayDiskWriterFactory.cc
@@ -32,12 +32,14 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
-#ifndef _D_DHT_CONNECTION_DECL_H_
-#define _D_DHT_CONNECTION_DECL_H_
+#include "ByteArrayDiskWriterFactory.h"
+#include "ByteArrayDiskWriter.h"
 
-#include "SharedHandle.h"
+namespace aria2 {
 
-class DHTConnection;
-typedef SharedHandle<DHTConnection> DHTConnectionHandle;
+DiskWriterHandle ByteArrayDiskWriterFactory::newDiskWriter()
+{
+  return new ByteArrayDiskWriter();
+}
 
-#endif // _D_DHT_CONNECTION_DECL_H_
+} // namespace aria2
diff --git a/src/ByteArrayDiskWriterFactory.h b/src/ByteArrayDiskWriterFactory.h
index 2c72194e..7af26018 100644
--- a/src/ByteArrayDiskWriterFactory.h
+++ b/src/ByteArrayDiskWriterFactory.h
@@ -36,17 +36,19 @@
 #define _D_BYTE_ARRAY_DISK_WRITER_FACTORY_H_
 
 #include "DiskWriterFactory.h"
-#include "ByteArrayDiskWriter.h"
+
+namespace aria2 {
+
+class ByteArrayDiskWriter;
 
 class ByteArrayDiskWriterFactory:public DiskWriterFactory
 {
 public:
-  DiskWriterHandle newDiskWriter()
-  {
-    return new ByteArrayDiskWriter();
-  }
+  SharedHandle<DiskWriter> newDiskWriter();
 };
 
 typedef SharedHandle<ByteArrayDiskWriterFactory> ByteArrayDiskWriterFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_BYTE_ARRAY_DISK_WRITER_FACTORY_H_
diff --git a/src/CUIDCounter.h b/src/CUIDCounter.h
index d251cceb..86ad2af5 100644
--- a/src/CUIDCounter.h
+++ b/src/CUIDCounter.h
@@ -36,6 +36,9 @@
 #define _D_CUID_COUNTER_H_
 
 #include "common.h"
+#include "SingletonHolder.h"
+
+namespace aria2 {
 
 typedef int32_t CUID;
 
@@ -56,4 +59,6 @@ public:
 typedef SharedHandle<CUIDCounter> CUIDCounterHandle;
 typedef SingletonHolder<CUIDCounterHandle> CUIDCounterSingletonHolder;
 
+}
+
 #endif // _D_CUID_COUNTER_H_
diff --git a/src/CheckIntegrityCommand.cc b/src/CheckIntegrityCommand.cc
index d5db23c5..e5c9fa11 100644
--- a/src/CheckIntegrityCommand.cc
+++ b/src/CheckIntegrityCommand.cc
@@ -35,14 +35,14 @@
 #include "CheckIntegrityCommand.h"
 #include "CheckIntegrityMan.h"
 #include "CheckIntegrityEntry.h"
+#include "DownloadEngine.h"
 #include "RequestGroup.h"
-#include "FileAllocationEntry.h"
-#include "InitiateConnectionCommandFactory.h"
-#include "DlAbortEx.h"
+#include "Logger.h"
 #include "message.h"
-#include "DownloadCommand.h"
 #include "prefs.h"
 
+namespace aria2 {
+
 CheckIntegrityCommand::CheckIntegrityCommand(int32_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const CheckIntegrityEntryHandle& entry):
   RealtimeCommand(cuid, requestGroup, e),
   _entry(entry)
@@ -84,3 +84,5 @@ bool CheckIntegrityCommand::handleException(Exception* e)
   logger->error(MSG_DOWNLOAD_NOT_COMPLETE, cuid, _requestGroup->getFilePath().c_str());
   return true;
 }
+
+} // namespace aria2
diff --git a/src/CheckIntegrityCommand.h b/src/CheckIntegrityCommand.h
index 6475b73a..b19829f5 100644
--- a/src/CheckIntegrityCommand.h
+++ b/src/CheckIntegrityCommand.h
@@ -36,17 +36,22 @@
 #define _D_CHECK_INTEGRITY_COMMAND_H_
 
 #include "RealtimeCommand.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class CheckIntegrityEntry;
-typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
 
 class CheckIntegrityCommand : public RealtimeCommand {
 private:
-  CheckIntegrityEntryHandle _entry;
+  SharedHandle<CheckIntegrityEntry> _entry;
   Time _timer;
 public:
-  CheckIntegrityCommand(int32_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const CheckIntegrityEntryHandle& entry);
+  CheckIntegrityCommand(int32_t cuid,
+			RequestGroup* requestGroup,
+			DownloadEngine* e,
+			const SharedHandle<CheckIntegrityEntry>& entry);
 
   virtual ~CheckIntegrityCommand();
 
@@ -55,4 +60,6 @@ public:
   virtual bool handleException(Exception* e);
 };
 
+} // namespace aria2
+
 #endif // _D_CHECK_INTEGRITY_COMMAND_H_
diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc
index 43f5a6a1..d2c8f1e9 100644
--- a/src/CheckIntegrityEntry.cc
+++ b/src/CheckIntegrityEntry.cc
@@ -33,10 +33,10 @@
  */
 /* copyright --> */
 #include "CheckIntegrityEntry.h"
-#include "Command.h"
-#include "RequestGroup.h"
 #include "IteratableValidator.h"
 
+namespace aria2 {
+
 CheckIntegrityEntry::CheckIntegrityEntry(RequestGroup* requestGroup,
 					 Command* nextCommand):
   RequestGroupEntry(requestGroup, nextCommand),
@@ -72,3 +72,5 @@ bool CheckIntegrityEntry::finished()
 {
   return _validator->finished();
 }
+
+} // namespace aria2
diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h
index d1ae8ca0..5aea0867 100644
--- a/src/CheckIntegrityEntry.h
+++ b/src/CheckIntegrityEntry.h
@@ -36,17 +36,18 @@
 #define _D_CHECK_INTEGRITY_ENTRY_H_
 
 #include "RequestGroupEntry.h"
+#include "ProgressAwareEntry.h"
+#include <deque>
+
+namespace aria2 {
 
 class IteratableValidator;
-typedef SharedHandle<IteratableValidator> IteratableValidatorHandle;
-class Command;
-typedef deque<Command*> Commands;
 class DownloadEngine;
 
 class CheckIntegrityEntry : public RequestGroupEntry,
 			    public ProgressAwareEntry {
 protected:
-  IteratableValidatorHandle _validator;
+  SharedHandle<IteratableValidator> _validator;
 public:
   CheckIntegrityEntry(RequestGroup* requestGroup, Command* nextCommand = 0);
 
@@ -64,11 +65,14 @@ public:
 
   virtual void initValidator() = 0;
 
-  virtual Commands onDownloadFinished(DownloadEngine* e) = 0;
+  virtual std::deque<Command*> onDownloadFinished(DownloadEngine* e) = 0;
 
-  virtual Commands onDownloadIncomplete(DownloadEngine* e) = 0;
+  virtual std::deque<Command*> onDownloadIncomplete(DownloadEngine* e) = 0;
 };
 
 typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
-typedef deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
+typedef std::deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
+
+} // namespace aria2
+
 #endif // _D_CHECK_INTEGRITY_ENTRY_H_
diff --git a/src/CheckIntegrityMan.cc b/src/CheckIntegrityMan.cc
index dcb7d157..1c02d623 100644
--- a/src/CheckIntegrityMan.cc
+++ b/src/CheckIntegrityMan.cc
@@ -34,6 +34,9 @@
 /* copyright --> */
 #include "CheckIntegrityMan.h"
 #include "CheckIntegrityEntry.h"
+#include <algorithm>
+
+namespace aria2 {
 
 CheckIntegrityMan::CheckIntegrityMan() {}
 
@@ -46,9 +49,8 @@ void CheckIntegrityMan::addCheckIntegrityEntry(const CheckIntegrityEntryHandle&
 
 bool CheckIntegrityMan::removeCheckIntegrityEntry(const CheckIntegrityEntryHandle& entry)
 {
-  CheckIntegrityEntries::iterator itr = find(_checkIntegrityEntries.begin(),
-					     _checkIntegrityEntries.end(),
-					     entry);
+  CheckIntegrityEntries::iterator itr =
+    std::find(_checkIntegrityEntries.begin(), _checkIntegrityEntries.end(), entry);
   if(itr == _checkIntegrityEntries.end()) {
     return false;
   } else {
@@ -70,3 +72,5 @@ int32_t CheckIntegrityMan::countCheckIntegrityEntry() const
 {
   return _checkIntegrityEntries.size();
 }
+
+} // namespace aria2
diff --git a/src/CheckIntegrityMan.h b/src/CheckIntegrityMan.h
index ed8f3f7a..2d78a57d 100644
--- a/src/CheckIntegrityMan.h
+++ b/src/CheckIntegrityMan.h
@@ -36,28 +36,32 @@
 #define _D_CHECK_INTEGRITY_MAN_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class CheckIntegrityEntry;
-typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
-typedef deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
 
 class CheckIntegrityMan {
 private:
-  CheckIntegrityEntries _checkIntegrityEntries;
+  std::deque<SharedHandle<CheckIntegrityEntry> > _checkIntegrityEntries;
 public:
   CheckIntegrityMan();
 
   ~CheckIntegrityMan();
 
-  void addCheckIntegrityEntry(const CheckIntegrityEntryHandle& entry);
+  void addCheckIntegrityEntry(const SharedHandle<CheckIntegrityEntry>& entry);
 
-  bool removeCheckIntegrityEntry(const CheckIntegrityEntryHandle& entry);
+  bool removeCheckIntegrityEntry(const SharedHandle<CheckIntegrityEntry>& entry);
 
-  CheckIntegrityEntryHandle getFirstCheckIntegrityEntry() const;
+  SharedHandle<CheckIntegrityEntry> getFirstCheckIntegrityEntry() const;
 
   int32_t countCheckIntegrityEntry() const;
 };
 
 typedef SharedHandle<CheckIntegrityMan> CheckIntegrityManHandle;
 
+} // namespace aria2
+
 #endif // _D_CHECK_INTEGRITY_MAN_H_
diff --git a/src/Checksum.h b/src/Checksum.h
index 54eea063..ed507cb8 100644
--- a/src/Checksum.h
+++ b/src/Checksum.h
@@ -36,14 +36,18 @@
 #define _D_CHECKSUM_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
 
 class Checksum {
 private:
-  string _algo;
-  string _messageDigest;
+  std::string _algo;
+  std::string _messageDigest;
 public:
   // _messageDigest is ascii hexadecimal notation.
-  Checksum(const string& algo, const string& messageDigest):
+  Checksum(const std::string& algo, const std::string& messageDigest):
     _algo(algo), _messageDigest(messageDigest) {}
   Checksum():
     _algo("sha1") {}
@@ -51,25 +55,25 @@ public:
   ~Checksum() {}
 
   bool isEmpty() const {
-    return _messageDigest.size() == 0;
+    return _messageDigest.empty();
   }
 
-  void setMessageDigest(const string& md) {
+  void setMessageDigest(const std::string& md) {
     this->_messageDigest = md;
   }
-  const string& getMessageDigest() const {
+  const std::string& getMessageDigest() const {
     return _messageDigest;
   }
   
-  void setAlgo(const string& algo) {
+  void setAlgo(const std::string& algo) {
     this->_algo = algo;
   }
 
-  const string& getAlgo() const {
+  const std::string& getAlgo() const {
     return _algo;
   }
 };
 
-typedef SharedHandle<Checksum> ChecksumHandle;
+} // namespace aria2
 
 #endif // _D_CHECKSUM_H_
diff --git a/src/ChecksumCheckIntegrityEntry.cc b/src/ChecksumCheckIntegrityEntry.cc
index e521415c..6c4ccd33 100644
--- a/src/ChecksumCheckIntegrityEntry.cc
+++ b/src/ChecksumCheckIntegrityEntry.cc
@@ -34,12 +34,14 @@
 /* copyright --> */
 #include "ChecksumCheckIntegrityEntry.h"
 #include "RequestGroup.h"
-#include "Command.h"
 #include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
 #include "IteratableChecksumValidator.h"
 #include "DownloadEngine.h"
 #include "PieceStorage.h"
 
+namespace aria2 {
+
 ChecksumCheckIntegrityEntry::ChecksumCheckIntegrityEntry(RequestGroup* requestGroup, Command* nextCommand):
   CheckIntegrityEntry(requestGroup, nextCommand) {}
 
@@ -59,13 +61,16 @@ void ChecksumCheckIntegrityEntry::initValidator()
   _validator->init();
 }
 
-Commands ChecksumCheckIntegrityEntry::onDownloadFinished(DownloadEngine* e)
+std::deque<Command*>
+ChecksumCheckIntegrityEntry::onDownloadFinished(DownloadEngine* e)
 {
-  return Commands();
+  return std::deque<Command*>();
 }
 
-Commands ChecksumCheckIntegrityEntry::onDownloadIncomplete(DownloadEngine* e)
+std::deque<Command*>
+ChecksumCheckIntegrityEntry::onDownloadIncomplete(DownloadEngine* e)
 {
-  return Commands();
+  return std::deque<Command*>();
 }
 
+} // namespace aria2
diff --git a/src/ChecksumCheckIntegrityEntry.h b/src/ChecksumCheckIntegrityEntry.h
index dfe2252e..f7de3979 100644
--- a/src/ChecksumCheckIntegrityEntry.h
+++ b/src/ChecksumCheckIntegrityEntry.h
@@ -37,6 +37,8 @@
 
 #include "CheckIntegrityEntry.h"
 
+namespace aria2 {
+
 class ChecksumCheckIntegrityEntry:public CheckIntegrityEntry
 {
 public:
@@ -48,9 +50,11 @@ public:
 
   virtual void initValidator();
 
-  virtual Commands onDownloadFinished(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadFinished(DownloadEngine* e);
 
-  virtual Commands onDownloadIncomplete(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadIncomplete(DownloadEngine* e);
 };
 
+} // namespace aria2
+
 #endif // _D_CHECKSUM_CHECK_INTEGRITY_ENTRY_H_
diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h
index c6280b4e..f5c42a0f 100644
--- a/src/ChunkChecksum.h
+++ b/src/ChunkChecksum.h
@@ -36,24 +36,28 @@
 #define _D_CHUNK_CHECKSUM_H_
 
 #include "common.h"
-#include "messageDigest.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class ChunkChecksum {
 private:
-  string _algo;
-  Strings _checksums;
+  std::string _algo;
+  std::deque<std::string> _checksums;
   int32_t _checksumLength;
 public:
   ChunkChecksum():_checksumLength(0) {}    
 
-  ChunkChecksum(const string& algo,
-		const Strings& checksums,
+  ChunkChecksum(const std::string& algo,
+		const std::deque<std::string>& checksums,
 		int32_t checksumLength):
     _algo(algo),
     _checksums(checksums),
     _checksumLength(checksumLength) {}
 
-  bool validateChunk(const string& actualChecksum,
+  bool validateChunk(const std::string& actualChecksum,
 		     int32_t checksumIndex) const
   {
     if(checksumIndex < (int32_t)_checksums.size()) {
@@ -73,7 +77,7 @@ public:
     return _checksums.size();
   }
 
-  string getChecksum(int32_t index) const
+  std::string getChecksum(int32_t index) const
   {
     if(index < (int32_t)_checksums.size()) {
       return _checksums[index];
@@ -82,7 +86,7 @@ public:
     }
   }
   
-  const Strings& getChecksums() const
+  const std::deque<std::string>& getChecksums() const
   {
     return _checksums;
   }
@@ -92,12 +96,12 @@ public:
     return _checksumLength;
   }
 
-  const string& getAlgo() const
+  const std::string& getAlgo() const
   {
     return _algo;
   }
 
-  void setAlgo(const string& algo)
+  void setAlgo(const std::string& algo)
   {
     _algo = algo;
   }
@@ -107,12 +111,12 @@ public:
     _checksumLength = length;
   }
 
-  void setChecksums(const Strings& mds)
+  void setChecksums(const std::deque<std::string>& mds)
   {
     _checksums = mds;
   }
 };
 
-typedef SharedHandle<ChunkChecksum> ChunkChecksumHandle;
+} // namespace aria2
 
 #endif // _D_CHUNK_CHECKSUM_H_
diff --git a/src/ChunkedEncoding.cc b/src/ChunkedEncoding.cc
index c376aba1..7840c8d6 100644
--- a/src/ChunkedEncoding.cc
+++ b/src/ChunkedEncoding.cc
@@ -36,9 +36,9 @@
 #include "DlAbortEx.h"
 #include "message.h"
 #include "Util.h"
-#include <string.h>
-#include <strings.h>
-#include <errno.h>
+#include <cstring>
+
+namespace aria2 {
 
 #define MAX_BUFSIZE (1024*1024)
 
@@ -51,9 +51,7 @@ ChunkedEncoding::ChunkedEncoding() {
 }
 
 ChunkedEncoding::~ChunkedEncoding() {
-  if(strbuf != NULL) {
-    delete [] strbuf;
-  }
+  delete [] strbuf;
 }
 
 void ChunkedEncoding::init() {
@@ -161,7 +159,7 @@ int32_t ChunkedEncoding::readChunkSize(char** pp) {
   if(exsp == 0 || p < exsp) {
     exsp = p;
   }
-  string temp(*pp, exsp);
+  std::string temp(*pp, exsp);
   chunkSize = Util::parseInt(temp, 16);
   if(chunkSize < 0) {
     throw new DlAbortEx(EX_INVALID_CHUNK_SIZE);
@@ -186,3 +184,5 @@ void ChunkedEncoding::addBuffer(const char* inbuf, int32_t inlen) {
   memcpy(strbufTail, inbuf, inlen);
   strbufTail += inlen;
 }
+
+} // namespace aria2
diff --git a/src/ChunkedEncoding.h b/src/ChunkedEncoding.h
index 2e73ed5b..eaaf2352 100644
--- a/src/ChunkedEncoding.h
+++ b/src/ChunkedEncoding.h
@@ -37,6 +37,8 @@
 
 #include "TransferEncoding.h"
 
+namespace aria2 {
+
 class ChunkedEncoding:public TransferEncoding {
 private:
   enum STATE {
@@ -70,4 +72,6 @@ public:
   void end();
 };
 
+} // namespace aria2
+
 #endif // _D_CHUNKED_ENCODING_H_
diff --git a/src/Command.cc b/src/Command.cc
index b24d74fd..c7b22f7f 100644
--- a/src/Command.cc
+++ b/src/Command.cc
@@ -33,5 +33,26 @@
  */
 /* copyright --> */
 #include "Command.h"
+#include "LogFactory.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 int32_t Command::uuidGen = 0;
+
+Command::Command(int32_t cuid):uuid(uuidGen++),
+			       status(STATUS_INACTIVE),
+			       cuid(cuid),
+			       logger(LogFactory::getInstance()) {}
+
+void Command::transitStatus()
+{
+  switch(status) {
+  case STATUS_REALTIME:
+    break;
+  default:
+    status = STATUS_INACTIVE;
+    }
+}
+
+} // namespace aria2
diff --git a/src/Command.h b/src/Command.h
index c83be85c..3d61a5c3 100644
--- a/src/Command.h
+++ b/src/Command.h
@@ -36,7 +36,11 @@
 #define _D_COMMAND_H_
 
 #include "common.h"
-#include "LogFactory.h"
+#include <deque>
+
+namespace aria2 {
+
+class Logger;
 
 typedef int32_t CommandUuid;
 
@@ -56,13 +60,14 @@ protected:
   int32_t cuid;
   const Logger* logger;
 public:
-  Command(int32_t cuid):uuid(uuidGen++), status(STATUS_INACTIVE), cuid(cuid) {
-    logger = LogFactory::getInstance();
-  }
+  Command(int32_t cuid);
+
   virtual ~Command() {}
+
   virtual bool execute() = 0;
 
   int32_t getCuid() const { return cuid; }
+
   const CommandUuid& getUuid() const { return uuid; }
 
   void setStatusActive() { this->status = STATUS_ACTIVE; }
@@ -76,17 +81,11 @@ public:
     return statusFilter <= status;
   }
 
-  void transitStatus()
-  {
-    switch(status) {
-    case STATUS_REALTIME:
-      break;
-    default:
-      status = STATUS_INACTIVE;
-    }
-  }
+  void transitStatus();
 };
 
-typedef deque<Command*> Commands;
+typedef std::deque<Command*> Commands;
+
+} // namespace aria2
 
 #endif // _D_COMMAND_H_
diff --git a/src/CompactPeerListProcessor.cc b/src/CompactPeerListProcessor.cc
index a3ddc70f..f6978f27 100644
--- a/src/CompactPeerListProcessor.cc
+++ b/src/CompactPeerListProcessor.cc
@@ -32,9 +32,18 @@
  */
 /* copyright --> */
 #include "CompactPeerListProcessor.h"
+#include "Peer.h"
 #include "Data.h"
 #include "a2netcompat.h"
 
+namespace aria2 {
+
+CompactPeerListProcessor::CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength):
+  pieceLength(pieceLength),
+  totalLength(totalLength) {}
+
+CompactPeerListProcessor::~CompactPeerListProcessor() {}
+
 bool CompactPeerListProcessor::canHandle(const MetaEntry* peersEntry) const {
   return dynamic_cast<const Data*>(peersEntry) != 0;
 }
@@ -49,7 +58,7 @@ Peers CompactPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
     for(int32_t i = 0; i < peersData->getLen(); i += 6) {
       struct in_addr in;
       in.s_addr = *(uint32_t*)(peersData->getData()+i);
-      string ipaddr = inet_ntoa(in);
+      std::string ipaddr = inet_ntoa(in);
       uint16_t port = ntohs(*(uint16_t*)(peersData->getData()+i+4));
       PeerHandle peer = new Peer(ipaddr, port);      
       peers.push_back(peer);
@@ -57,3 +66,5 @@ Peers CompactPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
   }
   return peers;
 }
+
+} // namespace aria2
diff --git a/src/CompactPeerListProcessor.h b/src/CompactPeerListProcessor.h
index e81cfae8..80a6d770 100644
--- a/src/CompactPeerListProcessor.h
+++ b/src/CompactPeerListProcessor.h
@@ -36,20 +36,23 @@
 
 #include "PeerListProcessor.h"
 
+namespace aria2 {
+
 class CompactPeerListProcessor : public PeerListProcessor {
 private:
   int32_t pieceLength;
   int64_t totalLength;
 public:
-  CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength)
-  :pieceLength(pieceLength),
-   totalLength(totalLength) {}
+  CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength);
 
-  virtual ~CompactPeerListProcessor() {}
+  virtual ~CompactPeerListProcessor();
 
-  virtual Peers extractPeer(const MetaEntry* peersEntry);
+  virtual std::deque<SharedHandle<Peer> >
+  extractPeer(const MetaEntry* peersEntry);
 
   virtual bool canHandle(const MetaEntry* peersEntry) const;
 };
 
+} // namespace aria2
+
 #endif // _D_COMPACT_PEER_LIST_PROCESSOR_H_
diff --git a/src/ConsoleStatCalc.cc b/src/ConsoleStatCalc.cc
index 3b3d1f75..b0a5ef85 100644
--- a/src/ConsoleStatCalc.cc
+++ b/src/ConsoleStatCalc.cc
@@ -44,6 +44,9 @@
 # include "BtContext.h"
 #endif // ENABLE_BITTORRENT
 #include <iomanip>
+#include <iostream>
+
+namespace aria2 {
 
 void
 ConsoleStatCalc::calculateStat(const RequestGroupManHandle& requestGroupMan,
@@ -55,8 +58,8 @@ ConsoleStatCalc::calculateStat(const RequestGroupManHandle& requestGroupMan,
   }
   _cp.reset();
 
-  cout << "\r                                                                             ";
-  cout << "\r";
+  std::cout << "\r                                                                             ";
+  std::cout << "\r";
   if(requestGroupMan->countRequestGroup() > 0) {
     RequestGroupHandle firstRequestGroup = requestGroupMan->getRequestGroup(0);
     TransferStat stat = firstRequestGroup->calculateStat();
@@ -65,88 +68,88 @@ ConsoleStatCalc::calculateStat(const RequestGroupManHandle& requestGroupMan,
       eta = (firstRequestGroup->getTotalLength()-firstRequestGroup->getCompletedLength())/stat.getDownloadSpeed();
     }
 
-    cout << "["
-	 << "#" << firstRequestGroup->getGID() << " ";
+    std::cout << "["
+	      << "#" << firstRequestGroup->getGID() << " ";
 #ifdef ENABLE_BITTORRENT
     if(firstRequestGroup->downloadFinished() &&
        !BtContextHandle(firstRequestGroup->getDownloadContext()).isNull()) {
-      cout << "SEEDING" << "(" << "ratio:"
-	   << fixed << setprecision(1)
-	   << ((stat.getAllTimeUploadLength()*10)/firstRequestGroup->getCompletedLength())/10.0
-	   << ")";
+      std::cout << "SEEDING" << "(" << "ratio:"
+		<< std::fixed << std::setprecision(1)
+		<< ((stat.getAllTimeUploadLength()*10)/firstRequestGroup->getCompletedLength())/10.0
+		<< ")";
     } else
 #endif // ENABLE_BITTORRENT
       {
-	cout << "SIZE:"
-	     << Util::abbrevSize(firstRequestGroup->getCompletedLength())
-	     << "B"
-	     << "/"
-	     << Util::abbrevSize(firstRequestGroup->getTotalLength())
-	     << "B";
+	std::cout << "SIZE:"
+		  << Util::abbrevSize(firstRequestGroup->getCompletedLength())
+		  << "B"
+		  << "/"
+		  << Util::abbrevSize(firstRequestGroup->getTotalLength())
+		  << "B";
 	if(firstRequestGroup->getTotalLength() > 0) {
-	  cout << "("
-	       << 100*firstRequestGroup->getCompletedLength()/firstRequestGroup->getTotalLength()
-	       << "%)";
+	  std::cout << "("
+		    << 100*firstRequestGroup->getCompletedLength()/firstRequestGroup->getTotalLength()
+		    << "%)";
 	}
       }
-    cout << " "
-	 << "CN:"
-	 << firstRequestGroup->getNumConnection();
+    std::cout << " "
+	      << "CN:"
+	      << firstRequestGroup->getNumConnection();
     if(!firstRequestGroup->downloadFinished()) {
-      cout << " "
-	   << "SPD:"
-	   << fixed << setprecision(2) << stat.getDownloadSpeed()/1024.0 << "KiB/s";
+      std::cout << " "
+		<< "SPD:"
+		<< std::fixed << std::setprecision(2) << stat.getDownloadSpeed()/1024.0 << "KiB/s";
     }
     if(stat.getSessionUploadLength() > 0) {
-      cout << " "
-	   << "UP:"
-	   << fixed << setprecision(2) << stat.getUploadSpeed()/1024.0 << "KiB/s"
-	   << "(" << Util::abbrevSize(stat.getAllTimeUploadLength()) << "B)";
+      std::cout << " "
+		<< "UP:"
+		<< std::fixed << std::setprecision(2) << stat.getUploadSpeed()/1024.0 << "KiB/s"
+		<< "(" << Util::abbrevSize(stat.getAllTimeUploadLength()) << "B)";
     }
     if(eta > 0) {
-      cout << " "
-	   << "ETA:"
-	   << Util::secfmt(eta);
+      std::cout << " "
+		<< "ETA:"
+		<< Util::secfmt(eta);
     }
-    cout << "]";
+    std::cout << "]";
     if(requestGroupMan->countRequestGroup() > 1) {
-      cout << "("
-	   << requestGroupMan->countRequestGroup()-1
-	   << "more...)";
+      std::cout << "("
+		<< requestGroupMan->countRequestGroup()-1
+		<< "more...)";
     }
   }
 
   if(requestGroupMan->countRequestGroup() > 1 &&
      !requestGroupMan->downloadFinished()) {
     TransferStat stat = requestGroupMan->calculateStat();
-    cout << " "
-	 << "[TOTAL SPD:"
-	 << fixed << setprecision(2) << stat.getDownloadSpeed()/1024.0 << "KiB/s" << "]";
+    std::cout << " "
+	      << "[TOTAL SPD:"
+	      << std::fixed << std::setprecision(2) << stat.getDownloadSpeed()/1024.0 << "KiB/s" << "]";
   }
 
   {
     FileAllocationEntryHandle entry = fileAllocationMan->getCurrentFileAllocationEntry();
     if(!entry.isNull()) {
-      cout << " "
-	   << "[FileAlloc:"
-	   << "#" << entry->getRequestGroup()->getGID() << " "
-	   << Util::abbrevSize(entry->getCurrentLength())
-	   << "B"
-	   << "/"
-	   << Util::abbrevSize(entry->getTotalLength())
-	   << "B"
-	   << "(";
+      std::cout << " "
+		<< "[FileAlloc:"
+		<< "#" << entry->getRequestGroup()->getGID() << " "
+		<< Util::abbrevSize(entry->getCurrentLength())
+		<< "B"
+		<< "/"
+		<< Util::abbrevSize(entry->getTotalLength())
+		<< "B"
+		<< "(";
       if(entry->getTotalLength() > 0) {
-	cout << 100*entry->getCurrentLength()/entry->getTotalLength();
+	std::cout << 100*entry->getCurrentLength()/entry->getTotalLength();
       } else {
-	cout << "--";
+	std::cout << "--";
       }
-      cout << "%)"
-	   << "]";
+      std::cout << "%)"
+		<< "]";
       if(fileAllocationMan->countFileAllocationEntryInQueue() > 0) {
-	cout << "("
-	     << fileAllocationMan->countFileAllocationEntryInQueue()
-	     << "waiting...)";
+	std::cout << "("
+		  << fileAllocationMan->countFileAllocationEntryInQueue()
+		  << "waiting...)";
       }
     }
   }
@@ -154,25 +157,27 @@ ConsoleStatCalc::calculateStat(const RequestGroupManHandle& requestGroupMan,
   {
     CheckIntegrityEntryHandle entry = checkIntegrityMan->getFirstCheckIntegrityEntry();
     if(!entry.isNull()) {
-      cout << " "
-	   << "[Checksum:"
-	   << "#" << entry->getRequestGroup()->getGID() << " "
-	   << Util::abbrevSize(entry->getCurrentLength())
-	   << "B"
-	   << "/"
-	   << Util::abbrevSize(entry->getTotalLength())
-	   << "B"
-	   << "("
-	   << 100*entry->getCurrentLength()/entry->getTotalLength()
-	   << "%)";
-      cout << "]";
+      std::cout << " "
+		<< "[Checksum:"
+		<< "#" << entry->getRequestGroup()->getGID() << " "
+		<< Util::abbrevSize(entry->getCurrentLength())
+		<< "B"
+		<< "/"
+		<< Util::abbrevSize(entry->getTotalLength())
+		<< "B"
+		<< "("
+		<< 100*entry->getCurrentLength()/entry->getTotalLength()
+		<< "%)";
+      std::cout << "]";
       if(checkIntegrityMan->countCheckIntegrityEntry() > 1) {
-	cout << "("
-	     << checkIntegrityMan->countCheckIntegrityEntry()-1
-	     << "more...)";
+	std::cout << "("
+		  << checkIntegrityMan->countCheckIntegrityEntry()-1
+		  << "more...)";
       }
     }
   }
 #endif // ENABLE_MESSAGE_DIGEST
-  cout << flush;
+  std::cout << std::flush;
 }
+
+} // namespace aria2
diff --git a/src/ConsoleStatCalc.h b/src/ConsoleStatCalc.h
index f221509b..c7f2f37f 100644
--- a/src/ConsoleStatCalc.h
+++ b/src/ConsoleStatCalc.h
@@ -38,6 +38,8 @@
 #include "StatCalc.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class ConsoleStatCalc:public StatCalc
 {
 private:
@@ -45,11 +47,14 @@ private:
 public:
   virtual ~ConsoleStatCalc() {}
 
-  virtual void calculateStat(const RequestGroupManHandle& requestGroupMan,
-			     const FileAllocationManHandle& fileAllocationMan,
-			     const CheckIntegrityManHandle& checkIntegrityMan);
+  virtual void
+  calculateStat(const SharedHandle<RequestGroupMan>& requestGroupMan,
+		const SharedHandle<FileAllocationMan>& fileAllocationMan,
+		const SharedHandle<CheckIntegrityMan>& checkIntegrityMan);
 };
 
 typedef SharedHandle<ConsoleStatCalc> ConsoleStatCalcHandle;
 
+} // namespace aria2
+
 #endif // _D_CONSOLE_STAT_CALC_H_
diff --git a/src/ContentTypeRequestGroupCriteria.cc b/src/ContentTypeRequestGroupCriteria.cc
index 54291f0f..9fa53d6b 100644
--- a/src/ContentTypeRequestGroupCriteria.cc
+++ b/src/ContentTypeRequestGroupCriteria.cc
@@ -36,9 +36,12 @@
 #include "RequestGroup.h"
 #include "SingleFileDownloadContext.h"
 #include "Util.h"
+#include "FileEntry.h"
 
-ContentTypeRequestGroupCriteria::ContentTypeRequestGroupCriteria(const Strings& contentTypes,
-								 const Strings& extensions):
+namespace aria2 {
+
+ContentTypeRequestGroupCriteria::ContentTypeRequestGroupCriteria(const std::deque<std::string>& contentTypes,
+								 const std::deque<std::string>& extensions):
   _contentTypes(contentTypes),
   _extensions(extensions) {}
 
@@ -58,9 +61,9 @@ bool ContentTypeRequestGroupCriteria::match(const RequestGroup* requestGroup) co
   }
 }
 
-bool ContentTypeRequestGroupCriteria::forwardMatch(const string& target, const Strings& candidates) const
+bool ContentTypeRequestGroupCriteria::forwardMatch(const std::string& target, const std::deque<std::string>& candidates) const
 {
-  for(Strings::const_iterator itr = candidates.begin(); itr != candidates.end(); ++itr) {
+  for(std::deque<std::string>::const_iterator itr = candidates.begin(); itr != candidates.end(); ++itr) {
     if(Util::endsWith(target, *itr)) {
       return true;
     }
@@ -68,12 +71,14 @@ bool ContentTypeRequestGroupCriteria::forwardMatch(const string& target, const S
   return false;
 }
 
-bool ContentTypeRequestGroupCriteria::exactMatch(const string& target, const Strings& candidates) const
+bool ContentTypeRequestGroupCriteria::exactMatch(const std::string& target, const std::deque<std::string>& candidates) const
 {
-  for(Strings::const_iterator itr = candidates.begin(); itr != candidates.end(); ++itr) {
+  for(std::deque<std::string>::const_iterator itr = candidates.begin(); itr != candidates.end(); ++itr) {
     if(target == *itr) {
       return true;
     }
   }
   return false;
 }
+
+} // namespace aria2
diff --git a/src/ContentTypeRequestGroupCriteria.h b/src/ContentTypeRequestGroupCriteria.h
index 5c348d0f..f1775d9a 100644
--- a/src/ContentTypeRequestGroupCriteria.h
+++ b/src/ContentTypeRequestGroupCriteria.h
@@ -36,24 +36,30 @@
 #define _D_CONTENT_TYPE_REQUEST_GROUP_CRITERIA_H_
 
 #include "RequestGroupCriteria.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class ContentTypeRequestGroupCriteria:public RequestGroupCriteria
 {
 private:
-  Strings _contentTypes;
-  Strings _extensions;
+  std::deque<std::string> _contentTypes;
+  std::deque<std::string> _extensions;
 
-  bool forwardMatch(const string& target, const Strings& candidates) const;
+  bool forwardMatch(const std::string& target, const std::deque<std::string>& candidates) const;
 
-  bool exactMatch(const string& target, const Strings& candidates) const;
+  bool exactMatch(const std::string& target, const std::deque<std::string>& candidates) const;
 
 public:
-  ContentTypeRequestGroupCriteria(const Strings& contentTypes,
-				  const Strings& extensions);
+  ContentTypeRequestGroupCriteria(const std::deque<std::string>& contentTypes,
+				  const std::deque<std::string>& extensions);
 
   virtual ~ContentTypeRequestGroupCriteria();
 
   virtual bool match(const RequestGroup* requestGroup) const;
 };
 
+} // namespace aria2
+
 #endif // _D_CONTENT_TYPE_REQUEST_GROUP_CRITERIA_H_
diff --git a/src/Cookie.cc b/src/Cookie.cc
index 951648af..830d6faf 100644
--- a/src/Cookie.cc
+++ b/src/Cookie.cc
@@ -35,7 +35,56 @@
 #include "Cookie.h"
 #include "Util.h"
 
-bool Cookie::match(const string& host, const string& dir, time_t date, bool secure) const
+namespace aria2 {
+
+Cookie::Cookie(const std::string& name,
+	       const std::string& value,
+	       time_t  expires,
+	       const std::string& path,
+	       const std::string& domain,
+	       bool secure):
+  name(name),
+  value(value),
+  expires(expires),
+  path(path),
+  domain(domain),
+  secure(secure),
+  onetime(false) {}
+
+Cookie::Cookie(const std::string& name,
+	       const std::string& value,
+	       const std::string& path,
+	       const std::string& domain,
+	       bool secure):
+  name(name),
+  value(value),
+  path(path),
+  domain(domain),
+  secure(secure),
+  onetime(true) {}
+
+Cookie::Cookie():expires(0), secure(false), onetime(true) {}
+
+Cookie::~Cookie() {}
+
+std::string Cookie::toString() const
+{
+  return name+"="+value;
+}
+
+void Cookie::clear()
+{
+  name = value = path = domain = "";
+  expires = 0;
+  secure = false;
+}
+
+bool Cookie::good() const
+{
+  return !name.empty();
+}
+
+bool Cookie::match(const std::string& host, const std::string& dir, time_t date, bool secure) const
 {
   if((secure || !this->secure && !secure) &&
      Util::endsWith("."+host, this->domain) &&
@@ -46,3 +95,5 @@ bool Cookie::match(const string& host, const string& dir, time_t date, bool secu
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/Cookie.h b/src/Cookie.h
index f33d048b..a4529749 100644
--- a/src/Cookie.h
+++ b/src/Cookie.h
@@ -36,63 +36,50 @@
 #define _D_COOKIE_H_
 
 #include "common.h"
+#include "a2time.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class Cookie {
 public:
-  string name;
-  string value;
+  std::string name;
+  std::string value;
   time_t expires;
-  string path;
-  string domain;
+  std::string path;
+  std::string domain;
   bool secure;
   bool onetime; // if true, this cookie will expire when the user's session ends.
 public:
-  Cookie(const string& name,
-	 const string& value,
+  Cookie(const std::string& name,
+	 const std::string& value,
 	 time_t  expires,
-	 const string& path,
-	 const string& domain,
-	 bool secure):
-    name(name),
-    value(value),
-    expires(expires),
-    path(path),
-    domain(domain),
-    secure(secure),
-    onetime(false) {}
+	 const std::string& path,
+	 const std::string& domain,
+	 bool secure);
 
-  Cookie(const string& name,
-	 const string& value,
-	 const string& path,
-	 const string& domain,
-	 bool secure):
-    name(name),
-    value(value),
-    path(path),
-    domain(domain),
-    secure(secure),
-    onetime(true) {}
+  Cookie(const std::string& name,
+	 const std::string& value,
+	 const std::string& path,
+	 const std::string& domain,
+	 bool secure);
 
-  Cookie():expires(0), secure(false), onetime(true) {}
+  Cookie();
 
-  ~Cookie() {}
-  string toString() const {
-    return name+"="+value;
-  }
-  void clear() {
-    name = value = path = domain = "";
-    expires = 0;
-    secure = false;
-  }
+  ~Cookie();
 
-  bool good() const
-  {
-    return !name.empty();
-  }
+  std::string toString() const;
 
-  bool match(const string& host, const string& dir, time_t date, bool secure) const;
+  void clear();
+
+  bool good() const;
+
+  bool match(const std::string& host, const std::string& dir, time_t date, bool secure) const;
 };
 
-typedef deque<Cookie> Cookies;
+typedef std::deque<Cookie> Cookies;
+
+} // namespace aria2
 
 #endif // _D_COOKIE_H_
diff --git a/src/CookieBox.cc b/src/CookieBox.cc
index 80869079..0dbb674b 100644
--- a/src/CookieBox.cc
+++ b/src/CookieBox.cc
@@ -33,9 +33,10 @@
  */
 /* copyright --> */
 #include "CookieBox.h"
-#include "Util.h"
 #include "CookieParser.h"
 
+namespace aria2 {
+
 CookieBox::CookieBox() {}
 
 CookieBox::~CookieBox() {}
@@ -44,7 +45,7 @@ void CookieBox::add(const Cookie& cookie) {
   cookies.push_back(cookie);
 }
 
-void CookieBox::add(const string& cookieStr, const string& defaultDomain, const string& defaultPath)
+void CookieBox::add(const std::string& cookieStr, const std::string& defaultDomain, const std::string& defaultPath)
 {
   Cookie c = CookieParser().parse(cookieStr, defaultDomain, defaultPath);
   if(c.good()) {
@@ -57,7 +58,7 @@ void CookieBox::add(const Cookies& cookies)
   this->cookies.insert(this->cookies.end(), cookies.begin(), cookies.end());
 }
 
-Cookies CookieBox::criteriaFind(const string& host, const string& dir, time_t date,  bool secure) const {
+Cookies CookieBox::criteriaFind(const std::string& host, const std::string& dir, time_t date,  bool secure) const {
   Cookies result;
   for(Cookies::const_iterator itr = cookies.begin(); itr != cookies.end(); itr++) {
     const Cookie& c = *itr;
@@ -68,3 +69,4 @@ Cookies CookieBox::criteriaFind(const string& host, const string& dir, time_t da
   return result;
 }
 
+} // namespace aria2
diff --git a/src/CookieBox.h b/src/CookieBox.h
index 288dc662..ab36eff3 100644
--- a/src/CookieBox.h
+++ b/src/CookieBox.h
@@ -36,8 +36,11 @@
 #define _D_COOKIE_BOX_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "Cookie.h"
 
+namespace aria2 {
+
 class CookieBox {
 private:
   Cookies cookies;
@@ -46,12 +49,14 @@ public:
   ~CookieBox();
   void clear();
   void add(const Cookie& cookie);
-  void add(const string& cookieStr,
-	   const string& defaultDomain, const string& defaultPath);
+  void add(const std::string& cookieStr,
+	   const std::string& defaultDomain, const std::string& defaultPath);
   void add(const Cookies& cookies);
-  Cookies criteriaFind(const string& host, const string& dir, time_t date, bool secure) const;
+  Cookies criteriaFind(const std::string& host, const std::string& dir, time_t date, bool secure) const;
 };
 
 typedef SharedHandle<CookieBox> CookieBoxHandle;
 
+} // namespace aria2
+
 #endif // _D_COOKIE_BOX_H_
diff --git a/src/CookieBoxFactory.cc b/src/CookieBoxFactory.cc
index 6197a349..d03051d4 100644
--- a/src/CookieBoxFactory.cc
+++ b/src/CookieBoxFactory.cc
@@ -34,8 +34,12 @@
 /* copyright --> */
 #include "CookieBoxFactory.h"
 #include "CookieParser.h"
+#include "CookieBox.h"
 #include "Util.h"
 #include "RecoverableException.h"
+#include <istream>
+
+namespace aria2 {
 
 CookieBoxHandle CookieBoxFactory::createNewInstance()
 {
@@ -44,9 +48,9 @@ CookieBoxHandle CookieBoxFactory::createNewInstance()
   return box;
 }
 
-void CookieBoxFactory::loadDefaultCookie(istream& s)
+void CookieBoxFactory::loadDefaultCookie(std::istream& s)
 {
-  string line;
+  std::string line;
   while(getline(s, line)) {
     if(Util::startsWith(line, "#")) {
       continue;
@@ -64,9 +68,9 @@ void CookieBoxFactory::loadDefaultCookie(istream& s)
   }
 }
 
-Cookie CookieBoxFactory::parseNsCookie(const string& nsCookieStr) const
+Cookie CookieBoxFactory::parseNsCookie(const std::string& nsCookieStr) const
 {
-  Strings vs;
+  std::deque<std::string> vs;
   Util::slice(vs, nsCookieStr, '\t', true);
   Cookie c;
   if(vs.size() < 6 ) {
@@ -87,3 +91,5 @@ Cookie CookieBoxFactory::parseNsCookie(const string& nsCookieStr) const
   }
   return c;
 }
+
+} // namespace aria2
diff --git a/src/CookieBoxFactory.h b/src/CookieBoxFactory.h
index c60f83c7..ea7aa149 100644
--- a/src/CookieBoxFactory.h
+++ b/src/CookieBoxFactory.h
@@ -36,8 +36,15 @@
 #define _D_COOKIE_BOX_FACTORY_H_
 
 #include "common.h"
-#include "CookieBox.h"
-#include <istream>
+#include "SharedHandle.h"
+#include "Cookie.h"
+#include "SingletonHolder.h"
+#include <string>
+#include <iosfwd>
+
+namespace aria2 {
+
+class CookieBox;
 
 class CookieBoxFactory {
 private:
@@ -48,11 +55,11 @@ public:
 
   ~CookieBoxFactory() {}
 
-  CookieBoxHandle createNewInstance();
+  SharedHandle<CookieBox> createNewInstance();
 
-  void loadDefaultCookie(istream& s);
+  void loadDefaultCookie(std::istream& s);
 
-  Cookie parseNsCookie(const string& nsCookieStr) const;
+  Cookie parseNsCookie(const std::string& nsCookieStr) const;
 
   const Cookies& getDefaultCookies() const
   {
@@ -63,4 +70,6 @@ public:
 typedef SharedHandle<CookieBoxFactory> CookieBoxFactoryHandle;
 typedef SingletonHolder<CookieBoxFactoryHandle> CookieBoxFactorySingletonHolder;
 
+} // namespace aria2
+
 #endif // _D_COOKIE_BOX_FACTORY_H_
diff --git a/src/CookieParser.cc b/src/CookieParser.cc
index 0c2628d5..950a381f 100644
--- a/src/CookieParser.cc
+++ b/src/CookieParser.cc
@@ -34,17 +34,21 @@
 /* copyright --> */
 #include "CookieParser.h"
 #include "Util.h"
+#include <utility>
+#include <istream>
 
-void CookieParser::setField(Cookie& cookie, const string& name, const string& value) const
+namespace aria2 {
+
+void CookieParser::setField(Cookie& cookie, const std::string& name, const std::string& value) const
 {
-  if(name.size() == string("secure").size() &&
+  if(name.size() == std::string("secure").size() &&
      strcasecmp(name.c_str(), "secure") == 0) {
     cookie.secure = true;
-  } else if(name.size() == string("domain").size() && strcasecmp(name.c_str(), "domain") == 0) {
+  } else if(name.size() == std::string("domain").size() && strcasecmp(name.c_str(), "domain") == 0) {
     cookie.domain = value;
-  } else if(name.size() == string("path").size() && strcasecmp(name.c_str(), "path") == 0) {
+  } else if(name.size() == std::string("path").size() && strcasecmp(name.c_str(), "path") == 0) {
     cookie.path = value;
-  } else if(name.size() == string("expires").size() && strcasecmp(name.c_str(), "expires") == 0) {
+  } else if(name.size() == std::string("expires").size() && strcasecmp(name.c_str(), "expires") == 0) {
     cookie.expires = Util::httpGMT(value);
     cookie.onetime = false;
   } else {
@@ -53,20 +57,20 @@ void CookieParser::setField(Cookie& cookie, const string& name, const string& va
   }
 }
 
-Cookie CookieParser::parse(const string& cookieStr) const
+Cookie CookieParser::parse(const std::string& cookieStr) const
 {
   return parse(cookieStr, "", "");
 }
 
-Cookie CookieParser::parse(const string& cookieStr, const string& defaultDomain, const string& defaultPath) const
+Cookie CookieParser::parse(const std::string& cookieStr, const std::string& defaultDomain, const std::string& defaultPath) const
 {
   Cookie cookie;
   cookie.domain = defaultDomain;
   cookie.path = defaultPath;
-  Strings terms;
+  std::deque<std::string> terms;
   Util::slice(terms, Util::trim(cookieStr), ';', true);
-  for(Strings::iterator itr = terms.begin(); itr != terms.end(); itr++) {
-    pair<string, string> nv;
+  for(std::deque<std::string>::iterator itr = terms.begin(); itr != terms.end(); itr++) {
+    std::pair<std::string, std::string> nv;
     Util::split(nv, *itr, '=');
     setField(cookie, nv.first, nv.second);
   }
@@ -74,10 +78,10 @@ Cookie CookieParser::parse(const string& cookieStr, const string& defaultDomain,
 }
 
 
-Cookies CookieParser::parse(istream& s) const
+Cookies CookieParser::parse(std::istream& s) const
 {
   Cookies cookies;
-  string line;
+  std::string line;
   while(getline(s, line)) {
     if(Util::trim(line) == "" || Util::startsWith(line, "#")) {
       continue;
@@ -90,3 +94,4 @@ Cookies CookieParser::parse(istream& s) const
   return cookies;
 }
 
+} // namespace aria2
diff --git a/src/CookieParser.h b/src/CookieParser.h
index 43ba2812..42371d85 100644
--- a/src/CookieParser.h
+++ b/src/CookieParser.h
@@ -36,24 +36,30 @@
 #define _D_COOKIE_PARSER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "Cookie.h"
-#include <istream>
+#include <string>
+#include <iosfwd>
+
+namespace aria2 {
 
 class CookieParser {
 private:
-  void setField(Cookie& cookie, const string& name, const string& value) const;
+  void setField(Cookie& cookie, const std::string& name, const std::string& value) const;
 public:
   CookieParser() {}
 
   ~CookieParser() {}
 
-  Cookie parse(const string& cookieStr, const string& defaultDomain, const string& defaultPath) const;
+  Cookie parse(const std::string& cookieStr, const std::string& defaultDomain, const std::string& defaultPath) const;
 
-  Cookie parse(const string& cookieStr) const;
+  Cookie parse(const std::string& cookieStr) const;
 
-  Cookies parse(istream& s) const;
+  Cookies parse(std::istream& s) const;
 };
 
 typedef SharedHandle<CookieParser> CookieParserHandle;
 
+} // namespace aria2
+
 #endif // _D_COOKIE_PARSER_H_
diff --git a/src/CopyDiskAdaptor.cc b/src/CopyDiskAdaptor.cc
index 462ef713..1dcd3940 100644
--- a/src/CopyDiskAdaptor.cc
+++ b/src/CopyDiskAdaptor.cc
@@ -33,9 +33,13 @@
  */
 /* copyright --> */
 #include "CopyDiskAdaptor.h"
+#include "FileEntry.h"
+#include "Logger.h"
 #include "Util.h"
 #include "message.h"
 
+namespace aria2 {
+
 void CopyDiskAdaptor::onDownloadComplete()
 {
   closeFile();
@@ -49,9 +53,9 @@ void CopyDiskAdaptor::fixFilename()
   for(FileEntries::iterator itr = fileEntries.begin();
       itr != fileEntries.end(); itr++) {
     if(!(*itr)->isExtracted() && (*itr)->isRequested()) {
-      string topDirPath = storeDir+"/"+topDir;
+      std::string topDirPath = storeDir+"/"+topDir;
       (*itr)->setupDir(topDirPath);
-      string destFilePath = topDirPath+"/"+(*itr)->getPath();
+      std::string destFilePath = topDirPath+"/"+(*itr)->getPath();
       logger->info(MSG_WRITING_FILE, destFilePath.c_str());
       Util::rangedFileCopy(destFilePath, getFilePath(),
 			   offset, (*itr)->getLength());
@@ -61,7 +65,9 @@ void CopyDiskAdaptor::fixFilename()
   }
 }
 
-string CopyDiskAdaptor::getFilePath()
+std::string CopyDiskAdaptor::getFilePath()
 {
   return storeDir+"/"+tempFilename;
 }
+
+} // namespace aria2
diff --git a/src/CopyDiskAdaptor.h b/src/CopyDiskAdaptor.h
index af6effdf..80d3f130 100644
--- a/src/CopyDiskAdaptor.h
+++ b/src/CopyDiskAdaptor.h
@@ -37,10 +37,12 @@
 
 #include "AbstractSingleDiskAdaptor.h"
 
+namespace aria2 {
+
 class CopyDiskAdaptor : public AbstractSingleDiskAdaptor {
 private:
-  string tempFilename;
-  string topDir;
+  std::string tempFilename;
+  std::string topDir;
 
   void fixFilename();
 public:
@@ -48,26 +50,28 @@ public:
 
   virtual ~CopyDiskAdaptor() {}
 
-  virtual string getFilePath();
+  virtual std::string getFilePath();
 
   virtual void onDownloadComplete();
 
   // tempFilename is relative to storeDir
-  void setTempFilename(const string& tempFilename) {
+  void setTempFilename(const std::string& tempFilename) {
     this->tempFilename = tempFilename;
   }
 
-  const string& getTempFile() const { return this->tempFilename; }
+  const std::string& getTempFile() const { return this->tempFilename; }
 
-  void setTopDir(const string& topDir) {
+  void setTopDir(const std::string& topDir) {
     this->topDir = topDir;
   }
 
-  const string& getTopDir() const {
+  const std::string& getTopDir() const {
     return topDir;
   }
 };
 
 typedef SharedHandle<CopyDiskAdaptor> CopyDiskAdaptorHandle;
 
+} // namespace aria2
+
 #endif // _D_COPY_DISK_ADAPTOR_H_
diff --git a/src/DHTAbstractMessage.cc b/src/DHTAbstractMessage.cc
index 6e3d585c..b068e696 100644
--- a/src/DHTAbstractMessage.cc
+++ b/src/DHTAbstractMessage.cc
@@ -36,23 +36,26 @@
 #include "DHTNode.h"
 #include "BencodeVisitor.h"
 #include "DHTConnection.h"
+#include "Dictionary.h"
 #include "Data.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageFactory.h"
 #include "DHTRoutingTable.h"
 
-DHTAbstractMessage::DHTAbstractMessage(const DHTNodeHandle& localNode,
-				       const DHTNodeHandle& remoteNode,
-				       const string& transactionID):
+namespace aria2 {
+
+DHTAbstractMessage::DHTAbstractMessage(const SharedHandle<DHTNode>& localNode,
+				       const SharedHandle<DHTNode>& remoteNode,
+				       const std::string& transactionID):
   DHTMessage(localNode, remoteNode, transactionID) {}
 
 DHTAbstractMessage::~DHTAbstractMessage() {}
 
-string DHTAbstractMessage::getBencodedMessage()
+std::string DHTAbstractMessage::getBencodedMessage()
 {
   SharedHandle<Dictionary> msg = new Dictionary();
-  msg->put(string("t"), new Data(_transactionID));
-  msg->put(string("y"), new Data(getType()));
+  msg->put(std::string("t"), new Data(_transactionID));
+  msg->put(std::string("y"), new Data(getType()));
   fillMessage(msg.get());
   
   BencodeVisitor v;
@@ -62,7 +65,7 @@ string DHTAbstractMessage::getBencodedMessage()
 
 void DHTAbstractMessage::send()
 {
-  string message = getBencodedMessage();
+  std::string message = getBencodedMessage();
   _connection->sendMessage(message.c_str(),
 			   message.size(),
 			   _remoteNode->getIPAddress(),
@@ -88,3 +91,5 @@ void DHTAbstractMessage::setRoutingTable(const WeakHandle<DHTRoutingTable>& rout
 {
   _routingTable = routingTable;
 }
+
+} // namespace aria2
diff --git a/src/DHTAbstractMessage.h b/src/DHTAbstractMessage.h
index 42d658b3..cdef0738 100644
--- a/src/DHTAbstractMessage.h
+++ b/src/DHTAbstractMessage.h
@@ -36,11 +36,14 @@
 #define _D_DHT_ABSTRACT_MESSAGE_H_
 
 #include "DHTMessage.h"
-#include "Dictionary.h"
-#include "DHTConnectionDecl.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageFactoryDecl.h"
-#include "DHTRoutingTableDecl.h"
+
+namespace aria2 {
+
+class Dictionary;
+class DHTConnection;
+class DHTMessageDispatcher;
+class DHTMessageFactory;
+class DHTRoutingTable;
 
 class DHTAbstractMessage:public DHTMessage {
 protected:
@@ -52,19 +55,19 @@ protected:
 
   WeakHandle<DHTRoutingTable> _routingTable;
 public:
-  DHTAbstractMessage(const DHTNodeHandle& localNode,
-		     const DHTNodeHandle& remoteNode,
-		     const string& transactionID = "");
+  DHTAbstractMessage(const SharedHandle<DHTNode>& localNode,
+		     const SharedHandle<DHTNode>& remoteNode,
+		     const std::string& transactionID = "");
 
   virtual ~DHTAbstractMessage();
 
   virtual void send();
 
-  virtual string getType() const = 0;
+  virtual std::string getType() const = 0;
 
   virtual void fillMessage(Dictionary* message) = 0;
 
-  string getBencodedMessage();
+  std::string getBencodedMessage();
 
   void setConnection(const WeakHandle<DHTConnection>& connection);
 
@@ -75,4 +78,6 @@ public:
   void setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ABSTRACT_MESSAGE_H_
diff --git a/src/DHTAbstractNodeLookupTask.cc b/src/DHTAbstractNodeLookupTask.cc
index 9bc8ddf8..598c68a4 100644
--- a/src/DHTAbstractNodeLookupTask.cc
+++ b/src/DHTAbstractNodeLookupTask.cc
@@ -42,8 +42,13 @@
 #include "DHTMessageCallbackImpl.h"
 #include "DHTBucket.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
 #include "DHTIDCloser.h"
+#include <cstring>
+#include <algorithm>
+
+namespace aria2 {
 
 DHTAbstractNodeLookupTask::DHTAbstractNodeLookupTask(const unsigned char* targetID):
   _inFlightMessage(0)
@@ -51,13 +56,13 @@ DHTAbstractNodeLookupTask::DHTAbstractNodeLookupTask(const unsigned char* target
   memcpy(_targetID, targetID, DHT_ID_LENGTH);
 }
 
-void DHTAbstractNodeLookupTask::onReceived(const DHTMessageHandle& message)
+void DHTAbstractNodeLookupTask::onReceived(const SharedHandle<DHTMessage>& message)
 {
   --_inFlightMessage;
   onReceivedInternal(message);
-  DHTNodeLookupEntries newEntries = toEntries(getNodesFromMessage(message));
+  std::deque<SharedHandle<DHTNodeLookupEntry> > newEntries = toEntries(getNodesFromMessage(message));
   size_t count = 0;
-  for(DHTNodeLookupEntries::const_iterator i = newEntries.begin();
+  for(std::deque<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);
@@ -65,8 +70,8 @@ void DHTAbstractNodeLookupTask::onReceived(const DHTMessageHandle& message)
     }
   }
   _logger->debug("%u node lookup entries added.", count);
-  stable_sort(_entries.begin(), _entries.end(), DHTIDCloser(_targetID));
-  _entries.erase(unique(_entries.begin(), _entries.end()), _entries.end());
+  std::stable_sort(_entries.begin(), _entries.end(), DHTIDCloser(_targetID));
+  _entries.erase(std::unique(_entries.begin(), _entries.end()), _entries.end());
   _logger->debug("%u node lookup entries are unique.", _entries.size());
   if(_entries.size() > DHTBucket::K) {
     _entries.erase(_entries.begin()+DHTBucket::K, _entries.end());
@@ -83,12 +88,12 @@ void DHTAbstractNodeLookupTask::onReceived(const DHTMessageHandle& message)
   }
 }
 
-void DHTAbstractNodeLookupTask::onTimeout(const DHTNodeHandle& node)
+void DHTAbstractNodeLookupTask::onTimeout(const SharedHandle<DHTNode>& node)
 {
   _logger->debug("node lookup message timeout for node ID=%s",
 		 Util::toHex(node->getID(), DHT_ID_LENGTH).c_str());
   --_inFlightMessage;
-  for(DHTNodeLookupEntries::iterator i = _entries.begin(); i != _entries.end(); ++i) {
+  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = _entries.begin(); i != _entries.end(); ++i) {
     if((*i)->_node == node) {
       _entries.erase(i);
       break;
@@ -108,11 +113,11 @@ void DHTAbstractNodeLookupTask::onTimeout(const DHTNodeHandle& node)
 
 void DHTAbstractNodeLookupTask::sendMessage()
 {
-  for(DHTNodeLookupEntries::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;
-      DHTMessageHandle m = createMessage((*i)->_node);
+      SharedHandle<DHTMessage> m = createMessage((*i)->_node);
       _dispatcher->addMessageToQueue(m, new DHTMessageCallbackImpl(this));
     }
   }
@@ -139,12 +144,15 @@ void DHTAbstractNodeLookupTask::startup()
   }
 }
 
-DHTNodeLookupEntries DHTAbstractNodeLookupTask::toEntries(const DHTNodes& nodes) const
+std::deque<SharedHandle<DHTNodeLookupEntry> >
+DHTAbstractNodeLookupTask::toEntries(const std::deque<SharedHandle<DHTNode> >& nodes) const
 {
-  DHTNodeLookupEntries entries;
-  for(DHTNodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
-    DHTNodeLookupEntryHandle e = new DHTNodeLookupEntry(*i);
+  std::deque<SharedHandle<DHTNodeLookupEntry> > entries;
+  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
+    SharedHandle<DHTNodeLookupEntry> e = new DHTNodeLookupEntry(*i);
     entries.push_back(e);
   }
   return entries;
 }
+
+} // namespace aria2
diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h
index 28255a43..694747b1 100644
--- a/src/DHTAbstractNodeLookupTask.h
+++ b/src/DHTAbstractNodeLookupTask.h
@@ -36,22 +36,26 @@
 #define _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_
 
 #include "DHTAbstractTask.h"
-#include "DHTNodeDecl.h"
-#include "DHTNodeLookupEntryDecl.h"
-#include "DHTConstants.h"
-#include "DHTTask.h"
-#include "DHTMessageDecl.h"
 #include "DHTMessageCallbackListener.h"
+#include "DHTConstants.h"
+#include <deque>
+
+namespace aria2 {
+
+class DHTNode;
+class DHTNodeLookupEntry;
+class DHTMessage;
 
 class DHTAbstractNodeLookupTask:public DHTAbstractTask, public DHTMessageCallbackListener {
 protected:
   unsigned char _targetID[DHT_ID_LENGTH];
 
-  DHTNodeLookupEntries _entries;
+  std::deque<SharedHandle<DHTNodeLookupEntry> > _entries;
   
   size_t _inFlightMessage;
 
-  DHTNodeLookupEntries toEntries(const DHTNodes& nodes) const;
+  std::deque<SharedHandle<DHTNodeLookupEntry> >
+  toEntries(const std::deque<SharedHandle<DHTNode> >& nodes) const;
 
   void sendMessage();
 
@@ -64,19 +68,21 @@ public:
 
   virtual void startup();
 
-  virtual void onReceived(const DHTMessageHandle& message);
+  virtual void onReceived(const SharedHandle<DHTMessage>& message);
 
-  virtual void onTimeout(const DHTNodeHandle& node);
+  virtual void onTimeout(const SharedHandle<DHTNode>& node);
 
-  virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message) = 0;
+  virtual std::deque<SharedHandle<DHTNode> > getNodesFromMessage(const SharedHandle<DHTMessage>& message) = 0;
   
-  virtual void onReceivedInternal(const DHTMessageHandle& message) {}
+  virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message) {}
   
   virtual bool needsAdditionalOutgoingMessage() { return true; }
   
   virtual void onFinish() {}
 
-  virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode) = 0;
+  virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_
diff --git a/src/DHTAbstractTask.cc b/src/DHTAbstractTask.cc
index e43e554f..82866556 100644
--- a/src/DHTAbstractTask.cc
+++ b/src/DHTAbstractTask.cc
@@ -44,6 +44,8 @@
 #include "LogFactory.h"
 #include "Util.h"
 
+namespace aria2 {
+
 DHTAbstractTask::DHTAbstractTask():
   _finished(false),
   _logger(LogFactory::getInstance()),
@@ -75,7 +77,9 @@ void DHTAbstractTask::setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue)
   _taskQueue = taskQueue;
 }
 
-void DHTAbstractTask::setLocalNode(const DHTNodeHandle& localNode)
+void DHTAbstractTask::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
+
+} // namespace aria2
diff --git a/src/DHTAbstractTask.h b/src/DHTAbstractTask.h
index 0efdcc8e..c0016a8e 100644
--- a/src/DHTAbstractTask.h
+++ b/src/DHTAbstractTask.h
@@ -35,16 +35,18 @@
 #ifndef _D_DHT_ABSTRACT_TASK_H_
 #define _D_DHT_ABSTRACT_TASK_H_
 
-#include "common.h"
-#include "DHTAbstractTaskDecl.h"
-#include "DHTNodeDecl.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageFactoryDecl.h"
-#include "DHTConstants.h"
 #include "DHTTask.h"
-#include "DHTMessageDecl.h"
-#include "DHTTaskQueueDecl.h"
+#include "SharedHandle.h"
+#include "DHTConstants.h"
+
+namespace aria2 {
+
+class DHTNode;
+class DHTRoutingTable;
+class DHTMessageDispatcher;
+class DHTMessageFactory;
+class DHTMessage;
+class DHTTaskQueue;
 
 class Logger;
 
@@ -54,7 +56,7 @@ protected:
   
   const Logger* _logger;
   
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
   WeakHandle<DHTRoutingTable> _routingTable;
 
@@ -76,7 +78,9 @@ public:
 
   void setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue);
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ABSTRACT_TASK_H_
diff --git a/src/DHTAbstractTaskDecl.h b/src/DHTAbstractTaskDecl.h
deleted file mode 100644
index f68bf702..00000000
--- a/src/DHTAbstractTaskDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_ABSTRACT_TASK_DECL_H_
-#define _D_DHT_ABSTRACT_TASK_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTAbstractTask;
-typedef SharedHandle<DHTAbstractTask> DHTAbstractTaskHandle;
-
-#endif // _D_DHT_ABSTRACT_TASK_DECL_H_
diff --git a/src/DHTAnnouncePeerMessage.cc b/src/DHTAnnouncePeerMessage.cc
index 414511e7..b8c321cc 100644
--- a/src/DHTAnnouncePeerMessage.cc
+++ b/src/DHTAnnouncePeerMessage.cc
@@ -44,13 +44,16 @@
 #include "DHTPeerAnnounceStorage.h"
 #include "DHTTokenTracker.h"
 #include "DlAbortEx.h"
+#include <cstring>
 
-DHTAnnouncePeerMessage::DHTAnnouncePeerMessage(const DHTNodeHandle& localNode,
-					       const DHTNodeHandle& remoteNode,
+namespace aria2 {
+
+DHTAnnouncePeerMessage::DHTAnnouncePeerMessage(const SharedHandle<DHTNode>& localNode,
+					       const SharedHandle<DHTNode>& remoteNode,
 					       const unsigned char* infoHash,
 					       uint16_t tcpPort,
-					       const string& token,
-					       const string& transactionID):
+					       const std::string& token,
+					       const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID),
   _token(token),
   _tcpPort(tcpPort),
@@ -67,7 +70,7 @@ void DHTAnnouncePeerMessage::doReceivedAction()
   _peerAnnounceStorage->addPeerAnnounce(_infoHash, _remoteNode->getIPAddress(),
 					_tcpPort);
 
-  DHTMessageHandle reply =
+  SharedHandle<DHTMessage> reply =
     _factory->createAnnouncePeerReplyMessage(_remoteNode, _transactionID);
   _dispatcher->addMessageToQueue(reply);
 }
@@ -85,7 +88,7 @@ Dictionary* DHTAnnouncePeerMessage::getArgument()
   return a;
 }
 
-string DHTAnnouncePeerMessage::getMessageType() const
+std::string DHTAnnouncePeerMessage::getMessageType() const
 {
   return "announce_peer";
 }
@@ -111,3 +114,5 @@ void DHTAnnouncePeerMessage::setTokenTracker(const WeakHandle<DHTTokenTracker>&
 {
   _tokenTracker = tokenTracker;
 }
+
+} // namespace aria2
diff --git a/src/DHTAnnouncePeerMessage.h b/src/DHTAnnouncePeerMessage.h
index 452629c4..6587e2cd 100644
--- a/src/DHTAnnouncePeerMessage.h
+++ b/src/DHTAnnouncePeerMessage.h
@@ -37,12 +37,15 @@
 
 #include "DHTQueryMessage.h"
 #include "DHTConstants.h"
-#include "DHTPeerAnnounceStorage.h"
-#include "DHTTokenTrackerDecl.h"
+
+namespace aria2 {
+
+class DHTPeerAnnounceStorage;
+class DHTTokenTracker;
 
 class DHTAnnouncePeerMessage:public DHTQueryMessage {
 private:
-  string _token;
+  std::string _token;
 
   unsigned char _infoHash[DHT_ID_LENGTH];
 
@@ -52,12 +55,12 @@ private:
 
   WeakHandle<DHTTokenTracker> _tokenTracker;
 public:
-  DHTAnnouncePeerMessage(const DHTNodeHandle& localNode,
-			 const DHTNodeHandle& remoteNode,
+  DHTAnnouncePeerMessage(const SharedHandle<DHTNode>& localNode,
+			 const SharedHandle<DHTNode>& remoteNode,
 			 const unsigned char* infoHash,
 			 uint16_t tcpPort,
-			 const string& token,
-			 const string& transactionID = "");
+			 const std::string& token,
+			 const std::string& transactionID = "");
 
   virtual ~DHTAnnouncePeerMessage();
 
@@ -65,7 +68,7 @@ public:
 
   virtual Dictionary* getArgument();
   
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
@@ -74,7 +77,7 @@ public:
     return _infoHash;
   }
 
-  const string& getToken() const
+  const std::string& getToken() const
   {
     return _token;
   }
@@ -89,4 +92,6 @@ public:
   void setTokenTracker(const WeakHandle<DHTTokenTracker>& tokenTracker);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ANNOUNCE_PEER_MESSAGE_H_
diff --git a/src/DHTAnnouncePeerReplyMessage.cc b/src/DHTAnnouncePeerReplyMessage.cc
index b3674c08..5dc68ddb 100644
--- a/src/DHTAnnouncePeerReplyMessage.cc
+++ b/src/DHTAnnouncePeerReplyMessage.cc
@@ -37,9 +37,11 @@
 #include "Dictionary.h"
 #include "Data.h"
 
-DHTAnnouncePeerReplyMessage::DHTAnnouncePeerReplyMessage(const DHTNodeHandle& localNode,
-							 const DHTNodeHandle& remoteNode,
-							 const string& transactionID):
+namespace aria2 {
+
+DHTAnnouncePeerReplyMessage::DHTAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& localNode,
+							 const SharedHandle<DHTNode>& remoteNode,
+							 const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID) {}
 
 DHTAnnouncePeerReplyMessage::~DHTAnnouncePeerReplyMessage() {}
@@ -53,9 +55,11 @@ Dictionary* DHTAnnouncePeerReplyMessage::getResponse()
   return r;
 }
 
-string DHTAnnouncePeerReplyMessage::getMessageType() const
+std::string DHTAnnouncePeerReplyMessage::getMessageType() const
 {
   return "announce_peer";
 }
 
 void DHTAnnouncePeerReplyMessage::validate() const {}
+
+} // namespace aria2
diff --git a/src/DHTAnnouncePeerReplyMessage.h b/src/DHTAnnouncePeerReplyMessage.h
index f134fadb..28309aba 100644
--- a/src/DHTAnnouncePeerReplyMessage.h
+++ b/src/DHTAnnouncePeerReplyMessage.h
@@ -37,11 +37,13 @@
 
 #include "DHTResponseMessage.h"
 
+namespace aria2 {
+
 class DHTAnnouncePeerReplyMessage:public DHTResponseMessage {
 public:
-  DHTAnnouncePeerReplyMessage(const DHTNodeHandle& localNode,
-			      const DHTNodeHandle& remoteNode,
-			      const string& transactionID);
+  DHTAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& localNode,
+			      const SharedHandle<DHTNode>& remoteNode,
+			      const std::string& transactionID);
 
   virtual ~DHTAnnouncePeerReplyMessage();
 
@@ -49,9 +51,11 @@ public:
 
   virtual Dictionary* getResponse();
 
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ANNOUNCE_PEER_REPLY_MESSAGE_H_
diff --git a/src/DHTAutoSaveCommand.cc b/src/DHTAutoSaveCommand.cc
index 833d8017..940f7197 100644
--- a/src/DHTAutoSaveCommand.cc
+++ b/src/DHTAutoSaveCommand.cc
@@ -45,9 +45,12 @@
 #include "prefs.h"
 #include "Option.h"
 #include "message.h"
+#include "Logger.h"
 #include <cerrno>
 #include <fstream>
 
+namespace aria2 {
+
 DHTAutoSaveCommand::DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval):
   TimeBasedCommand(cuid, e, interval),
   _localNode(0),
@@ -70,10 +73,10 @@ void DHTAutoSaveCommand::process()
 
 void DHTAutoSaveCommand::save()
 {
-  string dhtFile = _e->option->get(PREF_DHT_FILE_PATH);
+  std::string dhtFile = _e->option->get(PREF_DHT_FILE_PATH);
   logger->info("Saving DHT routing table to %s.", dhtFile.c_str());
 
-  string tempFile = dhtFile+"__temp";
+  std::string tempFile = dhtFile+"__temp";
   {
     File f(tempFile);
     if(!f.isFile()) {
@@ -89,11 +92,12 @@ void DHTAutoSaveCommand::save()
       }
     }
   }
-  DHTNodes nodes;
-  DHTBuckets buckets = _routingTable->getBuckets();
-  for(DHTBuckets::const_iterator i = buckets.begin(); i != buckets.end(); ++i) {
-    const DHTBucketHandle& bucket = *i;
-    DHTNodes goodNodes = bucket->getGoodNodes();
+  std::deque<SharedHandle<DHTNode> > nodes;
+  std::deque<SharedHandle<DHTBucket> > buckets = _routingTable->getBuckets();
+  for(std::deque<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(); i != buckets.end(); ++i) {
+
+    const SharedHandle<DHTBucket>& bucket = *i;
+    std::deque<SharedHandle<DHTNode> > goodNodes = bucket->getGoodNodes();
     nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
   }
 
@@ -102,8 +106,8 @@ void DHTAutoSaveCommand::save()
   serializer.setNodes(nodes);
 
   try {
-    ofstream o(tempFile.c_str(), ios::out|ios::binary);
-    o.exceptions(ios::failbit);
+    std::ofstream o(tempFile.c_str(), std::ios::out|std::ios::binary);
+    o.exceptions(std::ios::failbit);
 
     serializer.serialize(o);
 
@@ -111,7 +115,7 @@ void DHTAutoSaveCommand::save()
       logger->error("Cannot move file from %s to %s.",
 		    tempFile.c_str(), dhtFile.c_str());
     }
-  } catch(ios::failure const& e) {
+  } catch(std::ios::failure const& e) {
     logger->error("Failed to save DHT routing table to %s. cause:%s",
 		  tempFile.c_str(), strerror(errno));
   } catch(RecoverableException* e) {
@@ -121,12 +125,14 @@ void DHTAutoSaveCommand::save()
   }
 }
 
-void DHTAutoSaveCommand::setLocalNode(const DHTNodeHandle& localNode)
+void DHTAutoSaveCommand::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
 
-void DHTAutoSaveCommand::setRoutingTable(const DHTRoutingTableHandle& routingTable)
+void DHTAutoSaveCommand::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable)
 {
   _routingTable = routingTable;
 }
+
+} // namespace aria2
diff --git a/src/DHTAutoSaveCommand.h b/src/DHTAutoSaveCommand.h
index 86f586bf..99fd7155 100644
--- a/src/DHTAutoSaveCommand.h
+++ b/src/DHTAutoSaveCommand.h
@@ -36,15 +36,19 @@
 #define _D_DHT_AUTO_SAVE_COMMAND_H_
 
 #include "TimeBasedCommand.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTRoutingTable;
+class DHTNode;
 
 class DHTAutoSaveCommand : public TimeBasedCommand
 {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
   
-  DHTRoutingTableHandle _routingTable;
+  SharedHandle<DHTRoutingTable> _routingTable;
 
   void save();
 public:
@@ -56,9 +60,11 @@ public:
 
   virtual void process();
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 
-  void setRoutingTable(const DHTRoutingTableHandle& routingTable);
+  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_AUTO_SAVE_COMMAND_H_
diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc
index 4088dbc1..2993a9a9 100644
--- a/src/DHTBucket.cc
+++ b/src/DHTBucket.cc
@@ -36,13 +36,19 @@
 #include "DHTUtil.h"
 #include "DHTNode.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
 #include "DHTConstants.h"
 #include "a2functional.h"
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+
+namespace aria2 {
 
 DHTBucket::DHTBucket(uint32_t prefixLength,
 		     const unsigned char* max, const unsigned char* min,
-		     const DHTNodeHandle& localNode):
+		     const SharedHandle<DHTNode>& localNode):
   _prefixLength(prefixLength),
   _localNode(localNode),
   _logger(LogFactory::getInstance())
@@ -51,7 +57,7 @@ DHTBucket::DHTBucket(uint32_t prefixLength,
   memcpy(_min, min, DHT_ID_LENGTH);
 }
 
-DHTBucket::DHTBucket(const DHTNodeHandle& localNode):
+DHTBucket::DHTBucket(const SharedHandle<DHTNode>& localNode):
   _prefixLength(0),
   _localNode(localNode),
   _logger(LogFactory::getInstance())
@@ -73,7 +79,7 @@ void DHTBucket::getRandomNodeID(unsigned char* nodeID) const
   }
 }
 
-bool DHTBucket::isInRange(const DHTNodeHandle& node) const
+bool DHTBucket::isInRange(const SharedHandle<DHTNode>& node) const
 {
   return isInRange(node->getID());
 }
@@ -97,10 +103,10 @@ bool DHTBucket::isInRange(const unsigned char* nodeID) const
   return true;
 }
 
-bool DHTBucket::addNode(const DHTNodeHandle& node)
+bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
 {
   notifyUpdate();
-  DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node);
+  std::deque<SharedHandle<DHTNode> >::iterator itr = std::find(_nodes.begin(), _nodes.end(), node);
   if(itr == _nodes.end()) {
     if(_nodes.size() < K) {
       _nodes.push_back(node);
@@ -117,7 +123,7 @@ bool DHTBucket::addNode(const DHTNodeHandle& node)
       } else if(splitAllowed()) {
 	return false;
       } else {
-	DHTNodes::iterator ci = find(_cachedNodes.begin(), _cachedNodes.end(), node);
+	std::deque<SharedHandle<DHTNode> >::iterator ci = find(_cachedNodes.begin(), _cachedNodes.end(), node);
 	if(ci == _cachedNodes.end()) {
 	  _cachedNodes.push_back(node);
 	  if(_cachedNodes.size() > CACHE_SIZE) {
@@ -138,11 +144,11 @@ bool DHTBucket::addNode(const DHTNodeHandle& node)
   }
 }
 
-void DHTBucket::dropNode(const DHTNodeHandle& node)
+void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
 {
   return;
   /*
-  DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node);
+  std::deque<SharedHandle<DHTNode> >::iterator itr = find(_nodes.begin(), _nodes.end(), node);
   if(itr != _nodes.end()) {
     _nodes.erase(itr);
     if(_cachedNodes.size()) {
@@ -153,18 +159,20 @@ void DHTBucket::dropNode(const DHTNodeHandle& node)
   */
 }
 
-void DHTBucket::moveToHead(const DHTNodeHandle& node)
+void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
 {
-  DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node);
+  std::deque<SharedHandle<DHTNode> >::iterator itr =
+    std::find(_nodes.begin(), _nodes.end(), node);
   if(itr != _nodes.end()) {
     _nodes.erase(itr);
     _nodes.push_front(node);
   }
 }
 
-void DHTBucket::moveToTail(const DHTNodeHandle& node)
+void DHTBucket::moveToTail(const SharedHandle<DHTNode>& node)
 {
-  DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node);
+  std::deque<SharedHandle<DHTNode> >::iterator itr =
+    std::find(_nodes.begin(), _nodes.end(), node);
   if(itr != _nodes.end()) {
     _nodes.erase(itr);
     _nodes.push_back(node);
@@ -176,7 +184,7 @@ bool DHTBucket::splitAllowed() const
   return _prefixLength < DHT_ID_LENGTH*8-1 && isInRange(_localNode);
 }
 
-DHTBucketHandle DHTBucket::split()
+SharedHandle<DHTBucket> DHTBucket::split()
 {
   assert(splitAllowed());
   size_t newPrefixLength = _prefixLength+1;
@@ -185,10 +193,11 @@ DHTBucketHandle DHTBucket::split()
   memcpy(rMax, _max, DHT_ID_LENGTH);
   DHTUtil::flipBit(rMax, DHT_ID_LENGTH, _prefixLength);
 
-  DHTBucketHandle rBucket = new DHTBucket(newPrefixLength,
-					  rMax, _min, _localNode);
-  DHTNodes tempNodes = _nodes;
-  for(DHTNodes::iterator i = tempNodes.begin(); i != tempNodes.end();) {
+  SharedHandle<DHTBucket> rBucket = new DHTBucket(newPrefixLength,
+						  rMax, _min, _localNode);
+  std::deque<SharedHandle<DHTNode> > tempNodes = _nodes;
+  for(std::deque<SharedHandle<DHTNode> >::iterator i = tempNodes.begin();
+      i != tempNodes.end();) {
     if(rBucket->isInRange(*i)) {
       assert(rBucket->addNode(*i));
       i = tempNodes.erase(i);
@@ -215,25 +224,26 @@ size_t DHTBucket::countNode() const
   return _nodes.size();
 }
 
-const DHTNodes& DHTBucket::getNodes() const
+const std::deque<SharedHandle<DHTNode> >& DHTBucket::getNodes() const
 {
   return _nodes;
 }
 
-DHTNodes DHTBucket::getGoodNodes() const
+std::deque<SharedHandle<DHTNode> > DHTBucket::getGoodNodes() const
 {
-  DHTNodes goodNodes = _nodes;
-  goodNodes.erase(remove_if(goodNodes.begin(), goodNodes.end(),
-			    mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
+  std::deque<SharedHandle<DHTNode> > goodNodes = _nodes;
+  goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
+				 mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
   return goodNodes;
 }
 
-DHTNodeHandle DHTBucket::getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const
+SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
 {
-  DHTNodeHandle node = new DHTNode(nodeID);
+  SharedHandle<DHTNode> node = new DHTNode(nodeID);
   node->setIPAddress(ipaddr);
   node->setPort(port);
-  DHTNodes::const_iterator itr = find(_nodes.begin(), _nodes.end(), node);
+  std::deque<SharedHandle<DHTNode> >::const_iterator itr =
+    std::find(_nodes.begin(), _nodes.end(), node);
   if(itr == _nodes.end()) {
     return 0;
   } else {
@@ -259,7 +269,7 @@ void DHTBucket::notifyUpdate()
 
 class FindQuestionableNode {
 public:
-  bool operator()(const DHTNodeHandle& node) const
+  bool operator()(const SharedHandle<DHTNode>& node) const
   {
     return node->isQuestionable();
   }
@@ -267,15 +277,18 @@ public:
 
 bool DHTBucket::containsQuestionableNode() const
 {
-  return find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()) != _nodes.end();
+  return std::find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()) != _nodes.end();
 }
 
-DHTNodeHandle DHTBucket::getLRUQuestionableNode() const
+SharedHandle<DHTNode> DHTBucket::getLRUQuestionableNode() const
 {
-  DHTNodes::const_iterator i = find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode());
+  std::deque<SharedHandle<DHTNode> >::const_iterator i =
+    std::find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode());
   if(i == _nodes.end()) {
     return 0;
   } else {
     return *i;
   }
 }
+
+} // namespace aria2
diff --git a/src/DHTBucket.h b/src/DHTBucket.h
index 42ca67b2..5c10eeb1 100644
--- a/src/DHTBucket.h
+++ b/src/DHTBucket.h
@@ -36,11 +36,15 @@
 #define _D_DHT_BUCKET_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "DHTConstants.h"
-#include "DHTNodeDecl.h"
-#include "DHTBucketDecl.h"
 #include "TimeA2.h"
+#include <string>
+#include <deque>
 
+namespace aria2 {
+
+class DHTNode;
 class Logger;
 
 class DHTBucket {
@@ -52,22 +56,22 @@ private:
 
   unsigned char _max[DHT_ID_LENGTH];
 
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
   // sorted in ascending order
-  DHTNodes _nodes;
+  std::deque<SharedHandle<DHTNode> > _nodes;
 
-  DHTNodes _cachedNodes;
+  //std::deque<SharedHandle<DHTNode> > _cachedNodes;
 
   Time _lastUpdated;
 
   const Logger* _logger;
 public:
-  DHTBucket(const DHTNodeHandle& localNode);
+  DHTBucket(const SharedHandle<DHTNode>& localNode);
 
   DHTBucket(size_t prefixLength,
 	    const unsigned char* max, const unsigned char* min,
-	    const DHTNodeHandle& localNode);
+	    const SharedHandle<DHTNode>& localNode);
 
   ~DHTBucket();
 
@@ -77,13 +81,13 @@ public:
 
   void getRandomNodeID(unsigned char* nodeID) const;
 
-  DHTBucketHandle split();
+  SharedHandle<DHTBucket> split();
 
-  bool isInRange(const DHTNodeHandle& node) const;
+  bool isInRange(const SharedHandle<DHTNode>& node) const;
 
   bool isInRange(const unsigned char* nodeID) const;
 
-  bool addNode(const DHTNodeHandle& node);
+  bool addNode(const SharedHandle<DHTNode>& node);
 
   bool splitAllowed() const;
   
@@ -104,19 +108,19 @@ public:
 
   size_t countNode() const;
 
-  const DHTNodes& getNodes() const;
+  const std::deque<SharedHandle<DHTNode> >& getNodes() const;
 
-  DHTNodes getGoodNodes() const;
+  std::deque<SharedHandle<DHTNode> > getGoodNodes() const;
 
-  void dropNode(const DHTNodeHandle& node);
+  void dropNode(const SharedHandle<DHTNode>& node);
 
-  void moveToHead(const DHTNodeHandle& node);
+  void moveToHead(const SharedHandle<DHTNode>& node);
 
-  void moveToTail(const DHTNodeHandle& node);
+  void moveToTail(const SharedHandle<DHTNode>& node);
 
-  bool contains(const DHTNodeHandle& node) const;
+  bool contains(const SharedHandle<DHTNode>& node) const;
 
-  DHTNodeHandle getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const;
+  SharedHandle<DHTNode> getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const;
 
   bool operator==(const DHTBucket& bucket) const;
 
@@ -126,7 +130,9 @@ public:
 
   bool containsQuestionableNode() const;
 
-  DHTNodeHandle getLRUQuestionableNode() const;
+  SharedHandle<DHTNode> getLRUQuestionableNode() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_BUCKET_H_
diff --git a/src/DHTBucketDecl.h b/src/DHTBucketDecl.h
deleted file mode 100644
index a3ab9751..00000000
--- a/src/DHTBucketDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_BUCKET_DECL_H_
-#define _D_DHT_BUCKET_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTBucket;
-typedef SharedHandle<DHTBucket> DHTBucketHandle;
-typedef std::deque<DHTBucketHandle> DHTBuckets;
-
-#endif // _D_DHT_BUCKET_DECL_H_
diff --git a/src/DHTBucketRefreshCommand.cc b/src/DHTBucketRefreshCommand.cc
index 0a31938d..ba3da97c 100644
--- a/src/DHTBucketRefreshCommand.cc
+++ b/src/DHTBucketRefreshCommand.cc
@@ -38,9 +38,10 @@
 #include "DHTTaskFactory.h"
 #include "DHTTask.h"
 #include "DownloadEngine.h"
-#include "SingletonHolder.h"
 #include "RequestGroupMan.h"
 
+namespace aria2 {
+
 DHTBucketRefreshCommand::DHTBucketRefreshCommand(int32_t cuid, DownloadEngine* e, time_t interval):
   TimeBasedCommand(cuid, e, interval),
   _routingTable(0),
@@ -59,17 +60,19 @@ void DHTBucketRefreshCommand::process()
   _taskQueue->addPeriodicTask1(_taskFactory->createBucketRefreshTask());
 }
 
-void DHTBucketRefreshCommand::setRoutingTable(const DHTRoutingTableHandle& routingTable)
+void DHTBucketRefreshCommand::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable)
 {
   _routingTable = routingTable;
 }
 
-void DHTBucketRefreshCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTBucketRefreshCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
 
-void DHTBucketRefreshCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory)
+void DHTBucketRefreshCommand::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
 {
   _taskFactory = taskFactory;
 }
+
+} // namespace aria2
diff --git a/src/DHTBucketRefreshCommand.h b/src/DHTBucketRefreshCommand.h
index e000c5e0..068ea268 100644
--- a/src/DHTBucketRefreshCommand.h
+++ b/src/DHTBucketRefreshCommand.h
@@ -36,17 +36,21 @@
 #define _D_DHT_BUCKET_REFRESH_COMMAND_H_
 
 #include "TimeBasedCommand.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTRoutingTable;
+class DHTTaskQueue;
+class DHTTaskFactory;
 
 class DHTBucketRefreshCommand:public TimeBasedCommand {
 private:
-  DHTRoutingTableHandle _routingTable;
+  SharedHandle<DHTRoutingTable> _routingTable;
 
-  DHTTaskQueueHandle _taskQueue;
+  SharedHandle<DHTTaskQueue> _taskQueue;
 
-  DHTTaskFactoryHandle _taskFactory;
+  SharedHandle<DHTTaskFactory> _taskFactory;
 public:
   DHTBucketRefreshCommand(int32_t cuid, DownloadEngine* e, time_t interval);
 
@@ -56,11 +60,13 @@ public:
 
   virtual void process();
 
-  void setRoutingTable(const DHTRoutingTableHandle& routingTable);
+  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const DHTTaskFactoryHandle& taskFactory);
+  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_BUCKET_REFRESH_COMMAND_H_
diff --git a/src/DHTBucketRefreshTask.cc b/src/DHTBucketRefreshTask.cc
index 5d1f6b89..d26e3c04 100644
--- a/src/DHTBucketRefreshTask.cc
+++ b/src/DHTBucketRefreshTask.cc
@@ -42,14 +42,16 @@
 #include "Util.h"
 #include "Logger.h"
 
+namespace aria2 {
+
 DHTBucketRefreshTask::DHTBucketRefreshTask() {}
 
 DHTBucketRefreshTask::~DHTBucketRefreshTask() {}
 
 void DHTBucketRefreshTask::startup()
 {
-  DHTBuckets buckets = _routingTable->getBuckets();
-  for(DHTBuckets::iterator i = buckets.begin(); i != buckets.end(); ++i) {
+  std::deque<SharedHandle<DHTBucket> > buckets = _routingTable->getBuckets();
+  for(std::deque<SharedHandle<DHTBucket> >::iterator i = buckets.begin(); i != buckets.end(); ++i) {
     if((*i)->needsRefresh()) {
       (*i)->notifyUpdate();
       unsigned char targetID[DHT_ID_LENGTH];
@@ -67,3 +69,5 @@ void DHTBucketRefreshTask::startup()
   }
   _finished = true;
 }
+
+} // namespace aria2
diff --git a/src/DHTBucketRefreshTask.h b/src/DHTBucketRefreshTask.h
index 38212b78..f2ba9e0f 100644
--- a/src/DHTBucketRefreshTask.h
+++ b/src/DHTBucketRefreshTask.h
@@ -37,6 +37,8 @@
 
 #include "DHTAbstractTask.h"
 
+namespace aria2 {
+
 class DHTBucketRefreshTask:public DHTAbstractTask {
 public:
   DHTBucketRefreshTask();
@@ -46,4 +48,6 @@ public:
   virtual void startup();
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_BUCKET_REFRESH_TASK_H_
diff --git a/src/DHTConnection.h b/src/DHTConnection.h
index 5bedca3c..9caf3124 100644
--- a/src/DHTConnection.h
+++ b/src/DHTConnection.h
@@ -36,14 +36,19 @@
 #define _D_DHT_CONNECTION_H_
 
 #include "common.h"
+#include <string>
+
+namespace aria2 {
 
 class DHTConnection {
 public:
   virtual ~DHTConnection() {}
 
-  virtual ssize_t receiveMessage(char* data, size_t len, string& host, uint16_t& port) = 0;
+  virtual ssize_t receiveMessage(char* data, size_t len, std::string& host, uint16_t& port) = 0;
 
-  virtual void sendMessage(const char* data, size_t len, const string& host, uint16_t port) = 0;
+  virtual void sendMessage(const char* data, size_t len, const std::string& host, uint16_t port) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_CONNECTION_H_
diff --git a/src/DHTConnectionImpl.cc b/src/DHTConnectionImpl.cc
index 605b2d54..c7e54baf 100644
--- a/src/DHTConnectionImpl.cc
+++ b/src/DHTConnectionImpl.cc
@@ -34,8 +34,14 @@
 /* copyright --> */
 #include "DHTConnectionImpl.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "RecoverableException.h"
 #include "Util.h"
+#include "Socket.h"
+#include <utility>
+
+namespace aria2 {
+
 DHTConnectionImpl::DHTConnectionImpl():_socket(new SocketCore(SOCK_DGRAM)),
 				       _logger(LogFactory::getInstance()) {}
 
@@ -56,7 +62,7 @@ uint16_t DHTConnectionImpl::bind(uint16_t port)
 {
   try {
     _socket->bind(port);
-    pair<string, int32_t> svaddr;
+    std::pair<std::string, int32_t> svaddr;
     _socket->getAddrInfo(svaddr);
     _logger->info("Bind socket for DHT. port=%u", port);
     return svaddr.second;
@@ -67,10 +73,10 @@ uint16_t DHTConnectionImpl::bind(uint16_t port)
   return 0;
 }
 
-ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, string& host, uint16_t& port)
+ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, std::string& host, uint16_t& port)
 {
   if(_socket->isReadable(0)) {
-    pair<string, uint16_t> remoteHost;
+    std::pair<std::string, uint16_t> remoteHost;
     ssize_t length = _socket->readDataFrom(data, len, remoteHost);
     host = remoteHost.first;
     port = remoteHost.second;
@@ -80,12 +86,14 @@ ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, string& host,
   }
 }
 
-void DHTConnectionImpl::sendMessage(const char* data, size_t len, const string& host, uint16_t port)
+void DHTConnectionImpl::sendMessage(const char* data, size_t len, const std::string& host, uint16_t port)
 {
   _socket->writeData(data, len, host, port);
 }
 
-SocketHandle DHTConnectionImpl::getSocket() const
+SharedHandle<SocketCore> DHTConnectionImpl::getSocket() const
 {
   return _socket;
 }
+
+} // namespace aria2
diff --git a/src/DHTConnectionImpl.h b/src/DHTConnectionImpl.h
index 011b232f..96af0315 100644
--- a/src/DHTConnectionImpl.h
+++ b/src/DHTConnectionImpl.h
@@ -36,14 +36,17 @@
 #define _D_DHT_CONNECTION_IMPL_H_
 
 #include "DHTConnection.h"
-#include "Socket.h"
+#include "SharedHandle.h"
 #include "IntSequence.h"
 
+namespace aria2 {
+
+class SocketCore;
 class Logger;
 
 class DHTConnectionImpl:public DHTConnection {
 private:
-  SocketHandle _socket;
+  SharedHandle<SocketCore> _socket;
 
   const Logger* _logger;
 public:
@@ -55,11 +58,13 @@ public:
   
   uint16_t bind(uint16_t port);
 
-  virtual ssize_t receiveMessage(char* data, size_t len, string& host, uint16_t& port);
+  virtual ssize_t receiveMessage(char* data, size_t len, std::string& host, uint16_t& port);
 
-  virtual void sendMessage(const char* data, size_t len, const string& host, uint16_t port);
+  virtual void sendMessage(const char* data, size_t len, const std::string& host, uint16_t port);
 
-  SocketHandle getSocket() const;
+  SharedHandle<SocketCore> getSocket() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_CONNECTION_IMPL_H_
diff --git a/src/DHTEntryPointNameResolveCommand.cc b/src/DHTEntryPointNameResolveCommand.cc
index b0721517..5de627a7 100644
--- a/src/DHTEntryPointNameResolveCommand.cc
+++ b/src/DHTEntryPointNameResolveCommand.cc
@@ -46,6 +46,9 @@
 #include "DHTTaskFactory.h"
 #include "DHTTask.h"
 #include "RequestGroupMan.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e):
   Command(cuid),
@@ -70,7 +73,7 @@ bool DHTEntryPointNameResolveCommand::execute()
   }
 
   try {
-    string hostname = _e->option->get(PREF_DHT_ENTRY_POINT_HOST);
+    std::string hostname = _e->option->get(PREF_DHT_ENTRY_POINT_HOST);
     if(!Util::isNumbersAndDotsNotation(hostname)) {
       if(resolveHostname(hostname, _resolver)) {
 	hostname = _resolver->getAddrString();
@@ -80,7 +83,7 @@ bool DHTEntryPointNameResolveCommand::execute()
       }
     }
     
-    DHTNodeHandle entryNode = new DHTNode();
+    SharedHandle<DHTNode> entryNode = new DHTNode();
     entryNode->setIPAddress(hostname);
     entryNode->setPort(_e->option->getAsInt(PREF_DHT_ENTRY_POINT_PORT));
  
@@ -94,10 +97,10 @@ bool DHTEntryPointNameResolveCommand::execute()
   return true;
 }
 
-bool DHTEntryPointNameResolveCommand::resolveHostname(const string& hostname,
+bool DHTEntryPointNameResolveCommand::resolveHostname(const std::string& hostname,
 						      const NameResolverHandle& resolver)
 {
-  string ipaddr = DNSCacheSingletonHolder::instance()->find(hostname);
+  std::string ipaddr = DNSCacheSingletonHolder::instance()->find(hostname);
   if(ipaddr.empty()) {
 #ifdef ENABLE_ASYNC_DNS
     switch(resolver->getStatus()) {
@@ -136,26 +139,28 @@ bool DHTEntryPointNameResolveCommand::resolveHostname(const string& hostname,
 }
 
 #ifdef ENABLE_ASYNC_DNS
-void DHTEntryPointNameResolveCommand::setNameResolverCheck(const NameResolverHandle& resolver) {
+void DHTEntryPointNameResolveCommand::setNameResolverCheck(const SharedHandle<NameResolver>& resolver) {
   _e->addNameResolverCheck(resolver, this);
 }
 
-void DHTEntryPointNameResolveCommand::disableNameResolverCheck(const NameResolverHandle& resolver) {
+void DHTEntryPointNameResolveCommand::disableNameResolverCheck(const SharedHandle<NameResolver>& resolver) {
   _e->deleteNameResolverCheck(resolver, this);
 }
 #endif // ENABLE_ASYNC_DNS
 
-void DHTEntryPointNameResolveCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTEntryPointNameResolveCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
 
-void DHTEntryPointNameResolveCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory)
+void DHTEntryPointNameResolveCommand::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
 {
   _taskFactory = taskFactory;
 }
 
-void DHTEntryPointNameResolveCommand::setLocalNode(const DHTNodeHandle& localNode)
+void DHTEntryPointNameResolveCommand::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
+
+} // namespace aria2
diff --git a/src/DHTEntryPointNameResolveCommand.h b/src/DHTEntryPointNameResolveCommand.h
index 2bf3a9db..3e72c872 100644
--- a/src/DHTEntryPointNameResolveCommand.h
+++ b/src/DHTEntryPointNameResolveCommand.h
@@ -36,32 +36,34 @@
 #define _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_
 
 #include "Command.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
 
+namespace aria2 {
+
+class DHTTaskQueue;
+class DHTTaskFactory;
+class DHTNode;
 class DownloadEngine;
 class NameResolver;
-typedef SharedHandle<NameResolver> NameResolverHandle;
 
 class DHTEntryPointNameResolveCommand:public Command {
 protected:
   DownloadEngine* _e;
 private:
-  NameResolverHandle _resolver;
+  SharedHandle<NameResolver> _resolver;
 
-  DHTTaskQueueHandle _taskQueue;
+  SharedHandle<DHTTaskQueue> _taskQueue;
 
-  DHTTaskFactoryHandle _taskFactory;
+  SharedHandle<DHTTaskFactory> _taskFactory;
 
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
-  bool resolveHostname(const string& hostname,
-		       const NameResolverHandle& resolver);
+  bool resolveHostname(const std::string& hostname,
+		       const SharedHandle<NameResolver>& resolver);
 
-  void setNameResolverCheck(const NameResolverHandle& resolver);
+  void setNameResolverCheck(const SharedHandle<NameResolver>& resolver);
 
-  void disableNameResolverCheck(const NameResolverHandle& resolver);
+  void disableNameResolverCheck(const SharedHandle<NameResolver>& resolver);
 
 public:
   DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e);
@@ -70,11 +72,13 @@ public:
 
   virtual bool execute();
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const DHTTaskFactoryHandle& taskFactory);
+  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_
diff --git a/src/DHTFindNodeMessage.cc b/src/DHTFindNodeMessage.cc
index 72aaa398..772d6eba 100644
--- a/src/DHTFindNodeMessage.cc
+++ b/src/DHTFindNodeMessage.cc
@@ -40,11 +40,14 @@
 #include "DHTMessageFactory.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageCallback.h"
+#include <cstring>
 
-DHTFindNodeMessage::DHTFindNodeMessage(const DHTNodeHandle& localNode,
-				       const DHTNodeHandle& remoteNode,
+namespace aria2 {
+
+DHTFindNodeMessage::DHTFindNodeMessage(const SharedHandle<DHTNode>& localNode,
+				       const SharedHandle<DHTNode>& remoteNode,
 				       const unsigned char* targetNodeID,
-				       const string& transactionID):
+				       const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID)
 {
   memcpy(_targetNodeID, targetNodeID, DHT_ID_LENGTH);
@@ -54,8 +57,8 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {}
 
 void DHTFindNodeMessage::doReceivedAction()
 {
-  DHTNodes nodes = _routingTable->getClosestKNodes(_targetNodeID);
-  DHTMessageHandle reply =
+  std::deque<SharedHandle<DHTNode> > nodes = _routingTable->getClosestKNodes(_targetNodeID);
+  SharedHandle<DHTMessage> reply =
     _factory->createFindNodeReplyMessage(_remoteNode, nodes, _transactionID);
   _dispatcher->addMessageToQueue(reply);
 }
@@ -70,9 +73,11 @@ Dictionary* DHTFindNodeMessage::getArgument()
   return a;
 }
 
-string DHTFindNodeMessage::getMessageType() const
+std::string DHTFindNodeMessage::getMessageType() const
 {
   return "find_node";
 }
 
 void DHTFindNodeMessage::validate() const {}
+
+} // namespace aria2
diff --git a/src/DHTFindNodeMessage.h b/src/DHTFindNodeMessage.h
index 88bdbece..d15132db 100644
--- a/src/DHTFindNodeMessage.h
+++ b/src/DHTFindNodeMessage.h
@@ -38,14 +38,16 @@
 #include "DHTQueryMessage.h"
 #include "DHTConstants.h"
 
+namespace aria2 {
+
 class DHTFindNodeMessage:public DHTQueryMessage {
 private:
   unsigned char _targetNodeID[DHT_ID_LENGTH];
 public:
-  DHTFindNodeMessage(const DHTNodeHandle& localNode,
-		     const DHTNodeHandle& remoteNode,
+  DHTFindNodeMessage(const SharedHandle<DHTNode>& localNode,
+		     const SharedHandle<DHTNode>& remoteNode,
 		     const unsigned char* targetNodeID,
-		     const string& transactionID = "");
+		     const std::string& transactionID = "");
 
   virtual ~DHTFindNodeMessage();
 
@@ -53,7 +55,7 @@ public:
 
   virtual Dictionary* getArgument();
   
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
@@ -63,4 +65,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_FIND_NODE_MESSAGE_H_
diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc
index b5cfdcad..741adde1 100644
--- a/src/DHTFindNodeReplyMessage.cc
+++ b/src/DHTFindNodeReplyMessage.cc
@@ -42,17 +42,20 @@
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageCallback.h"
 #include "PeerMessageUtil.h"
+#include <cstring>
 
-DHTFindNodeReplyMessage::DHTFindNodeReplyMessage(const DHTNodeHandle& localNode,
-						 const DHTNodeHandle& remoteNode,
-						 const string& transactionID):
+namespace aria2 {
+
+DHTFindNodeReplyMessage::DHTFindNodeReplyMessage(const SharedHandle<DHTNode>& localNode,
+						 const SharedHandle<DHTNode>& remoteNode,
+						 const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID) {}
 
 DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {}
 
 void DHTFindNodeReplyMessage::doReceivedAction()
 {
-  for(DHTNodes::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+  for(std::deque<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
     if(memcmp((*i)->getID(), _localNode->getID(), DHT_ID_LENGTH) != 0) {
       _routingTable->addNode(*i);
     }
@@ -66,8 +69,8 @@ Dictionary* DHTFindNodeReplyMessage::getResponse()
 			DHT_ID_LENGTH));
   size_t offset = 0;
   char buffer[DHTBucket::K*26];
-  for(DHTNodes::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
-    DHTNodeHandle node = *i;
+  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+    SharedHandle<DHTNode> node = *i;
     memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
     if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) {
       offset += 26;
@@ -77,19 +80,21 @@ Dictionary* DHTFindNodeReplyMessage::getResponse()
   return a;
 }
 
-string DHTFindNodeReplyMessage::getMessageType() const
+std::string DHTFindNodeReplyMessage::getMessageType() const
 {
   return "find_node";
 }
 
 void DHTFindNodeReplyMessage::validate() const {}
 
-const DHTNodes& DHTFindNodeReplyMessage::getClosestKNodes() const
+const std::deque<SharedHandle<DHTNode> >& DHTFindNodeReplyMessage::getClosestKNodes() const
 {
   return _closestKNodes;
 }
 
-void DHTFindNodeReplyMessage::setClosestKNodes(const DHTNodes& closestKNodes)
+void DHTFindNodeReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
 {
   _closestKNodes = closestKNodes;
 }
+
+} // namespace aria2
diff --git a/src/DHTFindNodeReplyMessage.h b/src/DHTFindNodeReplyMessage.h
index 80ab387c..c1792257 100644
--- a/src/DHTFindNodeReplyMessage.h
+++ b/src/DHTFindNodeReplyMessage.h
@@ -36,14 +36,17 @@
 #define _D_DHT_FIND_NODE_REPLY_MESSAGE_H_
 
 #include "DHTResponseMessage.h"
+#include <deque>
+
+namespace aria2 {
 
 class DHTFindNodeReplyMessage:public DHTResponseMessage {
 private:
-  DHTNodes _closestKNodes;
+  std::deque<SharedHandle<DHTNode> > _closestKNodes;
 public:
-  DHTFindNodeReplyMessage(const DHTNodeHandle& localNode,
-			  const DHTNodeHandle& remoteNode,
-			  const string& transactionID);
+  DHTFindNodeReplyMessage(const SharedHandle<DHTNode>& localNode,
+			  const SharedHandle<DHTNode>& remoteNode,
+			  const std::string& transactionID);
 
   virtual ~DHTFindNodeReplyMessage();
 
@@ -51,13 +54,15 @@ public:
 
   virtual Dictionary* getResponse();
   
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
-  const DHTNodes& getClosestKNodes() const;
+  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const;
 
-  void setClosestKNodes(const DHTNodes& closestKNodes);
+  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_FIND_NODE_REPLY_MESSAGE_H_
diff --git a/src/DHTGetPeersCommand.cc b/src/DHTGetPeersCommand.cc
index 7788577e..07111ed7 100644
--- a/src/DHTGetPeersCommand.cc
+++ b/src/DHTGetPeersCommand.cc
@@ -41,6 +41,13 @@
 #include "DHTPeerLookupTask.h"
 #include "DHTNode.h"
 #include "DHTNodeLookupEntry.h"
+#include "BtContext.h"
+#include "BtRuntime.h"
+#include "PeerStorage.h"
+#include "Peer.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 DHTGetPeersCommand::DHTGetPeersCommand(int32_t cuid,
 				       RequestGroup* requestGroup,
@@ -85,12 +92,14 @@ bool DHTGetPeersCommand::execute()
   return false;
 }
 
-void DHTGetPeersCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTGetPeersCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
 
-void DHTGetPeersCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory)
+void DHTGetPeersCommand::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
 {
   _taskFactory = taskFactory;
 }
+
+} // namespace aria2
diff --git a/src/DHTGetPeersCommand.h b/src/DHTGetPeersCommand.h
index 9661bc95..8ff5be6d 100644
--- a/src/DHTGetPeersCommand.h
+++ b/src/DHTGetPeersCommand.h
@@ -38,14 +38,15 @@
 #include "Command.h"
 #include "BtContextAwareCommand.h"
 #include "RequestGroupAware.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
+class DHTTaskQueue;
+class DHTTaskFactory;
 class DHTPeerLookupTask;
 class DownloadEngine;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
 
 class DHTGetPeersCommand:public Command,
 			 public BtContextAwareCommand,
@@ -60,9 +61,9 @@ private:
 
   DownloadEngine* _e;
 
-  DHTTaskQueueHandle _taskQueue;
+  SharedHandle<DHTTaskQueue> _taskQueue;
 
-  DHTTaskFactoryHandle _taskFactory;
+  SharedHandle<DHTTaskFactory> _taskFactory;
 
   SharedHandle<DHTPeerLookupTask> _task;
 
@@ -71,15 +72,18 @@ private:
   Time _lastGetPeerTime;
 public:
   DHTGetPeersCommand(int32_t cuid, RequestGroup* requestGroup,
-		     DownloadEngine* e, const BtContextHandle& ctx);
+		     DownloadEngine* e,
+		     const SharedHandle<BtContext>& ctx);
 
   virtual ~DHTGetPeersCommand();
 
   virtual bool execute();
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const DHTTaskFactoryHandle& taskFactory);
+  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_GET_PEERS_COMMAND_H_
diff --git a/src/DHTGetPeersMessage.cc b/src/DHTGetPeersMessage.cc
index cb0a5ee4..c8545fc2 100644
--- a/src/DHTGetPeersMessage.cc
+++ b/src/DHTGetPeersMessage.cc
@@ -44,11 +44,14 @@
 #include "DHTUtil.h"
 #include "Peer.h"
 #include "DHTTokenTracker.h"
+#include <cstring>
 
-DHTGetPeersMessage::DHTGetPeersMessage(const DHTNodeHandle& localNode,
-				       const DHTNodeHandle& remoteNode,
+namespace aria2 {
+
+DHTGetPeersMessage::DHTGetPeersMessage(const SharedHandle<DHTNode>& localNode,
+				       const SharedHandle<DHTNode>& remoteNode,
 				       const unsigned char* infoHash,
-				       const string& transactionID):
+				       const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID)
 {
   memcpy(_infoHash, infoHash, DHT_ID_LENGTH);
@@ -58,14 +61,14 @@ DHTGetPeersMessage::~DHTGetPeersMessage() {}
 
 void DHTGetPeersMessage::doReceivedAction()
 {
-  string token = _tokenTracker->generateToken(_infoHash,
+  std::string token = _tokenTracker->generateToken(_infoHash,
 					      _remoteNode->getIPAddress(),
 					      _remoteNode->getPort());
   // Check to see localhost has the contents which has same infohash
   Peers peers = _peerAnnounceStorage->getPeers(_infoHash);
-  DHTMessageHandle reply = 0;
+  SharedHandle<DHTMessage> reply = 0;
   if(peers.empty()) {
-    DHTNodes nodes = _routingTable->getClosestKNodes(_infoHash);
+    std::deque<SharedHandle<DHTNode> > nodes = _routingTable->getClosestKNodes(_infoHash);
     reply =
       _factory->createGetPeersReplyMessage(_remoteNode, nodes, token,
 					   _transactionID);
@@ -85,7 +88,7 @@ Dictionary* DHTGetPeersMessage::getArgument()
   return a;
 }
 
-string DHTGetPeersMessage::getMessageType() const
+std::string DHTGetPeersMessage::getMessageType() const
 {
   return "get_peers";
 }
@@ -101,3 +104,5 @@ void DHTGetPeersMessage::setTokenTracker(const WeakHandle<DHTTokenTracker>& toke
 {
   _tokenTracker = tokenTracker;
 }
+
+} // namespace aria2
diff --git a/src/DHTGetPeersMessage.h b/src/DHTGetPeersMessage.h
index 926a0430..634e1e1e 100644
--- a/src/DHTGetPeersMessage.h
+++ b/src/DHTGetPeersMessage.h
@@ -37,8 +37,11 @@
 
 #include "DHTQueryMessage.h"
 #include "DHTConstants.h"
-#include "DHTPeerAnnounceStorageDecl.h"
-#include "DHTTokenTrackerDecl.h"
+
+namespace aria2 {
+
+class DHTPeerAnnounceStorage;
+class DHTTokenTracker;
 
 class DHTGetPeersMessage:public DHTQueryMessage {
 private:
@@ -48,10 +51,10 @@ private:
 
   WeakHandle<DHTTokenTracker> _tokenTracker;
 public:
-  DHTGetPeersMessage(const DHTNodeHandle& localNode,
-		     const DHTNodeHandle& remoteNode,
+  DHTGetPeersMessage(const SharedHandle<DHTNode>& localNode,
+		     const SharedHandle<DHTNode>& remoteNode,
 		     const unsigned char* infoHash,
-		     const string& transactionID = "");
+		     const std::string& transactionID = "");
 
   virtual ~DHTGetPeersMessage();
 
@@ -59,7 +62,7 @@ public:
 
   virtual Dictionary* getArgument();
   
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
@@ -74,4 +77,6 @@ public:
   void setTokenTracker(const WeakHandle<DHTTokenTracker>& tokenTracker);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_GET_PEERS_MESSAGE_H_
diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc
index 7bdf421e..7937c4b6 100644
--- a/src/DHTGetPeersReplyMessage.cc
+++ b/src/DHTGetPeersReplyMessage.cc
@@ -45,11 +45,14 @@
 #include "PeerMessageUtil.h"
 #include "Peer.h"
 #include "DHTUtil.h"
+#include <cstring>
 
-DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const DHTNodeHandle& localNode,
-						 const DHTNodeHandle& remoteNode,
-						 const string& token,
-						 const string& transactionID):
+namespace aria2 {
+
+DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const SharedHandle<DHTNode>& localNode,
+						 const SharedHandle<DHTNode>& remoteNode,
+						 const std::string& token,
+						 const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID),
   _token(token) {}
 
@@ -69,8 +72,8 @@ Dictionary* DHTGetPeersReplyMessage::getResponse()
   if(_values.size()) {
     List* valuesList = new List();
     r->put("values", valuesList);
-    for(Peers::const_iterator i = _values.begin(); i != _values.end(); ++i) {
-      PeerHandle peer = *i;
+    for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin(); i != _values.end(); ++i) {
+      const SharedHandle<Peer>& peer = *i;
       char buffer[6];
       if(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)) {
 	valuesList->add(new Data(buffer, sizeof(buffer)));
@@ -79,8 +82,8 @@ Dictionary* DHTGetPeersReplyMessage::getResponse()
   } else {
     size_t offset = 0;
     char buffer[DHTBucket::K*26];
-    for(DHTNodes::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
-      DHTNodeHandle node = *i;
+    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+      SharedHandle<DHTNode> node = *i;
       memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH);
       if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) {
 	offset += 26;
@@ -91,29 +94,31 @@ Dictionary* DHTGetPeersReplyMessage::getResponse()
   return r;
 }
 
-string DHTGetPeersReplyMessage::getMessageType() const
+std::string DHTGetPeersReplyMessage::getMessageType() const
 {
   return "get_peers";
 }
 
 void DHTGetPeersReplyMessage::validate() const {}
 
-const DHTNodes& DHTGetPeersReplyMessage::getClosestKNodes() const
+const std::deque<SharedHandle<DHTNode> >& DHTGetPeersReplyMessage::getClosestKNodes() const
 {
   return _closestKNodes;
 }
 
-void DHTGetPeersReplyMessage::setClosestKNodes(const DHTNodes& closestKNodes)
+void DHTGetPeersReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
 {
   _closestKNodes = closestKNodes;
 }
 
-const Peers& DHTGetPeersReplyMessage::getValues() const
+const std::deque<SharedHandle<Peer> >& DHTGetPeersReplyMessage::getValues() const
 {
   return _values;
 }
 
-void DHTGetPeersReplyMessage::setValues(const Peers& peers)
+void DHTGetPeersReplyMessage::setValues(const std::deque<SharedHandle<Peer> >& peers)
 {
   _values = peers;
 }
+
+} // namespace aria2
diff --git a/src/DHTGetPeersReplyMessage.h b/src/DHTGetPeersReplyMessage.h
index 0d9a88ac..7b365ad2 100644
--- a/src/DHTGetPeersReplyMessage.h
+++ b/src/DHTGetPeersReplyMessage.h
@@ -37,43 +37,49 @@
 
 #include "DHTResponseMessage.h"
 #include "DHTConstants.h"
-#include "PeerDecl.h"
+#include <deque>
+
+namespace aria2 {
+
+class Peer;
 
 class DHTGetPeersReplyMessage:public DHTResponseMessage {
 private:
-  string _token;
+  std::string _token;
 
-  DHTNodes _closestKNodes;
+  std::deque<SharedHandle<DHTNode> > _closestKNodes;
 
-  Peers _values;
+  std::deque<SharedHandle<Peer> > _values;
 public:
-  DHTGetPeersReplyMessage(const DHTNodeHandle& localNode,
-			  const DHTNodeHandle& remoteNode,
-			  const string& token,
-			  const string& transactionID);
+  DHTGetPeersReplyMessage(const SharedHandle<DHTNode>& localNode,
+			  const SharedHandle<DHTNode>& remoteNode,
+			  const std::string& token,
+			  const std::string& transactionID);
 
   virtual ~DHTGetPeersReplyMessage();
 
   virtual void doReceivedAction();
 
   virtual Dictionary* getResponse();
-  
-  virtual string getMessageType() const;
+
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
-  const DHTNodes& getClosestKNodes() const;
+  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const;
 
-  const Peers& getValues() const;
+  const std::deque<SharedHandle<Peer> >& getValues() const;
 
-  void setClosestKNodes(const DHTNodes& closestKNodes);
+  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
 
-  void setValues(const Peers& peers);
+  void setValues(const std::deque<SharedHandle<Peer> >& peers);
   
-  const string& getToken() const
+  const std::string& getToken() const
   {
     return _token;
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_GET_PEERS_REPLY_MESSAGE_H_
diff --git a/src/DHTIDCloser.h b/src/DHTIDCloser.h
index 978f4e01..4bbe99f1 100644
--- a/src/DHTIDCloser.h
+++ b/src/DHTIDCloser.h
@@ -35,10 +35,13 @@
 #ifndef _D_DHT_ID_CLOSER_H_
 #define _D_DHT_ID_CLOSER_H_
 
-#include "DHTNodeLookupEntryDecl.h"
+#include "common.h"
+#include "DHTNodeLookupEntry.h"
 #include "DHTConstants.h"
 #include "XORCloser.h"
 
+namespace aria2 {
+
 class DHTIDCloser {
 private:
   const unsigned char* _targetID;
@@ -47,11 +50,13 @@ private:
 public:
   DHTIDCloser(const unsigned char* targetID):_closer(targetID, DHT_ID_LENGTH) {}
 
-  bool operator()(const DHTNodeLookupEntryHandle& m1,
-		  const DHTNodeLookupEntryHandle& m2) const
+  bool operator()(const SharedHandle<DHTNodeLookupEntry>& m1,
+		  const SharedHandle<DHTNodeLookupEntry>& m2) const
   {
     return _closer(m1->_node->getID(), m2->_node->getID());
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ID_CLOSER_H_
diff --git a/src/DHTInteractionCommand.cc b/src/DHTInteractionCommand.cc
index 068fdafe..09d9174c 100644
--- a/src/DHTInteractionCommand.cc
+++ b/src/DHTInteractionCommand.cc
@@ -42,6 +42,9 @@
 #include "Socket.h"
 #include "message.h"
 #include "RequestGroupMan.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 DHTInteractionCommand::DHTInteractionCommand(int32_t cuid, DownloadEngine* e):
   Command(cuid),
@@ -93,17 +96,19 @@ bool DHTInteractionCommand::execute()
   return false;
 }
 
-void DHTInteractionCommand::setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher)
+void DHTInteractionCommand::setMessageDispatcher(const SharedHandle<DHTMessageDispatcher>& dispatcher)
 {
   _dispatcher = dispatcher;
 }
 
-void DHTInteractionCommand::setMessageReceiver(const DHTMessageReceiverHandle& receiver)
+void DHTInteractionCommand::setMessageReceiver(const SharedHandle<DHTMessageReceiver>& receiver)
 {
   _receiver = receiver;
 }
 
-void DHTInteractionCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTInteractionCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
+
+} // namespace aria2
diff --git a/src/DHTInteractionCommand.h b/src/DHTInteractionCommand.h
index 40e6d0fb..8363efa7 100644
--- a/src/DHTInteractionCommand.h
+++ b/src/DHTInteractionCommand.h
@@ -36,22 +36,24 @@
 #define _D_DHT_INTERACTION_COMMAND_H_
 
 #include "Command.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageReceiverDecl.h"
-#include "DHTTaskQueueDecl.h"
+#include "SharedHandle.h"
 
+namespace aria2 {
+
+class DHTMessageDispatcher;
+class DHTMessageReceiver;
+class DHTTaskQueue;
 class DownloadEngine;
 class SocketCore;
-typedef SharedHandle<SocketCore> SocketHandle;
 
 class DHTInteractionCommand:public Command {
 protected:
   DownloadEngine* _e;
 private:
-  DHTMessageDispatcherHandle _dispatcher;
-  DHTMessageReceiverHandle _receiver;
-  DHTTaskQueueHandle _taskQueue;
-  SocketHandle _readCheckSocket;
+  SharedHandle<DHTMessageDispatcher> _dispatcher;
+  SharedHandle<DHTMessageReceiver> _receiver;
+  SharedHandle<DHTTaskQueue> _taskQueue;
+  SharedHandle<SocketCore> _readCheckSocket;
 
 public:
   DHTInteractionCommand(int32_t cuid, DownloadEngine* e);
@@ -60,15 +62,17 @@ public:
 
   virtual bool execute();
 
-  void setReadCheckSocket(const SocketHandle& socket);
+  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
 
-  void disableReadCheckSocket(const SocketHandle& socket);
+  void disableReadCheckSocket(const SharedHandle<SocketCore>& socket);
 
-  void setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher);
+  void setMessageDispatcher(const SharedHandle<DHTMessageDispatcher>& dispatcher);
 
-  void setMessageReceiver(const DHTMessageReceiverHandle& receiver);
+  void setMessageReceiver(const SharedHandle<DHTMessageReceiver>& receiver);
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_INTERACTION_COMMAND_H_
diff --git a/src/DHTMessage.cc b/src/DHTMessage.cc
index ac32e691..a77cf97d 100644
--- a/src/DHTMessage.cc
+++ b/src/DHTMessage.cc
@@ -36,9 +36,11 @@
 #include "DHTNode.h"
 #include "DHTUtil.h"
 
-DHTMessage::DHTMessage(const DHTNodeHandle& localNode,
-		       const DHTNodeHandle& remoteNode,
-		       const string& transactionID):
+namespace aria2 {
+
+DHTMessage::DHTMessage(const SharedHandle<DHTNode>& localNode,
+		       const SharedHandle<DHTNode>& remoteNode,
+		       const std::string& transactionID):
   _localNode(localNode), _remoteNode(remoteNode), _transactionID(transactionID)
 {
   if(transactionID.empty()) {
@@ -52,16 +54,18 @@ void DHTMessage::generateTransactionID()
 {
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  _transactionID = string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  _transactionID = std::string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 }
 
-DHTNodeHandle DHTMessage::getLocalNode() const
+SharedHandle<DHTNode> DHTMessage::getLocalNode() const
 {
   return _localNode;
 }
 
-DHTNodeHandle DHTMessage::getRemoteNode() const
+SharedHandle<DHTNode> DHTMessage::getRemoteNode() const
 {
   return _remoteNode;
 }
 
+
+} // namespace aria2
diff --git a/src/DHTMessage.h b/src/DHTMessage.h
index e2417624..dcafc645 100644
--- a/src/DHTMessage.h
+++ b/src/DHTMessage.h
@@ -36,33 +36,37 @@
 #define _D_DHT_MESSAGE_H_
 
 #include "common.h"
-#include "DHTMessageDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
+
+class DHTNode;
 
 class DHTMessage {
 protected:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
-  DHTNodeHandle _remoteNode;
+  SharedHandle<DHTNode> _remoteNode;
 
-  string _transactionID;
+  std::string _transactionID;
 
   void generateTransactionID();
 public:
-  DHTMessage(const DHTNodeHandle& localNode,
-	     const DHTNodeHandle& remoteNode,
-	     const string& transactionID = "");
+  DHTMessage(const SharedHandle<DHTNode>& localNode,
+	     const SharedHandle<DHTNode>& remoteNode,
+	     const std::string& transactionID = "");
 
   virtual ~DHTMessage();
 
-  const string& getTransactionID() const
+  const std::string& getTransactionID() const
   {
     return _transactionID;
   }
 
-  DHTNodeHandle getLocalNode() const;
+  SharedHandle<DHTNode> getLocalNode() const;
 
-  DHTNodeHandle getRemoteNode() const;
+  SharedHandle<DHTNode> getRemoteNode() const;
 
   virtual void doReceivedAction() = 0;
 
@@ -72,9 +76,11 @@ public:
 
   virtual void validate() const = 0;
   
-  virtual string getMessageType() const = 0;
+  virtual std::string getMessageType() const = 0;
 
-  virtual string toString() const = 0;
+  virtual std::string toString() const = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_H_
diff --git a/src/DHTMessageCallback.h b/src/DHTMessageCallback.h
index 56fbfd01..c5a802ca 100644
--- a/src/DHTMessageCallback.h
+++ b/src/DHTMessageCallback.h
@@ -36,17 +36,22 @@
 #define _D_DHT_MESSAGE_CALLBACK_H_
 
 #include "common.h"
-#include "DHTMessageCallbackDecl.h"
-#include "DHTMessageDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTMessage;
+class DHTNode;
 
 class DHTMessageCallback {
 public:
   virtual ~DHTMessageCallback() {}
 
-  virtual void onReceived(const DHTMessageHandle& message) = 0;
+  virtual void onReceived(const SharedHandle<DHTMessage>& message) = 0;
 
-  virtual void onTimeout(const DHTNodeHandle& remoteNode) = 0;
+  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_CALLBACK_H_
diff --git a/src/DHTMessageCallbackDecl.h b/src/DHTMessageCallbackDecl.h
deleted file mode 100644
index f0fadcee..00000000
--- a/src/DHTMessageCallbackDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_CALLBACK_DECL_H_
-#define _D_DHT_MESSAGE_CALLBACK_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTMessageCallback;
-typedef SharedHandle<DHTMessageCallback> DHTMessageCallbackHandle;
-
-#endif // _D_DHT_MESSAGE_CALLBACK_DECL_H_
diff --git a/src/DHTMessageCallbackImpl.cc b/src/DHTMessageCallbackImpl.cc
index a6e96545..b937fbcd 100644
--- a/src/DHTMessageCallbackImpl.cc
+++ b/src/DHTMessageCallbackImpl.cc
@@ -35,21 +35,26 @@
 #include "DHTMessageCallbackImpl.h"
 #include "DHTMessage.h"
 #include "DHTNode.h"
+#include "DHTMessageCallbackListener.h"
+
+namespace aria2 {
  
 DHTMessageCallbackImpl::DHTMessageCallbackImpl(const WeakHandle<DHTMessageCallbackListener>& listener):_listener(listener) {}
 
 DHTMessageCallbackImpl::~DHTMessageCallbackImpl() {}
 
-void DHTMessageCallbackImpl::onReceived(const DHTMessageHandle& message)
+void DHTMessageCallbackImpl::onReceived(const SharedHandle<DHTMessage>& message)
 {
   if(!_listener.isNull()) {
     _listener->onReceived(message);
   }
 }
 
-void DHTMessageCallbackImpl::onTimeout(const DHTNodeHandle& remoteNode)
+void DHTMessageCallbackImpl::onTimeout(const SharedHandle<DHTNode>& remoteNode)
 {
   if(!_listener.isNull()) {
     _listener->onTimeout(remoteNode);
   }
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageCallbackImpl.h b/src/DHTMessageCallbackImpl.h
index b7a2e912..b631e768 100644
--- a/src/DHTMessageCallbackImpl.h
+++ b/src/DHTMessageCallbackImpl.h
@@ -36,7 +36,10 @@
 #define _D_DHT_MESSAGE_CALLBACK_IMPL_H_
 
 #include "DHTMessageCallback.h"
-#include "DHTMessageCallbackListener.h"
+
+namespace aria2 {
+
+class DHTMessageCallbackListener;
 
 class DHTMessageCallbackImpl:public DHTMessageCallback {
 private:
@@ -47,9 +50,11 @@ public:
 
   virtual ~DHTMessageCallbackImpl();
 
-  virtual void onReceived(const DHTMessageHandle& message);
+  virtual void onReceived(const SharedHandle<DHTMessage>& message);
 
-  virtual void onTimeout(const DHTNodeHandle& remoteNode);
+  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_CALLBACK_IMPL_H_
diff --git a/src/DHTMessageCallbackListener.h b/src/DHTMessageCallbackListener.h
index 6a77a529..4a96af30 100644
--- a/src/DHTMessageCallbackListener.h
+++ b/src/DHTMessageCallbackListener.h
@@ -36,16 +36,22 @@
 #define _D_DHT_MESSAGE_CALLBACK_LISTENER_H_
 
 #include "common.h"
-#include "DHTMessageDecl.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTMessage;
+class DHTNode;
 
 class DHTMessageCallbackListener {
 public:
   virtual ~DHTMessageCallbackListener() {}
 
-  virtual void onReceived(const DHTMessageHandle& message) = 0;
+  virtual void onReceived(const SharedHandle<DHTMessage>& message) = 0;
 
-  virtual void onTimeout(const DHTNodeHandle& remoteNode) = 0;
+  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_CALLBACK_LISTENER_H_
diff --git a/src/DHTMessageDecl.h b/src/DHTMessageDecl.h
deleted file mode 100644
index 0d5c7351..00000000
--- a/src/DHTMessageDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_DECL_H_
-#define _D_DHT_MESSAGE_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTMessage;
-typedef SharedHandle<DHTMessage> DHTMessageHandle;
-typedef std::deque<DHTMessageHandle> DHTMessages;
-
-#endif // _D_DHT_MESSAGE_DECL_H_
diff --git a/src/DHTMessageDispatcher.cc b/src/DHTMessageDispatcher.cc
index 73be8beb..68055e7c 100644
--- a/src/DHTMessageDispatcher.cc
+++ b/src/DHTMessageDispatcher.cc
@@ -39,26 +39,29 @@
 #include "DHTMessageTracker.h"
 #include "RecoverableException.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "DHTConstants.h"
 
-DHTMessageDispatcher::DHTMessageDispatcher(const DHTMessageTrackerHandle& tracker):_tracker(tracker), _logger(LogFactory::getInstance()) {}
+namespace aria2 {
+
+DHTMessageDispatcher::DHTMessageDispatcher(const SharedHandle<DHTMessageTracker>& tracker):_tracker(tracker), _logger(LogFactory::getInstance()) {}
 
 DHTMessageDispatcher::~DHTMessageDispatcher() {}
 
-void DHTMessageDispatcher::addMessageToQueue(const DHTMessageHandle& message,
+void DHTMessageDispatcher::addMessageToQueue(const SharedHandle<DHTMessage>& message,
 					     time_t timeout,
-					     const DHTMessageCallbackHandle& callback)
+					     const SharedHandle<DHTMessageCallback>& callback)
 {
   _messageQueue.push_back(new DHTMessageEntry(message, timeout, callback));
 }
 
-void DHTMessageDispatcher::addMessageToQueue(const DHTMessageHandle& message,
-					     const DHTMessageCallbackHandle& callback)
+void DHTMessageDispatcher::addMessageToQueue(const SharedHandle<DHTMessage>& message,
+					     const SharedHandle<DHTMessageCallback>& callback)
 {
   addMessageToQueue(message, DHT_MESSAGE_TIMEOUT, callback);
 }
 
-void DHTMessageDispatcher::sendMessage(const DHTMessageEntryHandle& entry)
+void DHTMessageDispatcher::sendMessage(const SharedHandle<DHTMessageEntry>& entry)
 {
   try {
     entry->_message->send();
@@ -74,7 +77,9 @@ void DHTMessageDispatcher::sendMessage(const DHTMessageEntryHandle& entry)
 
 void DHTMessageDispatcher::sendMessages()
 {
-  for(DHTMessageEntries::iterator itr = _messageQueue.begin(); itr != _messageQueue.end(); ++itr) {
+  // TODO I can't use bind1st and mem_fun here because bind1st cannot bind a
+  // function which takes a reference as an argument..
+  for(std::deque<SharedHandle<DHTMessageEntry> >::iterator itr = _messageQueue.begin(); itr != _messageQueue.end(); ++itr) {
     sendMessage(*itr);
   }
   _messageQueue.clear();
@@ -84,3 +89,5 @@ size_t DHTMessageDispatcher::countMessageInQueue() const
 {
   return _messageQueue.size();
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageDispatcher.h b/src/DHTMessageDispatcher.h
index b2c63a4a..85863c9e 100644
--- a/src/DHTMessageDispatcher.h
+++ b/src/DHTMessageDispatcher.h
@@ -36,38 +36,43 @@
 #define _D_DHT_MESSAGE_DISPATCHER_H_
 
 #include "common.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageTrackerDecl.h"
-#include "DHTMessageCallbackDecl.h"
-#include "DHTMessageEntryDecl.h"
-#include "DHTMessageDecl.h"
+#include "SharedHandle.h"
+#include <deque>
 
+namespace aria2 {
+
+class DHTMessageTracker;
+class DHTMessageCallback;
+class DHTMessageEntry;
+class DHTMessage;
 class Logger;
 
 class DHTMessageDispatcher {
 private:
-  DHTMessageTrackerHandle _tracker;
+  SharedHandle<DHTMessageTracker> _tracker;
 
-  DHTMessageEntries _messageQueue;
+  std::deque<SharedHandle<DHTMessageEntry> > _messageQueue;
 
   const Logger* _logger;
 
-  void sendMessage(const DHTMessageEntryHandle& msg);
+  void sendMessage(const SharedHandle<DHTMessageEntry>& msg);
 public:
-  DHTMessageDispatcher(const DHTMessageTrackerHandle& tracker);
+  DHTMessageDispatcher(const SharedHandle<DHTMessageTracker>& tracker);
 
   ~DHTMessageDispatcher();
 
-  void addMessageToQueue(const DHTMessageHandle& message,
+  void addMessageToQueue(const SharedHandle<DHTMessage>& message,
 			 time_t timeout,
-			 const DHTMessageCallbackHandle& callback = 0);
+			 const SharedHandle<DHTMessageCallback>& callback = 0);
 
-  void addMessageToQueue(const DHTMessageHandle& message,
-			 const DHTMessageCallbackHandle& callback = 0);
+  void addMessageToQueue(const SharedHandle<DHTMessage>& message,
+			 const SharedHandle<DHTMessageCallback>& callback = 0);
 
   void sendMessages();
 
   size_t countMessageInQueue() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_DISPATCHER_H_
diff --git a/src/DHTMessageDispatcherDecl.h b/src/DHTMessageDispatcherDecl.h
deleted file mode 100644
index e3836347..00000000
--- a/src/DHTMessageDispatcherDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_DISPATCHER_DECL_H_
-#define _D_DHT_MESSAGE_DISPATCHER_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTMessageDispatcher;
-typedef SharedHandle<DHTMessageDispatcher> DHTMessageDispatcherHandle;
-
-#endif // _D_DHT_MESSAGE_DISPATCHER_DECL_H_
diff --git a/src/DHTMessageEntry.cc b/src/DHTMessageEntry.cc
index c3882f3c..5667ed4b 100644
--- a/src/DHTMessageEntry.cc
+++ b/src/DHTMessageEntry.cc
@@ -36,9 +36,15 @@
 #include "DHTMessage.h"
 #include "DHTMessageCallback.h"
 
-DHTMessageEntry::DHTMessageEntry(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback):
+namespace aria2 {
+
+DHTMessageEntry::DHTMessageEntry(const SharedHandle<DHTMessage>& message,
+				 time_t timeout,
+				 const SharedHandle<DHTMessageCallback>& callback):
   _message(message),
   _timeout(timeout),
   _callback(callback) {}
 
 DHTMessageEntry::~DHTMessageEntry() {}
+
+} // namespace aria2
diff --git a/src/DHTMessageEntry.h b/src/DHTMessageEntry.h
index 46e8a261..2253e70d 100644
--- a/src/DHTMessageEntry.h
+++ b/src/DHTMessageEntry.h
@@ -36,19 +36,26 @@
 #define _D_DHT_MESSAGE_ENTRY_H_
 
 #include "common.h"
-#include "DHTMessageEntryDecl.h"
-#include "DHTMessageDecl.h"
-#include "DHTMessageCallbackDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTMessage;
+class DHTMessageCallback;
 
 class DHTMessageEntry {
 public:
-  DHTMessageHandle _message;
+  SharedHandle<DHTMessage> _message;
   time_t _timeout;
-  DHTMessageCallbackHandle _callback;
+  SharedHandle<DHTMessageCallback> _callback;
 
-  DHTMessageEntry(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback);
+  DHTMessageEntry(const SharedHandle<DHTMessage>& message,
+		  time_t timeout,
+		  const SharedHandle<DHTMessageCallback>& callback);
 
   ~DHTMessageEntry();
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_ENTRY_H_
diff --git a/src/DHTMessageEntryDecl.h b/src/DHTMessageEntryDecl.h
deleted file mode 100644
index 2c80a9dd..00000000
--- a/src/DHTMessageEntryDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_ENTRY_DECL_H_
-#define _D_DHT_MESSAGE_ENTRY_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTMessageEntry;
-typedef SharedHandle<DHTMessageEntry> DHTMessageEntryHandle;
-typedef std::deque<DHTMessageEntryHandle> DHTMessageEntries;
-
-#endif // _D_DHT_MESSAGE_ENTRY_DECL_H_
diff --git a/src/DHTMessageFactory.h b/src/DHTMessageFactory.h
index 460019ab..fe9a71d6 100644
--- a/src/DHTMessageFactory.h
+++ b/src/DHTMessageFactory.h
@@ -36,75 +36,82 @@
 #define _D_DHT_MESSAGE_FACTORY_H_
 
 #include "common.h"
-#include "DHTMessageDecl.h"
-#include "DHTNodeDecl.h"
-#include "PeerDecl.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
 
+namespace aria2 {
+
+class DHTMessage;
+class DHTNode;
+class Peer;
 class Dictionary;
 
 class DHTMessageFactory {
 public:
   virtual ~DHTMessageFactory() {}
 
-  virtual DHTMessageHandle
+  virtual SharedHandle<DHTMessage>
   createQueryMessage(const Dictionary* d,
-		     const string& ipaddr, uint16_t port) = 0;
+		     const std::string& ipaddr, uint16_t port) = 0;
 
-  virtual DHTMessageHandle
-  createResponseMessage(const string& messageType,
+  virtual SharedHandle<DHTMessage>
+  createResponseMessage(const std::string& messageType,
 			const Dictionary* d,
-			const DHTNodeHandle& remoteNode) = 0;
+			const SharedHandle<DHTNode>& remoteNode) = 0;
 
-  virtual DHTMessageHandle
-  createPingMessage(const DHTNodeHandle& remoteNode,
-		    const string& transactionID = "") = 0;
+  virtual SharedHandle<DHTMessage>
+  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+		    const std::string& transactionID = "") = 0;
 
-  virtual DHTMessageHandle
-  createPingReplyMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			 const unsigned char* id,
-			 const string& transactionID) = 0;
+			 const std::string& transactionID) = 0;
 
-  virtual DHTMessageHandle
-  createFindNodeMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* targetNodeID,
-			const string& transactionID = "") = 0;
+			const std::string& transactionID = "") = 0;
 
-  virtual DHTMessageHandle
-  createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& transactionID) = 0;
+  virtual SharedHandle<DHTMessage>
+  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& transactionID) = 0;
 
-  virtual DHTMessageHandle
-  createGetPeersMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* infoHash,
-			const string& transactionID = "") = 0;
+			const std::string& transactionID = "") = 0;
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& token,
-			     const string& transactionID) = 0;
+  virtual SharedHandle<DHTMessage>
+  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& token,
+			     const std::string& transactionID) = 0;
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const Peers& peers,
-			     const string& token,
-			     const 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;
 
-  virtual DHTMessageHandle
-  createAnnouncePeerMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
 			    const unsigned char* infoHash,
 			    uint16_t tcpPort,
-			    const string& token,
-			    const string& transactionID = "") = 0;
+			    const std::string& token,
+			    const std::string& transactionID = "") = 0;
 
-  virtual DHTMessageHandle
-  createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode,
-				 const string& transactionID) = 0;
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+				 const std::string& transactionID) = 0;
 
-  virtual DHTMessageHandle
-  createUnknownMessage(const char* data, size_t length, const string& ipaddr,
+  virtual SharedHandle<DHTMessage>
+  createUnknownMessage(const char* data, size_t length, const std::string& ipaddr,
 		       uint16_t port) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_FACTORY_H_
diff --git a/src/DHTMessageFactoryDecl.h b/src/DHTMessageFactoryDecl.h
deleted file mode 100644
index 131d1053..00000000
--- a/src/DHTMessageFactoryDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_FACTORY_DECL_H_
-#define _D_DHT_MESSAGE_FACTORY_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTMessageFactory;
-typedef SharedHandle<DHTMessageFactory> DHTMessageFactoryHandle;
-
-#endif // _D_DHT_MESSAGE_FACTORY_DECL_H_
diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc
index b3ffe51c..6d5552d3 100644
--- a/src/DHTMessageFactoryImpl.cc
+++ b/src/DHTMessageFactoryImpl.cc
@@ -57,16 +57,20 @@
 #include "BtRuntime.h"
 #include "Util.h"
 #include "Peer.h"
+#include <cstring>
+#include <utility>
+
+namespace aria2 {
 
 DHTMessageFactoryImpl::DHTMessageFactoryImpl():_localNode(0),
 					       _logger(LogFactory::getInstance()) {}
 
 DHTMessageFactoryImpl::~DHTMessageFactoryImpl() {}
 
-DHTNodeHandle
-DHTMessageFactoryImpl::getRemoteNode(const unsigned char* id, const string& ipaddr, uint16_t port) const
+SharedHandle<DHTNode>
+DHTMessageFactoryImpl::getRemoteNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const
 {
-  DHTNodeHandle node = _routingTable->getNode(id, ipaddr, port);
+  SharedHandle<DHTNode> node = _routingTable->getNode(id, ipaddr, port);
   if(node.isNull()) {
     node = new DHTNode(id);
     node->setIPAddress(ipaddr);
@@ -75,7 +79,7 @@ DHTMessageFactoryImpl::getRemoteNode(const unsigned char* id, const string& ipad
   return node;
 }
 
-static const Dictionary* getDictionary(const Dictionary* d, const string& key)
+static const Dictionary* getDictionary(const Dictionary* d, const std::string& key)
 {
   const Dictionary* c = dynamic_cast<const Dictionary*>(d->get(key));
   if(c) {
@@ -85,7 +89,7 @@ static const Dictionary* getDictionary(const Dictionary* d, const string& key)
   }
 }
 
-static const Data* getData(const Dictionary* d, const string& key)
+static const Data* getData(const Dictionary* d, const std::string& key)
 {
   const Data* c = dynamic_cast<const Data*>(d->get(key));
   if(c) {
@@ -95,7 +99,7 @@ static const Data* getData(const Dictionary* d, const string& key)
   }
 }
 
-static const List* getList(const Dictionary* d, const string& key)
+static const List* getList(const Dictionary* d, const std::string& key)
 {
   const List* l = dynamic_cast<const List*>(d->get(key));
   if(l) {
@@ -131,8 +135,8 @@ void DHTMessageFactoryImpl::validatePort(const Data* i) const
   }
 }
 
-DHTMessageHandle DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d,
-							   const string& ipaddr,
+SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d,
+							   const std::string& ipaddr,
 							   uint16_t port)
 {
   const Data* q = getData(d, "q");
@@ -144,9 +148,9 @@ DHTMessageHandle DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d,
   }
   const Data* id = getData(getDictionary(d, "a"), "id");
   validateID(id);
-  DHTNodeHandle remoteNode = getRemoteNode((const unsigned char*)id->toString().c_str(), ipaddr, port);
-  string messageType = q->toString();
-  string transactionID = t->toString();
+  SharedHandle<DHTNode> remoteNode = getRemoteNode((const unsigned char*)id->toString().c_str(), ipaddr, port);
+  std::string messageType = q->toString();
+  std::string transactionID = t->toString();
   if(messageType == "ping") {
     return createPingMessage(remoteNode, transactionID);
   } else if(messageType == "find_node") {
@@ -177,9 +181,9 @@ DHTMessageHandle DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d,
   }
 }
 
-DHTMessageHandle DHTMessageFactoryImpl::createResponseMessage(const string& messageType,
+SharedHandle<DHTMessage> DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
 							      const Dictionary* d,
-							      const DHTNodeHandle& remoteNode)
+							      const SharedHandle<DHTNode>& remoteNode)
 {
   const Data* t = getData(d, "t");
   const Data* y = getData(d, "y");
@@ -193,7 +197,7 @@ DHTMessageHandle DHTMessageFactoryImpl::createResponseMessage(const string& mess
   validateID(id);
   validateIDMatch(remoteNode->getID(),
 		      (const unsigned char*)id->toString().c_str());
-  string transactionID = t->toString();
+  std::string transactionID = t->toString();
   if(messageType == "ping") {
     return createPingReplyMessage(remoteNode, (const unsigned char*)id->getData(), transactionID);
   } else if(messageType == "find_node") {
@@ -225,37 +229,37 @@ void DHTMessageFactoryImpl::setCommonProperty(const SharedHandle<DHTAbstractMess
   m->setMessageFactory(this);
 }
 
-DHTMessageHandle DHTMessageFactoryImpl::createPingMessage(const DHTNodeHandle& remoteNode, const string& transactionID)
+SharedHandle<DHTMessage> DHTMessageFactoryImpl::createPingMessage(const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID)
 {
   SharedHandle<DHTPingMessage> m = new DHTPingMessage(_localNode, remoteNode, transactionID);
   setCommonProperty(m);
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createPingReplyMessage(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 					      const unsigned char* id,
-					      const string& transactionID)
+					      const std::string& transactionID)
 {
   SharedHandle<DHTPingReplyMessage> m = new DHTPingReplyMessage(_localNode, remoteNode, id, transactionID);
   setCommonProperty(m);
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createFindNodeMessage(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
 					     const unsigned char* targetNodeID,
-					     const string& transactionID)
+					     const std::string& transactionID)
 {
   SharedHandle<DHTFindNodeMessage> m = new DHTFindNodeMessage(_localNode, remoteNode, targetNodeID, transactionID);
   setCommonProperty(m);
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
-						  const DHTNodes& closestKNodes,
-						  const string& transactionID)
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+						  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+						  const std::string& transactionID)
 {
   SharedHandle<DHTFindNodeReplyMessage> m = new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID);
   m->setClosestKNodes(closestKNodes);
@@ -263,15 +267,15 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage(const DHTNodeHandle& remoteNod
   return m;
 }
 
-DHTNodes DHTMessageFactoryImpl::extractNodes(const char* src, size_t length)
+std::deque<SharedHandle<DHTNode> > DHTMessageFactoryImpl::extractNodes(const char* src, size_t length)
 {
   if(length%26 != 0) {
     throw new DlAbortEx("Nodes length is not multiple of 26");
   }
-  DHTNodes nodes;
+  std::deque<SharedHandle<DHTNode> > nodes;
   for(size_t offset = 0; offset < length; offset += 26) {
-    DHTNodeHandle node = new DHTNode(reinterpret_cast<const unsigned char*>(src+offset));
-    pair<string, uint16_t> addr =
+    SharedHandle<DHTNode> node = new DHTNode(reinterpret_cast<const unsigned char*>(src+offset));
+    std::pair<std::string, uint16_t> addr =
       PeerMessageUtil::unpackcompact(src+offset+DHT_ID_LENGTH);
     node->setIPAddress(addr.first);
     node->setPort(addr.second);
@@ -280,20 +284,20 @@ DHTNodes DHTMessageFactoryImpl::extractNodes(const char* src, size_t length)
   return nodes;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 						  const Dictionary* d,
-						  const string& transactionID)
+						  const std::string& transactionID)
 {
   const Data* nodesData = getData(getDictionary(d, "r"), "nodes");
-  DHTNodes nodes = extractNodes(nodesData->getData(), nodesData->getLen());
+  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData->getData(), nodesData->getLen());
   return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createGetPeersMessage(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
 					     const unsigned char* infoHash,
-					     const string& transactionID)
+					     const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersMessage> m = new DHTGetPeersMessage(_localNode,
 							      remoteNode,
@@ -305,43 +309,44 @@ DHTMessageFactoryImpl::createGetPeersMessage(const DHTNodeHandle& remoteNode,
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
 							   const Dictionary* d,
-							   const string& transactionID)
+							   const std::string& transactionID)
 {
   const Dictionary* r = getDictionary(d, "r");
   const Data* nodesData = getData(r, "nodes");
-  DHTNodes nodes = extractNodes(nodesData->getData(), nodesData->getLen());
+  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData->getData(), nodesData->getLen());
   const Data* token = getData(r, "token");
   return createGetPeersReplyMessage(remoteNode, nodes, token->toString(),
 				    transactionID);
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-						  const DHTNodes& closestKNodes,
-						  const string& token,
-						  const string& transactionID)
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+						  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+						  const std::string& token,
+						  const std::string& transactionID)
 {
-  SharedHandle<DHTGetPeersReplyMessage> m = new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID);
+  SharedHandle<DHTGetPeersReplyMessage> m =
+    new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID);
   m->setClosestKNodes(closestKNodes);
   setCommonProperty(m);
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,
 							    const Dictionary* d,
-							    const string& transactionID)
+							    const std::string& transactionID)
 {
   const Dictionary* r = getDictionary(d, "r");
   const List* valuesList = getList(r, "values");
-  Peers peers;
-  for(MetaList::const_iterator i = valuesList->getList().begin(); i != valuesList->getList().end(); ++i) {
+  std::deque<SharedHandle<Peer> > peers;
+  for(std::deque<MetaEntry*>::const_iterator i = valuesList->getList().begin(); i != valuesList->getList().end(); ++i) {
     const Data* data = dynamic_cast<const Data*>(*i);
     if(data && data->getLen() == 6) {
-      pair<string, uint16_t> addr = PeerMessageUtil::unpackcompact(data->getData());
+      std::pair<std::string, uint16_t> addr = PeerMessageUtil::unpackcompact(data->getData());
       PeerHandle peer = new Peer(addr.first, addr.second);
       peers.push_back(peer);
     }
@@ -351,11 +356,11 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues(const DHTNodeHandle&
 				    transactionID);
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-						  const Peers& values,
-						  const string& token,
-						  const string& transactionID)
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+						  const std::deque<SharedHandle<Peer> >& values,
+						  const std::string& token,
+						  const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersReplyMessage> m = new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID);
   m->setValues(values);
@@ -363,12 +368,12 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage(const DHTNodeHandle& remoteNod
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createAnnouncePeerMessage(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
 						 const unsigned char* infoHash,
 						 uint16_t tcpPort,
-						 const string& token,
-						 const string& transactionID)
+						 const std::string& token,
+						 const std::string& transactionID)
 {
   SharedHandle<DHTAnnouncePeerMessage> m =
     new DHTAnnouncePeerMessage(_localNode, remoteNode, infoHash, tcpPort, token, transactionID);
@@ -378,9 +383,9 @@ DHTMessageFactoryImpl::createAnnouncePeerMessage(const DHTNodeHandle& remoteNode
   return m;
 }
 
-DHTMessageHandle
-DHTMessageFactoryImpl::createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode,
-						      const string& transactionID)
+SharedHandle<DHTMessage>
+DHTMessageFactoryImpl::createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+						      const std::string& transactionID)
 {
   SharedHandle<DHTAnnouncePeerReplyMessage> m =
     new DHTAnnouncePeerReplyMessage(_localNode, remoteNode, transactionID);
@@ -388,9 +393,9 @@ DHTMessageFactoryImpl::createAnnouncePeerReplyMessage(const DHTNodeHandle& remot
   return m;
 }
 
-DHTMessageHandle
+SharedHandle<DHTMessage>
 DHTMessageFactoryImpl::createUnknownMessage(const char* data, size_t length,
-					    const string& ipaddr, uint16_t port)
+					    const std::string& ipaddr, uint16_t port)
 
 {
   SharedHandle<DHTUnknownMessage> m = 
@@ -398,32 +403,34 @@ DHTMessageFactoryImpl::createUnknownMessage(const char* data, size_t length,
   return m;
 }
 
-void DHTMessageFactoryImpl::setRoutingTable(const DHTRoutingTableHandle& routingTable)
+void DHTMessageFactoryImpl::setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable)
 {
   _routingTable = routingTable;
 }
 
-void DHTMessageFactoryImpl::setConnection(const DHTConnectionHandle& connection)
+void DHTMessageFactoryImpl::setConnection(const WeakHandle<DHTConnection>& connection)
 {
   _connection = connection;
 }
 
-void DHTMessageFactoryImpl::setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher)
+void DHTMessageFactoryImpl::setMessageDispatcher(const WeakHandle<DHTMessageDispatcher>& dispatcher)
 {
   _dispatcher = dispatcher;
 }
   
-void DHTMessageFactoryImpl::setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage)
+void DHTMessageFactoryImpl::setPeerAnnounceStorage(const WeakHandle<DHTPeerAnnounceStorage>& storage)
 {
   _peerAnnounceStorage = storage;
 }
 
-void DHTMessageFactoryImpl::setTokenTracker(const DHTTokenTrackerHandle& tokenTracker)
+void DHTMessageFactoryImpl::setTokenTracker(const WeakHandle<DHTTokenTracker>& tokenTracker)
 {
   _tokenTracker = tokenTracker;
 }
 
-void DHTMessageFactoryImpl::setLocalNode(const DHTNodeHandle& localNode)
+void DHTMessageFactoryImpl::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h
index 7f118ff4..2c200552 100644
--- a/src/DHTMessageFactoryImpl.h
+++ b/src/DHTMessageFactoryImpl.h
@@ -36,19 +36,22 @@
 #define _D_DHT_MESSAGE_FACTORY_IMPL_H_
 
 #include "DHTMessageFactory.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTConnectionDecl.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTPeerAnnounceStorageDecl.h"
-#include "DHTTokenTrackerDecl.h"
 
+namespace aria2 {
+
+class DHTConnection;
+class DHTMessageDispatcher;
+class DHTRoutingTable;
+class DHTPeerAnnounceStorage;
+class DHTTokenTracker;
 class Logger;
 class Data;
+class DHTMessage;
 class DHTAbstractMessage;
 
 class DHTMessageFactoryImpl:public DHTMessageFactory {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
   WeakHandle<DHTConnection> _connection;
 
@@ -63,7 +66,7 @@ private:
   const Logger* _logger;
   
   // search node in routingTable. If it is not found, create new one.
-  DHTNodeHandle getRemoteNode(const unsigned char* id, const string& ipaddr, uint16_t port) const;
+  SharedHandle<DHTNode> getRemoteNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
 
   void validateID(const Data* id) const;
 
@@ -71,7 +74,7 @@ private:
 
   void validatePort(const Data* i) const;
 
-  DHTNodes extractNodes(const char* src, size_t length);
+  std::deque<SharedHandle<DHTNode> > extractNodes(const char* src, size_t length);
 
   void setCommonProperty(const SharedHandle<DHTAbstractMessage>& m);
 
@@ -80,93 +83,95 @@ public:
 
   virtual ~DHTMessageFactoryImpl();
 
-  virtual DHTMessageHandle
+  virtual SharedHandle<DHTMessage>
   createQueryMessage(const Dictionary* d,
-		     const string& ipaddr, uint16_t port);
+		     const std::string& ipaddr, uint16_t port);
 
-  virtual DHTMessageHandle
-  createResponseMessage(const string& messageType,
+  virtual SharedHandle<DHTMessage>
+  createResponseMessage(const std::string& messageType,
 			const Dictionary* d,
-			const DHTNodeHandle& remoteNode);
+			const SharedHandle<DHTNode>& remoteNode);
 
-  virtual DHTMessageHandle
-  createPingMessage(const DHTNodeHandle& remoteNode,
-		    const string& transactionID = "");
+  virtual SharedHandle<DHTMessage>
+  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+		    const std::string& transactionID = "");
 
-  virtual DHTMessageHandle
-  createPingReplyMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			 const unsigned char* id,
-			 const string& transactionID);
+			 const std::string& transactionID);
 
-  virtual DHTMessageHandle
-  createFindNodeMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* targetNodeID,
-			const string& transactionID = "");
+			const std::string& transactionID = "");
 
-  DHTMessageHandle
-  createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
+  SharedHandle<DHTMessage>
+  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			     const Dictionary* d,
-			     const string& transactionID);
+			     const std::string& transactionID);
 
 
-  virtual DHTMessageHandle
-  createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& transactionID);
+  virtual SharedHandle<DHTMessage>
+  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& transactionID);
 
-  virtual DHTMessageHandle
-  createGetPeersMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* infoHash,
-			const string& transactionID = "");
+			const std::string& transactionID = "");
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& token,
-			     const string& transactionID);
+  virtual SharedHandle<DHTMessage>
+  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& token,
+			     const std::string& transactionID);
 
-  DHTMessageHandle
-  createGetPeersReplyMessageWithNodes(const DHTNodeHandle& remoteNode,
+  SharedHandle<DHTMessage>
+  createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
 				      const Dictionary* d,
-				      const string& transactionID);
+				      const std::string& transactionID);
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const Peers& peers,
-			     const string& token,
-			     const string& transactionID);
+  virtual SharedHandle<DHTMessage>
+  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<Peer> >& peers,
+			     const std::string& token,
+			     const std::string& transactionID);
 
-  DHTMessageHandle
-  createGetPeersReplyMessageWithValues(const DHTNodeHandle& remoteNode,
+  SharedHandle<DHTMessage>
+  createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,
 				       const Dictionary* d,
-				       const string& transactionID);
+				       const std::string& transactionID);
 
-  virtual DHTMessageHandle
-  createAnnouncePeerMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
 			    const unsigned char* infoHash,
 			    uint16_t tcpPort,
-			    const string& token,
-			    const string& transactionID = "");
+			    const std::string& token,
+			    const std::string& transactionID = "");
 
-  virtual DHTMessageHandle
-  createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode,
-				 const string& transactionID);
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+				 const std::string& transactionID);
 
-  virtual DHTMessageHandle
-  createUnknownMessage(const char* data, size_t length, const string& ipaddr,
+  virtual SharedHandle<DHTMessage>
+  createUnknownMessage(const char* data, size_t length, const std::string& ipaddr,
 		       uint16_t port);
 
-  void setRoutingTable(const DHTRoutingTableHandle& routingTable);
+  void setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable);
 
-  void setConnection(const DHTConnectionHandle& connection);
+  void setConnection(const WeakHandle<DHTConnection>& connection);
 
-  void setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher);
+  void setMessageDispatcher(const WeakHandle<DHTMessageDispatcher>& dispatcher);
   
-  void setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage);
+  void setPeerAnnounceStorage(const WeakHandle<DHTPeerAnnounceStorage>& storage);
 
-  void setTokenTracker(const DHTTokenTrackerHandle& tokenTracker);
+  void setTokenTracker(const WeakHandle<DHTTokenTracker>& tokenTracker);
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_FACTORY_IMPL_H_
diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc
index 50acf2f3..388bd201 100644
--- a/src/DHTMessageReceiver.cc
+++ b/src/DHTMessageReceiver.cc
@@ -40,13 +40,18 @@
 #include "DHTRoutingTable.h"
 #include "DHTNode.h"
 #include "DHTMessageCallback.h"
-#include "MetaEntry.h"
+#include "Dictionary.h"
+#include "Data.h"
 #include "MetaFileUtil.h"
 #include "DlAbortEx.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
+#include <utility>
 
-DHTMessageReceiver::DHTMessageReceiver(const DHTMessageTrackerHandle& tracker):
+namespace aria2 {
+
+DHTMessageReceiver::DHTMessageReceiver(const SharedHandle<DHTMessageTracker>& tracker):
   _tracker(tracker),
   _connection(0),
   _factory(0),
@@ -56,9 +61,9 @@ DHTMessageReceiver::DHTMessageReceiver(const DHTMessageTrackerHandle& tracker):
 
 DHTMessageReceiver::~DHTMessageReceiver() {}
 
-DHTMessageHandle DHTMessageReceiver::receiveMessage()
+SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage()
 {
-  string remoteAddr;
+  std::string remoteAddr;
   uint16_t remotePort;
   char data[64*1024];
   ssize_t length = _connection->receiveMessage(data, sizeof(data),
@@ -80,10 +85,10 @@ DHTMessageHandle DHTMessageReceiver::receiveMessage()
       _logger->info("Malformed DHT message. This is not a bencoded directory. From:%s:%u", remoteAddr.c_str(), remotePort);
       return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort);
     }
-    DHTMessageHandle message = 0;
-    DHTMessageCallbackHandle callback = 0;
+    SharedHandle<DHTMessage> message = 0;
+    SharedHandle<DHTMessageCallback> callback = 0;
     if(isReply) {
-      std::pair<DHTMessageHandle, DHTMessageCallbackHandle> p = _tracker->messageArrived(d, remoteAddr, remotePort);
+      std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = _tracker->messageArrived(d, remoteAddr, remotePort);
       message = p.first;
       callback = p.second;
       if(message.isNull()) {
@@ -117,7 +122,7 @@ void DHTMessageReceiver::handleTimeout()
 
 SharedHandle<DHTMessage>
 DHTMessageReceiver::handleUnknownMessage(const char* data, size_t length,
-					 const string& remoteAddr,
+					 const std::string& remoteAddr,
 					 uint16_t remotePort)
 {
   SharedHandle<DHTMessage> m =
@@ -126,27 +131,29 @@ DHTMessageReceiver::handleUnknownMessage(const char* data, size_t length,
   return m;
 }
 
-DHTConnectionHandle DHTMessageReceiver::getConnection() const
+SharedHandle<DHTConnection> DHTMessageReceiver::getConnection() const
 {
   return _connection;
 }
 
-DHTMessageTrackerHandle DHTMessageReceiver::getMessageTracker() const
+SharedHandle<DHTMessageTracker> DHTMessageReceiver::getMessageTracker() const
 {
   return _tracker;
 }
 
-void DHTMessageReceiver::setConnection(const DHTConnectionHandle& connection)
+void DHTMessageReceiver::setConnection(const SharedHandle<DHTConnection>& connection)
 {
   _connection = connection;
 }
 
-void DHTMessageReceiver::setMessageFactory(const DHTMessageFactoryHandle& factory)
+void DHTMessageReceiver::setMessageFactory(const SharedHandle<DHTMessageFactory>& factory)
 {
   _factory = factory;
 }
 
-void DHTMessageReceiver::setRoutingTable(const DHTRoutingTableHandle& routingTable)
+void DHTMessageReceiver::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable)
 {
   _routingTable = routingTable;
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageReceiver.h b/src/DHTMessageReceiver.h
index 85dc1ddc..cc63b486 100644
--- a/src/DHTMessageReceiver.h
+++ b/src/DHTMessageReceiver.h
@@ -36,48 +36,53 @@
 #define _D_DHT_MESSAGE_RECEIVER_H_
 
 #include "common.h"
-#include "DHTMessageReceiverDecl.h"
-#include "DHTMessageTrackerDecl.h"
-#include "DHTMessageDecl.h"
-#include "DHTConnectionDecl.h"
-#include "DHTMessageFactoryDecl.h"
-#include "DHTRoutingTableDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTMessageTracker;
+class DHTMessage;
+class DHTConnection;
+class DHTMessageFactory;
+class DHTRoutingTable;
 
 class Logger;
 
 class DHTMessageReceiver {
 private:
-  DHTMessageTrackerHandle _tracker;
+  SharedHandle<DHTMessageTracker> _tracker;
 
-  DHTConnectionHandle _connection;
+  SharedHandle<DHTConnection> _connection;
 
-  DHTMessageFactoryHandle _factory;
+  SharedHandle<DHTMessageFactory> _factory;
 
-  DHTRoutingTableHandle _routingTable;
+  SharedHandle<DHTRoutingTable> _routingTable;
 
   const Logger* _logger;
 
   SharedHandle<DHTMessage>
   handleUnknownMessage(const char* data, size_t length,
-		       const string& remoteAddr, uint16_t remotePort);
+		       const std::string& remoteAddr, uint16_t remotePort);
 public:
-  DHTMessageReceiver(const DHTMessageTrackerHandle& tracker);
+  DHTMessageReceiver(const SharedHandle<DHTMessageTracker>& tracker);
   
   ~DHTMessageReceiver();
 
-  DHTMessageHandle receiveMessage();
+  SharedHandle<DHTMessage> receiveMessage();
 
   void handleTimeout();
 
-  DHTConnectionHandle getConnection() const;
+  SharedHandle<DHTConnection> getConnection() const;
 
-  DHTMessageTrackerHandle getMessageTracker() const;
+  SharedHandle<DHTMessageTracker> getMessageTracker() const;
 
-  void setConnection(const DHTConnectionHandle& connection);
+  void setConnection(const SharedHandle<DHTConnection>& connection);
 
-  void setMessageFactory(const DHTMessageFactoryHandle& factory);
+  void setMessageFactory(const SharedHandle<DHTMessageFactory>& factory);
 
-  void setRoutingTable(const DHTRoutingTableHandle& routingTable);
+  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_RECEIVER_H_
diff --git a/src/DHTMessageReceiverDecl.h b/src/DHTMessageReceiverDecl.h
deleted file mode 100644
index 09405759..00000000
--- a/src/DHTMessageReceiverDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_RECEIVER_DECL_H_
-#define _D_DHT_MESSAGE_RECEIVER_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTMessageReceiver;
-typedef SharedHandle<DHTMessageReceiver> DHTMessageReceiverHandle;
-
-#endif // _D_DHT_MESSAGE_RECEIVER_DECL_H_
diff --git a/src/DHTMessageTracker.cc b/src/DHTMessageTracker.cc
index 3c427d86..c2341ff5 100644
--- a/src/DHTMessageTracker.cc
+++ b/src/DHTMessageTracker.cc
@@ -41,10 +41,14 @@
 #include "DHTMessageFactory.h"
 #include "Util.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Dictionary.h"
 #include "Data.h"
 #include "DlAbortEx.h"
 #include "DHTConstants.h"
+#include <utility>
+
+namespace aria2 {
 
 DHTMessageTracker::DHTMessageTracker():
   _routingTable(0),
@@ -53,19 +57,19 @@ DHTMessageTracker::DHTMessageTracker():
 
 DHTMessageTracker::~DHTMessageTracker() {}
 
-void DHTMessageTracker::addMessage(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback)
+void DHTMessageTracker::addMessage(const SharedHandle<DHTMessage>& message, time_t timeout, const SharedHandle<DHTMessageCallback>& callback)
 {
   _entries.push_back(new DHTMessageTrackerEntry(message, timeout, callback));
 }
 
-void DHTMessageTracker::addMessage(const DHTMessageHandle& message, const DHTMessageCallbackHandle& callback)
+void DHTMessageTracker::addMessage(const SharedHandle<DHTMessage>& message, const SharedHandle<DHTMessageCallback>& callback)
 {
   addMessage(message, DHT_MESSAGE_TIMEOUT, callback);
 }
 
-pair<DHTMessageHandle, DHTMessageCallbackHandle>
+std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >
 DHTMessageTracker::messageArrived(const Dictionary* d,
-				  const string& ipaddr, uint16_t port)
+				  const std::string& ipaddr, uint16_t port)
 {
   const Data* tid = dynamic_cast<const Data*>(d->get("t"));
   if(!tid) {
@@ -73,36 +77,36 @@ DHTMessageTracker::messageArrived(const Dictionary* d,
   }
   _logger->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u",
 		 Util::toHex(tid->toString()).c_str(), ipaddr.c_str(), port);
-  for(DHTMessageTrackerEntries::iterator i = _entries.begin();
+  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i = _entries.begin();
       i != _entries.end(); ++i) {
     if((*i)->match(tid->toString(), ipaddr, port)) {
-      DHTMessageTrackerEntryHandle entry = *i;
+      SharedHandle<DHTMessageTrackerEntry> entry = *i;
       _entries.erase(i);
       _logger->debug("Tracker entry found.");
-      DHTNodeHandle targetNode = entry->getTargetNode();
+      SharedHandle<DHTNode> targetNode = entry->getTargetNode();
 
-      DHTMessageHandle message = _factory->createResponseMessage(entry->getMessageType(),
+      SharedHandle<DHTMessage> message = _factory->createResponseMessage(entry->getMessageType(),
 								 d, targetNode);
       int64_t rtt = entry->getElapsedMillis();
       _logger->debug("RTT is %s", Util::llitos(rtt).c_str());
       targetNode->updateRTT(rtt);
-      DHTMessageCallbackHandle callback = entry->getCallback();
-      return pair<DHTMessageHandle, DHTMessageCallbackHandle>(message, callback);
+      SharedHandle<DHTMessageCallback> callback = entry->getCallback();
+      return std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >(message, callback);
     }
   }
   _logger->debug("Tracker entry not found.");
-  return pair<DHTMessageHandle, DHTMessageCallbackHandle>(0, 0);
+  return std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >(0, 0);
 }
 
 void DHTMessageTracker::handleTimeout()
 {
-  for(DHTMessageTrackerEntries::iterator i = _entries.begin();
+  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i = _entries.begin();
       i != _entries.end();) {
     if((*i)->isTimeout()) {
       try {
-	DHTMessageTrackerEntryHandle entry = *i;
+	SharedHandle<DHTMessageTrackerEntry> entry = *i;
 	i = _entries.erase(i);
-	DHTNodeHandle node = entry->getTargetNode();
+	SharedHandle<DHTNode> node = entry->getTargetNode();
 	_logger->debug("Message timeout: To:%s:%u",
 		       node->getIPAddress().c_str(), node->getPort());
 	node->updateRTT(entry->getElapsedMillis());
@@ -112,7 +116,7 @@ void DHTMessageTracker::handleTimeout()
 			 node->getIPAddress().c_str(), node->getPort());
 	  _routingTable->dropNode(node);
 	}
-	DHTMessageCallbackHandle callback = entry->getCallback();
+	SharedHandle<DHTMessageCallback> callback = entry->getCallback();
 	if(!callback.isNull()) {
 	  callback->onTimeout(node);
 	}
@@ -126,10 +130,10 @@ void DHTMessageTracker::handleTimeout()
   }
 }
 
-DHTMessageTrackerEntryHandle
-DHTMessageTracker::getEntryFor(const DHTMessageHandle& message) const
+SharedHandle<DHTMessageTrackerEntry>
+DHTMessageTracker::getEntryFor(const SharedHandle<DHTMessage>& message) const
 {
-  for(DHTMessageTrackerEntries::const_iterator i = _entries.begin();
+  for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::const_iterator i = _entries.begin();
       i != _entries.end(); ++i) {
     if((*i)->match(message->getTransactionID(), message->getRemoteNode()->getIPAddress(), message->getRemoteNode()->getPort())) {
       return *i;
@@ -143,12 +147,14 @@ size_t DHTMessageTracker::countEntry() const
   return _entries.size();
 }
 
-void DHTMessageTracker::setRoutingTable(const DHTRoutingTableHandle& routingTable)
+void DHTMessageTracker::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable)
 {
   _routingTable = routingTable;
 }
 
-void DHTMessageTracker::setMessageFactory(const DHTMessageFactoryHandle& factory)
+void DHTMessageTracker::setMessageFactory(const SharedHandle<DHTMessageFactory>& factory)
 {
   _factory = factory;
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageTracker.h b/src/DHTMessageTracker.h
index e4cf6b3a..e23c4920 100644
--- a/src/DHTMessageTracker.h
+++ b/src/DHTMessageTracker.h
@@ -36,23 +36,27 @@
 #define _D_DHT_MESSAGE_TRACKER_H_
 
 #include "common.h"
-#include "DHTMessageTrackerDecl.h"
-#include "DHTMessageDecl.h"
-#include "DHTMessageCallbackDecl.h"
-#include "DHTMessageTrackerEntryDecl.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTMessageFactoryDecl.h"
+#include "SharedHandle.h"
+#include <utility>
+#include <deque>
 
+namespace aria2 {
+
+class DHTMessage;
+class DHTMessageCallback;
+class DHTRoutingTable;
+class DHTMessageFactory;
+class DHTMessageTrackerEntry;
 class Logger;
 class Dictionary;
 
 class DHTMessageTracker {
 private:
-  DHTMessageTrackerEntries _entries;
+  std::deque<SharedHandle<DHTMessageTrackerEntry> > _entries;
   
-  DHTRoutingTableHandle _routingTable;
+  SharedHandle<DHTRoutingTable> _routingTable;
 
-  DHTMessageFactoryHandle _factory;
+  SharedHandle<DHTMessageFactory> _factory;
 
   const Logger* _logger;
 public:
@@ -60,22 +64,27 @@ public:
 
   ~DHTMessageTracker();
 
-  void addMessage(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback = 0);
+  void addMessage(const SharedHandle<DHTMessage>& message,
+		  time_t timeout,
+		  const SharedHandle<DHTMessageCallback>& callback = 0);
 
-  void addMessage(const DHTMessageHandle& message, const DHTMessageCallbackHandle& callback = 0);
+  void addMessage(const SharedHandle<DHTMessage>& message,
+		  const SharedHandle<DHTMessageCallback>& callback = 0);
 
-  pair<DHTMessageHandle, DHTMessageCallbackHandle>
-  messageArrived(const Dictionary* d, const string& ipaddr, uint16_t port);
+  std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> >
+  messageArrived(const Dictionary* d, const std::string& ipaddr, uint16_t port);
 
   void handleTimeout();
 
-  DHTMessageTrackerEntryHandle getEntryFor(const DHTMessageHandle& message) const;
+  SharedHandle<DHTMessageTrackerEntry> getEntryFor(const SharedHandle<DHTMessage>& message) const;
 
   size_t countEntry() const;
 
-  void setRoutingTable(const DHTRoutingTableHandle& routingTable);
+  void setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable);
 
-  void setMessageFactory(const DHTMessageFactoryHandle& factory);
+  void setMessageFactory(const SharedHandle<DHTMessageFactory>& factory);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_TRACKER_H_
diff --git a/src/DHTMessageTrackerDecl.h b/src/DHTMessageTrackerDecl.h
deleted file mode 100644
index 59e6d062..00000000
--- a/src/DHTMessageTrackerDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_TRACKER_DECL_H_
-#define _D_DHT_MESSAGE_TRACKER_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTMessageTracker;
-typedef SharedHandle<DHTMessageTracker> DHTMessageTrackerHandle;
-
-#endif // _D_DHT_MESSAGE_TRACKER_DECL_H_
diff --git a/src/DHTMessageTrackerEntry.cc b/src/DHTMessageTrackerEntry.cc
index ab0231d7..dc7c0ecf 100644
--- a/src/DHTMessageTrackerEntry.cc
+++ b/src/DHTMessageTrackerEntry.cc
@@ -38,9 +38,11 @@
 #include "DHTMessageCallback.h"
 #include "DHTConstants.h"
 
-DHTMessageTrackerEntry::DHTMessageTrackerEntry(const DHTMessageHandle& sentMessage,
+namespace aria2 {
+
+DHTMessageTrackerEntry::DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage,
 					       time_t timeout,
-					       const DHTMessageCallbackHandle& callback):
+					       const SharedHandle<DHTMessageCallback>& callback):
   _targetNode(sentMessage->getRemoteNode()),
   _transactionID(sentMessage->getTransactionID()),
   _messageType(sentMessage->getMessageType()),
@@ -56,18 +58,20 @@ bool DHTMessageTrackerEntry::isTimeout() const
 void DHTMessageTrackerEntry::extendTimeout()
 {}
 
-bool DHTMessageTrackerEntry::match(const string& transactionID, const string& ipaddr, uint16_t port) const
+bool DHTMessageTrackerEntry::match(const std::string& transactionID, const std::string& ipaddr, uint16_t port) const
 {
   return _transactionID == transactionID &&
     _targetNode->getIPAddress() == ipaddr && _targetNode->getPort() == port;
 }
 
-DHTMessageCallbackHandle DHTMessageTrackerEntry::getCallback() const
+SharedHandle<DHTMessageCallback> DHTMessageTrackerEntry::getCallback() const
 {
   return _callback;
 }
 
-DHTNodeHandle DHTMessageTrackerEntry::getTargetNode() const
+SharedHandle<DHTNode> DHTMessageTrackerEntry::getTargetNode() const
 {
   return _targetNode;
 }
+
+} // namespace aria2
diff --git a/src/DHTMessageTrackerEntry.h b/src/DHTMessageTrackerEntry.h
index b6425e24..d2299b73 100644
--- a/src/DHTMessageTrackerEntry.h
+++ b/src/DHTMessageTrackerEntry.h
@@ -36,45 +36,49 @@
 #define _D_DHT_MESSAGE_TRACKER_ENTRY_H_
 
 #include "common.h"
-#include "DHTMessageTrackerEntryDecl.h"
+#include "SharedHandle.h"
 #include "DHTConstants.h"
-#include "DHTNodeDecl.h"
-#include "DHTMessageDecl.h"
-#include "DHTMessageCallbackDecl.h"
 #include "TimeA2.h"
+#include <string>
+
+namespace aria2 {
+
+class DHTNode;
+class DHTMessage;
+class DHTMessageCallback;
 
 class DHTMessageTrackerEntry {
 private:
-  DHTNodeHandle _targetNode;
+  SharedHandle<DHTNode> _targetNode;
 
-  string _transactionID;
+  std::string _transactionID;
 
-  string _messageType;
+  std::string _messageType;
   
-  DHTMessageCallbackHandle _callback;
+  SharedHandle<DHTMessageCallback> _callback;
 
   Time _dispatchedTime;
 
   time_t _timeout;
 public:
-  DHTMessageTrackerEntry(const DHTMessageHandle& sentMessage,
+  DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage,
 			 time_t timeout,
-			 const DHTMessageCallbackHandle& callback = 0);
+			 const SharedHandle<DHTMessageCallback>& callback = 0);
 
   bool isTimeout() const;
 
   void extendTimeout();
 
-  bool match(const string& transactionID, const string& ipaddr, uint16_t port) const;
+  bool match(const std::string& transactionID, const std::string& ipaddr, uint16_t port) const;
 
-  DHTNodeHandle getTargetNode() const;
+  SharedHandle<DHTNode> getTargetNode() const;
 
-  const string& getMessageType() const
+  const std::string& getMessageType() const
   {
     return _messageType;
   }
 
-  DHTMessageCallbackHandle getCallback() const;
+  SharedHandle<DHTMessageCallback> getCallback() const;
 
   int64_t getElapsedMillis() const
   {
@@ -82,4 +86,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_MESSAGE_TRACKER_ENTRY_H_
diff --git a/src/DHTMessageTrackerEntryDecl.h b/src/DHTMessageTrackerEntryDecl.h
deleted file mode 100644
index cb3c565f..00000000
--- a/src/DHTMessageTrackerEntryDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_
-#define _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTMessageTrackerEntry;
-typedef SharedHandle<DHTMessageTrackerEntry> DHTMessageTrackerEntryHandle;
-typedef std::deque<DHTMessageTrackerEntryHandle> DHTMessageTrackerEntries;
-
-#endif // _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_
diff --git a/src/DHTNode.cc b/src/DHTNode.cc
index cca92f55..c1220d76 100644
--- a/src/DHTNode.cc
+++ b/src/DHTNode.cc
@@ -35,6 +35,9 @@
 #include "DHTNode.h"
 #include "DHTUtil.h"
 #include "Util.h"
+#include <cstring>
+
+namespace aria2 {
 
 DHTNode::DHTNode():_port(0), _rtt(0), _condition(0), _lastContact(0)
 {
@@ -106,10 +109,12 @@ void DHTNode::timeout()
   ++_condition;
 }
 
-string DHTNode::toString() const
+std::string DHTNode::toString() const
 {
   return "DHTNode ID="+Util::toHex(_id, DHT_ID_LENGTH)+
     ", Host="+_ipaddr+":"+Util::uitos(_port)+
     ", Condition="+Util::uitos(_condition)+
     ", RTT="+Util::itos(_rtt);
 }
+
+} // namespace aria2
diff --git a/src/DHTNode.h b/src/DHTNode.h
index c6af39aa..0d52a25d 100644
--- a/src/DHTNode.h
+++ b/src/DHTNode.h
@@ -36,15 +36,18 @@
 #define _D_DHT_NODE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "DHTConstants.h"
-#include "DHTNodeDecl.h"
 #include "TimeA2.h"
+#include <string>
+
+namespace aria2 {
 
 class DHTNode {
 private:
   unsigned char _id[DHT_ID_LENGTH];
 
-  string _ipaddr;
+  std::string _ipaddr;
 
   uint16_t _port;
 
@@ -74,12 +77,12 @@ public:
     _rtt = millisec;
   }
 
-  string getIPAddress() const
+  std::string getIPAddress() const
   {
     return _ipaddr;
   }
 
-  void setIPAddress(const string& ipaddr)
+  void setIPAddress(const std::string& ipaddr)
   {
     _ipaddr = ipaddr;
   }
@@ -117,7 +120,9 @@ public:
 
   bool operator<(const DHTNode& node) const;
 
-  string toString() const;
+  std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_NODE_H_
diff --git a/src/DHTNodeDecl.h b/src/DHTNodeDecl.h
deleted file mode 100644
index 9648e3d6..00000000
--- a/src/DHTNodeDecl.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_NODE_DECL_H_
-#define _D_DHT_NODE_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTNode;
-typedef SharedHandle<DHTNode> DHTNodeHandle;
-typedef std::deque<DHTNodeHandle> DHTNodes;
-#endif // _D_DHT_NODE_DECL_H_
diff --git a/src/DHTNodeLookupEntry.cc b/src/DHTNodeLookupEntry.cc
index 473cb47d..2f64761b 100644
--- a/src/DHTNodeLookupEntry.cc
+++ b/src/DHTNodeLookupEntry.cc
@@ -35,7 +35,9 @@
 #include "DHTNodeLookupEntry.h"
 #include "DHTNode.h"
 
-DHTNodeLookupEntry::DHTNodeLookupEntry(const DHTNodeHandle& node):
+namespace aria2 {
+
+DHTNodeLookupEntry::DHTNodeLookupEntry(const SharedHandle<DHTNode>& node):
   _node(node), _used(false) {}
 
 DHTNodeLookupEntry::DHTNodeLookupEntry():
@@ -45,3 +47,5 @@ bool DHTNodeLookupEntry::operator==(const DHTNodeLookupEntry& entry) const
 {
   return _node == entry._node;
 }
+
+} // namespace aria2
diff --git a/src/DHTNodeLookupEntry.h b/src/DHTNodeLookupEntry.h
index e041f6b0..36051afd 100644
--- a/src/DHTNodeLookupEntry.h
+++ b/src/DHTNodeLookupEntry.h
@@ -36,19 +36,25 @@
 #define _D_DHT_NODE_LOOKUP_ENTRY_H_
 
 #include "common.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTNode;
 
 class DHTNodeLookupEntry {
 public:
-  DHTNodeHandle _node;
+  SharedHandle<DHTNode> _node;
 
   bool _used;
 
-  DHTNodeLookupEntry(const DHTNodeHandle& node);
+  DHTNodeLookupEntry(const SharedHandle<DHTNode>& node);
 
   DHTNodeLookupEntry();
 
   bool operator==(const DHTNodeLookupEntry& entry) const;
 };
 
+} // namespace aria2;
+
 #endif // _D_DHT_NODE_LOOKUP_ENTRY_H_
diff --git a/src/DHTNodeLookupEntryDecl.h b/src/DHTNodeLookupEntryDecl.h
deleted file mode 100644
index 0d1e54fa..00000000
--- a/src/DHTNodeLookupEntryDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_
-#define _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTNodeLookupEntry;
-typedef SharedHandle<DHTNodeLookupEntry> DHTNodeLookupEntryHandle;
-typedef std::deque<DHTNodeLookupEntryHandle> DHTNodeLookupEntries;
-
-#endif // _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_
diff --git a/src/DHTNodeLookupTask.cc b/src/DHTNodeLookupTask.cc
index 7770d55b..6c76045b 100644
--- a/src/DHTNodeLookupTask.cc
+++ b/src/DHTNodeLookupTask.cc
@@ -40,17 +40,23 @@
 #include "LogFactory.h"
 #include "Util.h"
 
+namespace aria2 {
+
 DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID):
   DHTAbstractNodeLookupTask(targetNodeID)
 {}
 
-DHTNodes DHTNodeLookupTask::getNodesFromMessage(const DHTMessageHandle& message)
+std::deque<SharedHandle<DHTNode> >
+DHTNodeLookupTask::getNodesFromMessage(const SharedHandle<DHTMessage>& message)
 {
   SharedHandle<DHTFindNodeReplyMessage> m = message;
   return m->getClosestKNodes();
 }
 
-DHTMessageHandle DHTNodeLookupTask::createMessage(const DHTNodeHandle& remoteNode)
+SharedHandle<DHTMessage>
+DHTNodeLookupTask::createMessage(const SharedHandle<DHTNode>& remoteNode)
 {
   return _factory->createFindNodeMessage(remoteNode, _targetID);
 }
+
+} // namespace aria2
diff --git a/src/DHTNodeLookupTask.h b/src/DHTNodeLookupTask.h
index 3fbf2ce7..7d9f9a13 100644
--- a/src/DHTNodeLookupTask.h
+++ b/src/DHTNodeLookupTask.h
@@ -37,13 +37,17 @@
 
 #include "DHTAbstractNodeLookupTask.h"
 
+namespace aria2 {
+
 class DHTNodeLookupTask:public DHTAbstractNodeLookupTask {
 public:
   DHTNodeLookupTask(const unsigned char* targetNodeID);
 
-  virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message);
+  virtual std::deque<SharedHandle<DHTNode> > getNodesFromMessage(const SharedHandle<DHTMessage>& message);
 
-  virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode);
+  virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_NODE_LOOKUP_TASK_H_
diff --git a/src/DHTPeerAnnounceCommand.cc b/src/DHTPeerAnnounceCommand.cc
index e6272e54..eb633aeb 100644
--- a/src/DHTPeerAnnounceCommand.cc
+++ b/src/DHTPeerAnnounceCommand.cc
@@ -35,10 +35,12 @@
 #include "DHTPeerAnnounceCommand.h"
 #include "DHTPeerAnnounceStorage.h"
 #include "DownloadEngine.h"
-#include "SingletonHolder.h"
 #include "RequestGroupMan.h"
 #include "RecoverableException.h"
 #include "message.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 DHTPeerAnnounceCommand::DHTPeerAnnounceCommand(int32_t cuid, DownloadEngine* e, time_t interval):
   TimeBasedCommand(cuid, e, interval),
@@ -62,7 +64,9 @@ void DHTPeerAnnounceCommand::process()
   }
 }
 
-void DHTPeerAnnounceCommand::setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage)
+void DHTPeerAnnounceCommand::setPeerAnnounceStorage(const SharedHandle<DHTPeerAnnounceStorage>& storage)
 {
   _peerAnnounceStorage = storage;
 }
+
+} // namespace aria2
diff --git a/src/DHTPeerAnnounceCommand.h b/src/DHTPeerAnnounceCommand.h
index 6eec7717..dbbb6e4e 100644
--- a/src/DHTPeerAnnounceCommand.h
+++ b/src/DHTPeerAnnounceCommand.h
@@ -36,11 +36,15 @@
 #define _D_DHT_PEER_ANNOUNCE_COMMAND_H_
 
 #include "TimeBasedCommand.h"
-#include "DHTPeerAnnounceStorageDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTPeerAnnounceStorage;
 
 class DHTPeerAnnounceCommand:public TimeBasedCommand {
 private:
-  DHTPeerAnnounceStorageHandle _peerAnnounceStorage;
+  SharedHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage;
 public:
   DHTPeerAnnounceCommand(int32_t cuid, DownloadEngine* e, time_t interval);
 
@@ -50,7 +54,9 @@ public:
 
   virtual void process();
 
-  void setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage);
+  void setPeerAnnounceStorage(const SharedHandle<DHTPeerAnnounceStorage>& storage);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PEER_ANNOUNCE_COMMAND_H_
diff --git a/src/DHTPeerAnnounceEntry.cc b/src/DHTPeerAnnounceEntry.cc
index 74b27b29..1ed364ff 100644
--- a/src/DHTPeerAnnounceEntry.cc
+++ b/src/DHTPeerAnnounceEntry.cc
@@ -36,6 +36,11 @@
 #include "BtContext.h"
 #include "Peer.h"
 #include "BtRegistry.h"
+#include "PeerStorage.h"
+#include <cstring>
+#include <algorithm>
+
+namespace aria2 {
 
 DHTPeerAnnounceEntry::DHTPeerAnnounceEntry(const unsigned char* infoHash):
   _btCtx(0)
@@ -47,7 +52,7 @@ DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {}
 
 void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry)
 {
-  PeerAddrEntries::iterator i = find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
+  std::deque<PeerAddrEntry>::iterator i = std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
   if(i == _peerAddrEntries.end()) {
     _peerAddrEntries.push_back(entry);
   } else {
@@ -56,7 +61,7 @@ void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry)
   notifyUpdate();
 }
 
-void DHTPeerAnnounceEntry::setBtContext(const BtContextHandle& btCtx)
+void DHTPeerAnnounceEntry::setBtContext(const SharedHandle<BtContext>& btCtx)
 {
   _btCtx = btCtx;
 }
@@ -66,7 +71,7 @@ size_t DHTPeerAnnounceEntry::countPeerAddrEntry() const
   return _peerAddrEntries.size();
 }
 
-const PeerAddrEntries& DHTPeerAnnounceEntry::getPeerAddrEntries() const
+const std::deque<PeerAddrEntry>& DHTPeerAnnounceEntry::getPeerAddrEntries() const
 {
   return _peerAddrEntries;
 }
@@ -89,8 +94,8 @@ public:
 
 void DHTPeerAnnounceEntry::removeStalePeerAddrEntry(time_t timeout)
 {
-  _peerAddrEntries.erase(remove_if(_peerAddrEntries.begin(), _peerAddrEntries.end(),
-				   FindStaleEntry(timeout)), _peerAddrEntries.end());
+  _peerAddrEntries.erase(std::remove_if(_peerAddrEntries.begin(), _peerAddrEntries.end(),
+					FindStaleEntry(timeout)), _peerAddrEntries.end());
 }
 
 bool DHTPeerAnnounceEntry::empty() const
@@ -100,13 +105,13 @@ bool DHTPeerAnnounceEntry::empty() const
 
 Peers DHTPeerAnnounceEntry::getPeers() const
 {
-  Peers peers;
-  for(PeerAddrEntries::const_iterator i = _peerAddrEntries.begin();
+  std::deque<SharedHandle<Peer> > peers;
+  for(std::deque<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
       i != _peerAddrEntries.end(); ++i) {
     peers.push_back(new Peer((*i).getIPAddress(), (*i).getPort()));
   }
   if(!_btCtx.isNull()) {
-    PeerStorageHandle peerStorage = PEER_STORAGE(_btCtx);
+    SharedHandle<PeerStorage> peerStorage = PEER_STORAGE(_btCtx);
     if(!peerStorage.isNull()) {
       const Peers& activePeers = peerStorage->getActivePeers();
       peers.insert(peers.end(), activePeers.begin(), activePeers.end());
@@ -119,3 +124,5 @@ void DHTPeerAnnounceEntry::notifyUpdate()
 {
   _lastUpdated.reset();
 }
+
+} // namespace aria2
diff --git a/src/DHTPeerAnnounceEntry.h b/src/DHTPeerAnnounceEntry.h
index b4cb6d56..25497d25 100644
--- a/src/DHTPeerAnnounceEntry.h
+++ b/src/DHTPeerAnnounceEntry.h
@@ -36,21 +36,24 @@
 #define _D_DHT_PEER_ANNOUNCE_ENTRY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "PeerAddrEntry.h"
-#include "PeerDecl.h"
 #include "TimeA2.h"
+#include <deque>
 
+namespace aria2 {
+
+class Peer;
 class BtContext;
-typedef SharedHandle<BtContext> BtContextHandle;
 
 class DHTPeerAnnounceEntry {
 private:
   unsigned char _infoHash[DHT_ID_LENGTH];
 
-  PeerAddrEntries _peerAddrEntries;
+  std::deque<PeerAddrEntry> _peerAddrEntries;
 
-  BtContextHandle _btCtx;
+  SharedHandle<BtContext> _btCtx;
 
   Time _lastUpdated;
 public:
@@ -62,11 +65,11 @@ public:
   // if it already exists, update "Last Updated" property.
   void addPeerAddrEntry(const PeerAddrEntry& entry);
 
-  void setBtContext(const BtContextHandle& btCtx);
+  void setBtContext(const SharedHandle<BtContext>& btCtx);
 
   size_t countPeerAddrEntry() const;
 
-  const PeerAddrEntries& getPeerAddrEntries() const;
+  const std::deque<PeerAddrEntry>& getPeerAddrEntries() const;
 
   void removeStalePeerAddrEntry(time_t timeout);
   
@@ -84,8 +87,10 @@ public:
     return _infoHash;
   }
 
-  Peers getPeers() const;
+  std::deque<SharedHandle<Peer> > getPeers() const;
 
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PEER_ANNOUNCE_ENTRY_H_
diff --git a/src/DHTPeerAnnounceEntryDecl.h b/src/DHTPeerAnnounceEntryDecl.h
deleted file mode 100644
index 047c55f5..00000000
--- a/src/DHTPeerAnnounceEntryDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_
-#define _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTPeerAnnounceEntry;
-typedef SharedHandle<DHTPeerAnnounceEntry> DHTPeerAnnounceEntryHandle;
-typedef std::deque<DHTPeerAnnounceEntryHandle> DHTPeerAnnounceEntries;
-
-#endif // _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_
diff --git a/src/DHTPeerAnnounceStorage.cc b/src/DHTPeerAnnounceStorage.cc
index f36ef9ac..2f75adb4 100644
--- a/src/DHTPeerAnnounceStorage.cc
+++ b/src/DHTPeerAnnounceStorage.cc
@@ -41,7 +41,12 @@
 #include "DHTTaskFactory.h"
 #include "DHTTask.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
+#include <cstring>
+#include <algorithm>
+
+namespace aria2 {
 
 DHTPeerAnnounceStorage::DHTPeerAnnounceStorage():_taskQueue(0),
 						 _taskFactory(0),
@@ -58,18 +63,18 @@ public:
     memcpy(_infoHash, infoHash, DHT_ID_LENGTH);
   }
 
-  bool operator()(const DHTPeerAnnounceEntryHandle& entry) const
+  bool operator()(const SharedHandle<DHTPeerAnnounceEntry>& entry) const
   {
     return memcmp(_infoHash, entry->getInfoHash(), DHT_ID_LENGTH) == 0;
   }
 };
 
-DHTPeerAnnounceEntryHandle
+SharedHandle<DHTPeerAnnounceEntry>
 DHTPeerAnnounceStorage::getPeerAnnounceEntry(const unsigned char* infoHash)
 {
-  DHTPeerAnnounceEntries::iterator i = 
-    find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash));
-  DHTPeerAnnounceEntryHandle entry = 0;
+  std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = 
+    std::find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash));
+  SharedHandle<DHTPeerAnnounceEntry> entry = 0;
   if(i == _entries.end()) {
     entry = new DHTPeerAnnounceEntry(infoHash);
     _entries.push_back(entry);
@@ -81,7 +86,7 @@ DHTPeerAnnounceStorage::getPeerAnnounceEntry(const unsigned char* infoHash)
 
 void
 DHTPeerAnnounceStorage::addPeerAnnounce(const unsigned char* infoHash,
-					const string& ipaddr, uint16_t port)
+					const std::string& ipaddr, uint16_t port)
 {
   _logger->debug("Adding %s:%u to peer announce list: infoHash=%s",
 		 ipaddr.c_str(), port, Util::toHex(infoHash, DHT_ID_LENGTH).c_str());
@@ -98,8 +103,8 @@ void DHTPeerAnnounceStorage::addPeerAnnounce(const BtContextHandle& ctx)
 
 void DHTPeerAnnounceStorage::removePeerAnnounce(const BtContextHandle& ctx)
 {
-  DHTPeerAnnounceEntries::iterator i = 
-    find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(ctx->getInfoHash()));
+  std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = 
+    std::find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(ctx->getInfoHash()));
   if(i != _entries.end()) {
     (*i)->setBtContext(0);
     if((*i)->empty()) {
@@ -111,14 +116,13 @@ void DHTPeerAnnounceStorage::removePeerAnnounce(const BtContextHandle& ctx)
 bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const
 {
   return 
-    find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash))
-    != _entries.end();
+    std::find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash)) != _entries.end();
 }
 
 Peers DHTPeerAnnounceStorage::getPeers(const unsigned char* infoHash)
 {
-  DHTPeerAnnounceEntries::iterator i = 
-    find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash));
+  std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = 
+    std::find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash));
   if(i == _entries.end() || (*i)->empty()) {
     return Peers();
   }
@@ -128,7 +132,7 @@ Peers DHTPeerAnnounceStorage::getPeers(const unsigned char* infoHash)
 void DHTPeerAnnounceStorage::handleTimeout()
 {
   _logger->debug("Now purge peer announces which are timed out.");
-  for(DHTPeerAnnounceEntries::iterator i = _entries.begin(); i != _entries.end();) {
+  for(std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = _entries.begin(); i != _entries.end();) {
     (*i)->removeStalePeerAddrEntry(DHT_PEER_ANNOUNCE_PURGE_INTERVAL);
     if((*i)->empty()) {
       _logger->debug("1 entry purged: infoHash=%s",
@@ -143,10 +147,10 @@ void DHTPeerAnnounceStorage::handleTimeout()
 void DHTPeerAnnounceStorage::announcePeer()
 {
   _logger->debug("Now announcing peer.");
-  for(DHTPeerAnnounceEntries::iterator i = _entries.begin(); i != _entries.end(); ++i) {
+  for(std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = _entries.begin(); i != _entries.end(); ++i) {
     if((*i)->getLastUpdated().elapsed(DHT_PEER_ANNOUNCE_INTERVAL)) {
       (*i)->notifyUpdate();
-      DHTTaskHandle task = _taskFactory->createPeerAnnounceTask((*i)->getInfoHash());
+      SharedHandle<DHTTask> task = _taskFactory->createPeerAnnounceTask((*i)->getInfoHash());
       _taskQueue->addPeriodicTask2(task);
       _logger->debug("Added 1 peer announce: infoHash=%s",
 		     Util::toHex((*i)->getInfoHash(), DHT_ID_LENGTH).c_str());
@@ -154,12 +158,14 @@ void DHTPeerAnnounceStorage::announcePeer()
   }
 }
 
-void DHTPeerAnnounceStorage::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTPeerAnnounceStorage::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
 
-void DHTPeerAnnounceStorage::setTaskFactory(const DHTTaskFactoryHandle& taskFactory)
+void DHTPeerAnnounceStorage::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
 {
   _taskFactory = taskFactory;
 }
+
+} // namespace aria2
diff --git a/src/DHTPeerAnnounceStorage.h b/src/DHTPeerAnnounceStorage.h
index 93dbb73f..27e63eb4 100644
--- a/src/DHTPeerAnnounceStorage.h
+++ b/src/DHTPeerAnnounceStorage.h
@@ -36,24 +36,27 @@
 #define _D_DHT_PEER_ANNOUNCE_STORAGE_H_
 
 #include "common.h"
-#include "DHTPeerAnnounceStorageDecl.h"
-#include "DHTPeerAnnounceEntryDecl.h"
-#include "PeerDecl.h"
-#include "BtContextDecl.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
+#include "SharedHandle.h"
+#include <deque>
 
+namespace aria2 {
+
+class BtContext;
+class Peer;
+class DHTPeerAnnounceEntry;
+class DHTTaskQueue;
+class DHTTaskFactory;
 class Logger;
 
 class DHTPeerAnnounceStorage {
 private:
-  DHTPeerAnnounceEntries _entries;
+  std::deque<SharedHandle<DHTPeerAnnounceEntry> > _entries;
 
-  DHTPeerAnnounceEntryHandle getPeerAnnounceEntry(const unsigned char* infoHash);
+  SharedHandle<DHTPeerAnnounceEntry> getPeerAnnounceEntry(const unsigned char* infoHash);
 
-  DHTTaskQueueHandle _taskQueue;
+  SharedHandle<DHTTaskQueue> _taskQueue;
 
-  DHTTaskFactoryHandle _taskFactory;
+  SharedHandle<DHTTaskFactory> _taskFactory;
 
   const Logger* _logger;
 public:
@@ -62,18 +65,18 @@ public:
   ~DHTPeerAnnounceStorage();
 
   void addPeerAnnounce(const unsigned char* infoHash,
-		       const string& ipaddr, uint16_t port);
+		       const std::string& ipaddr, uint16_t port);
 
   // add peer announce as localhost downloading the content
-  void addPeerAnnounce(const BtContextHandle& ctx);
+  void addPeerAnnounce(const SharedHandle<BtContext>& ctx);
   
   // give 0 to DHTPeerAnnounceEntry::setBtContext().
   // If DHTPeerAnnounceEntry is empty, it is erased.
-  void removePeerAnnounce(const BtContextHandle& ctx);
+  void removePeerAnnounce(const SharedHandle<BtContext>& ctx);
 
   bool contains(const unsigned char* infoHash) const;
 
-  Peers getPeers(const unsigned char* infoHash);
+  std::deque<SharedHandle<Peer> > getPeers(const unsigned char* infoHash);
 
   // drop peer announce entry which is not updated in the past
   // DHT_PEER_ANNOUNCE_PURGE_INTERVAL seconds.
@@ -84,9 +87,11 @@ public:
   // are excluded from announce.
   void announcePeer();
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const DHTTaskFactoryHandle& taskFactory);
+  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PEER_ANNOUNCE_STORAGE_H_
diff --git a/src/DHTPeerAnnounceStorageDecl.h b/src/DHTPeerAnnounceStorageDecl.h
deleted file mode 100644
index 132f8742..00000000
--- a/src/DHTPeerAnnounceStorageDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_
-#define _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTPeerAnnounceStorage;
-typedef SharedHandle<DHTPeerAnnounceStorage> DHTPeerAnnounceStorageHandle;
-
-#endif // _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_
diff --git a/src/DHTPeerLookupTask.cc b/src/DHTPeerLookupTask.cc
index f16409e3..6d2030ba 100644
--- a/src/DHTPeerLookupTask.cc
+++ b/src/DHTPeerLookupTask.cc
@@ -48,23 +48,25 @@
 #include "Util.h"
 #include "DHTBucket.h"
 
-DHTPeerLookupTask::DHTPeerLookupTask(const BtContextHandle& btContext):
+namespace aria2 {
+
+DHTPeerLookupTask::DHTPeerLookupTask(const SharedHandle<BtContext>& btContext):
   DHTAbstractNodeLookupTask(btContext->getInfoHash()),
   _ctx(btContext),
   _peerStorage(PEER_STORAGE(btContext)),
   _btRuntime(BT_RUNTIME(btContext)) {}
 
-DHTNodes DHTPeerLookupTask::getNodesFromMessage(const DHTMessageHandle& message)
+std::deque<SharedHandle<DHTNode> > DHTPeerLookupTask::getNodesFromMessage(const SharedHandle<DHTMessage>& message)
 {
   SharedHandle<DHTGetPeersReplyMessage> m = message;
   return m->getClosestKNodes();
 }
   
-void DHTPeerLookupTask::onReceivedInternal(const DHTMessageHandle& message)
+void DHTPeerLookupTask::onReceivedInternal(const SharedHandle<DHTMessage>& message)
 {
   SharedHandle<DHTGetPeersReplyMessage> m = message;
 
-  DHTNodeHandle remoteNode = m->getRemoteNode();
+  SharedHandle<DHTNode> remoteNode = m->getRemoteNode();
   _tokenStorage[Util::toHex(remoteNode->getID(), DHT_ID_LENGTH)] = m->getToken();
 
   _peerStorage->addPeer(m->getValues());
@@ -72,7 +74,7 @@ void DHTPeerLookupTask::onReceivedInternal(const DHTMessageHandle& message)
   _logger->info("Received %u peers.", m->getValues().size());
 }
   
-DHTMessageHandle DHTPeerLookupTask::createMessage(const DHTNodeHandle& remoteNode)
+SharedHandle<DHTMessage> DHTPeerLookupTask::createMessage(const SharedHandle<DHTNode>& remoteNode)
 {
   return _factory->createGetPeersMessage(remoteNode, _targetID);
 }
@@ -81,11 +83,11 @@ void DHTPeerLookupTask::onFinish()
 {
   // send announce_peer message to K closest nodes
   size_t num = DHTBucket::K;
-  for(DHTNodeLookupEntries::const_iterator i = _entries.begin();
+  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::const_iterator i = _entries.begin();
       i != _entries.end() && num > 0; ++i, --num) {
     if((*i)->_used) {
-      const DHTNodeHandle& node = (*i)->_node;
-      DHTMessageHandle m = 
+      const SharedHandle<DHTNode>& node = (*i)->_node;
+      SharedHandle<DHTMessage> m = 
 	_factory->createAnnouncePeerMessage(node,
 					    _ctx->getInfoHash(),
 					    _btRuntime->getListenPort(),
@@ -96,7 +98,9 @@ void DHTPeerLookupTask::onFinish()
   }
 }
 
-const Peers& DHTPeerLookupTask::getPeers() const
+const std::deque<SharedHandle<Peer> >& DHTPeerLookupTask::getPeers() const
 {
   return _peers;
 }
+
+} // namespace aria2
diff --git a/src/DHTPeerLookupTask.h b/src/DHTPeerLookupTask.h
index 396b2033..66a8fff3 100644
--- a/src/DHTPeerLookupTask.h
+++ b/src/DHTPeerLookupTask.h
@@ -36,38 +36,40 @@
 #define _D_DHT_PEER_LOOKUP_TASK_H_
 
 #include "DHTAbstractNodeLookupTask.h"
-#include "BtContextDecl.h"
-#include "PeerDecl.h"
 #include <map>
 
+namespace aria2 {
+
+class BtContext;
+class Peer;
 class PeerStorage;
-typedef SharedHandle<PeerStorage> PeerStorageHandle;
 class BtRuntime;
-typedef SharedHandle<BtRuntime> BtRuntimeHandle;
 
 class DHTPeerLookupTask:public DHTAbstractNodeLookupTask {
 private:
-  std::map<string, string> _tokenStorage;
+  std::map<std::string, std::string> _tokenStorage;
 
-  Peers _peers;
+  std::deque<SharedHandle<Peer> > _peers;
 
-  BtContextHandle _ctx;
+  SharedHandle<BtContext> _ctx;
 
-  PeerStorageHandle _peerStorage;
+  SharedHandle<PeerStorage> _peerStorage;
 
-  BtRuntimeHandle _btRuntime;
+  SharedHandle<BtRuntime> _btRuntime;
 public:
-  DHTPeerLookupTask(const BtContextHandle& btContext);
+  DHTPeerLookupTask(const SharedHandle<BtContext>& btContext);
 
-  virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message);
+  virtual std::deque<SharedHandle<DHTNode> > getNodesFromMessage(const SharedHandle<DHTMessage>& message);
   
-  virtual void onReceivedInternal(const DHTMessageHandle& message);
+  virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message);
   
-  virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode);
+  virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode);
 
   virtual void onFinish();
   
-  const Peers& getPeers() const;
+  const std::deque<SharedHandle<Peer> >& getPeers() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PEER_LOOKUP_TASK_H_
diff --git a/src/DHTPingMessage.cc b/src/DHTPingMessage.cc
index 844a4a9e..45fa1ee5 100644
--- a/src/DHTPingMessage.cc
+++ b/src/DHTPingMessage.cc
@@ -34,15 +34,18 @@
 /* copyright --> */
 #include "DHTPingMessage.h"
 #include "DHTNode.h"
+#include "Dictionary.h"
 #include "Data.h"
 #include "DHTConstants.h"
 #include "DHTMessageDispatcher.h"
 #include "DHTMessageFactory.h"
 #include "DHTMessageCallback.h"
 
-DHTPingMessage::DHTPingMessage(const DHTNodeHandle& localNode,
-			       const DHTNodeHandle& remoteNode,
-			       const string& transactionID):
+namespace aria2 {
+
+DHTPingMessage::DHTPingMessage(const SharedHandle<DHTNode>& localNode,
+			       const SharedHandle<DHTNode>& remoteNode,
+			       const std::string& transactionID):
   DHTQueryMessage(localNode, remoteNode, transactionID) {}
 
 DHTPingMessage::~DHTPingMessage() {}
@@ -50,7 +53,7 @@ DHTPingMessage::~DHTPingMessage() {}
 void DHTPingMessage::doReceivedAction()
 {
   // send back ping reply
-  DHTMessageHandle reply = _factory->createPingReplyMessage(_remoteNode, _localNode->getID(), _transactionID);
+  SharedHandle<DHTMessage> reply = _factory->createPingReplyMessage(_remoteNode, _localNode->getID(), _transactionID);
   _dispatcher->addMessageToQueue(reply);
 }
 
@@ -62,9 +65,11 @@ Dictionary* DHTPingMessage::getArgument()
   return a;
 }
 
-string DHTPingMessage::getMessageType() const
+std::string DHTPingMessage::getMessageType() const
 {
   return "ping";
 }
 
 void DHTPingMessage::validate() const {}
+
+} // namespace aria2
diff --git a/src/DHTPingMessage.h b/src/DHTPingMessage.h
index 16b5d8ab..62738683 100644
--- a/src/DHTPingMessage.h
+++ b/src/DHTPingMessage.h
@@ -37,11 +37,13 @@
 
 #include "DHTQueryMessage.h"
 
+namespace aria2 {
+
 class DHTPingMessage:public DHTQueryMessage {
 public:
-  DHTPingMessage(const DHTNodeHandle& localNode,
-		 const DHTNodeHandle& remoteNode,
-		 const string& transactionID = "");
+  DHTPingMessage(const SharedHandle<DHTNode>& localNode,
+		 const SharedHandle<DHTNode>& remoteNode,
+		 const std::string& transactionID = "");
 
   virtual ~DHTPingMessage();
 
@@ -49,9 +51,11 @@ public:
 
   virtual Dictionary* getArgument();
 
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PING_MESSAGE_H_
diff --git a/src/DHTPingReplyMessage.cc b/src/DHTPingReplyMessage.cc
index f8ac1848..068483fb 100644
--- a/src/DHTPingReplyMessage.cc
+++ b/src/DHTPingReplyMessage.cc
@@ -36,11 +36,14 @@
 #include "DHTNode.h"
 #include "Dictionary.h"
 #include "Data.h"
+#include <cstring>
 
-DHTPingReplyMessage::DHTPingReplyMessage(const DHTNodeHandle& localNode,
-					 const DHTNodeHandle& remoteNode,
+namespace aria2 {
+
+DHTPingReplyMessage::DHTPingReplyMessage(const SharedHandle<DHTNode>& localNode,
+					 const SharedHandle<DHTNode>& remoteNode,
 					 const unsigned char* id,
-					 const string& transactionID):
+					 const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID)
 {
   memcpy(_id, id, DHT_ID_LENGTH);
@@ -57,9 +60,11 @@ Dictionary* DHTPingReplyMessage::getResponse()
   return r;
 }
 
-string DHTPingReplyMessage::getMessageType() const
+std::string DHTPingReplyMessage::getMessageType() const
 {
   return "ping";
 }
 
 void DHTPingReplyMessage::validate() const {}
+
+} // namespace aria2
diff --git a/src/DHTPingReplyMessage.h b/src/DHTPingReplyMessage.h
index 33659956..b95eaa01 100644
--- a/src/DHTPingReplyMessage.h
+++ b/src/DHTPingReplyMessage.h
@@ -38,14 +38,16 @@
 #include "DHTResponseMessage.h"
 #include "DHTConstants.h"
 
+namespace aria2 {
+
 class DHTPingReplyMessage:public DHTResponseMessage {
 private:
   unsigned char _id[DHT_ID_LENGTH];
 public:
-  DHTPingReplyMessage(const DHTNodeHandle& localNode,
-		      const DHTNodeHandle& remoteNode,
+  DHTPingReplyMessage(const SharedHandle<DHTNode>& localNode,
+		      const SharedHandle<DHTNode>& remoteNode,
 		      const unsigned char* id,
-		      const string& transactionID);
+		      const std::string& transactionID);
 
   virtual ~DHTPingReplyMessage();
 
@@ -53,7 +55,7 @@ public:
 
   virtual Dictionary* getResponse();
 
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   virtual void validate() const;
 
@@ -63,4 +65,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PING_REPLY_MESSAGE_H_
diff --git a/src/DHTPingTask.cc b/src/DHTPingTask.cc
index 9f31b388..4eb03025 100644
--- a/src/DHTPingTask.cc
+++ b/src/DHTPingTask.cc
@@ -40,7 +40,9 @@
 #include "DHTNode.h"
 #include "DHTConstants.h"
 
-DHTPingTask::DHTPingTask(const DHTNodeHandle& remoteNode, size_t numMaxRetry):
+namespace aria2 {
+
+DHTPingTask::DHTPingTask(const SharedHandle<DHTNode>& remoteNode, size_t numMaxRetry):
   _remoteNode(remoteNode),
   _numMaxRetry(numMaxRetry),
   _numRetry(0),
@@ -52,24 +54,24 @@ DHTPingTask::~DHTPingTask() {}
 
 void DHTPingTask::startup()
 {
-  DHTMessageHandle m = _factory->createPingMessage(_remoteNode);
+  SharedHandle<DHTMessage> m = _factory->createPingMessage(_remoteNode);
   _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this));
 }
 
-void DHTPingTask::onReceived(const DHTMessageHandle& message)
+void DHTPingTask::onReceived(const SharedHandle<DHTMessage>& message)
 {
   _pingSuccessful = true;
   _finished = true;
 }
 
-void DHTPingTask::onTimeout(const DHTNodeHandle& node)
+void DHTPingTask::onTimeout(const SharedHandle<DHTNode>& node)
 {
   ++_numRetry;
   if(_numRetry >= _numMaxRetry) {
     _pingSuccessful = false;
     _finished = true;
   } else {
-    DHTMessageHandle m = _factory->createPingMessage(_remoteNode);
+    SharedHandle<DHTMessage> m = _factory->createPingMessage(_remoteNode);
     _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this));
   }
 }
@@ -78,3 +80,5 @@ bool DHTPingTask::isPingSuccessful() const
 {
   return _pingSuccessful;
 }
+
+} // namespace aria2
diff --git a/src/DHTPingTask.h b/src/DHTPingTask.h
index 7e84cbc3..27232c24 100644
--- a/src/DHTPingTask.h
+++ b/src/DHTPingTask.h
@@ -38,9 +38,11 @@
 #include "DHTAbstractTask.h"
 #include "DHTMessageCallbackListener.h"
 
+namespace aria2 {
+
 class DHTPingTask:public DHTAbstractTask, public DHTMessageCallbackListener {
 protected:
-  DHTNodeHandle _remoteNode;
+  SharedHandle<DHTNode> _remoteNode;
 
   size_t _numMaxRetry;
 
@@ -50,15 +52,15 @@ protected:
 
   time_t _timeout;
 public:
-  DHTPingTask(const DHTNodeHandle& remoteNode, size_t numMaxRetry = 0);
+  DHTPingTask(const SharedHandle<DHTNode>& remoteNode, size_t numMaxRetry = 0);
 
   virtual ~DHTPingTask();
 
   virtual void startup();
 
-  virtual void onReceived(const DHTMessageHandle& message);
+  virtual void onReceived(const SharedHandle<DHTMessage>& message);
 
-  virtual void onTimeout(const DHTNodeHandle& node);  
+  virtual void onTimeout(const SharedHandle<DHTNode>& node);  
 
   void setTimeout(time_t timeout)
   {
@@ -68,4 +70,6 @@ public:
   bool isPingSuccessful() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_PING_TASK_H_
diff --git a/src/DHTQueryMessage.cc b/src/DHTQueryMessage.cc
index a6862230..ccc4e150 100644
--- a/src/DHTQueryMessage.cc
+++ b/src/DHTQueryMessage.cc
@@ -35,16 +35,19 @@
 #include "DHTQueryMessage.h"
 #include "DHTNode.h"
 #include "Util.h"
+#include "Dictionary.h"
 #include "Data.h"
 
-DHTQueryMessage::DHTQueryMessage(const DHTNodeHandle& localNode,
-				 const DHTNodeHandle& remoteNode,
-				 const string& transactionID):
+namespace aria2 {
+
+DHTQueryMessage::DHTQueryMessage(const SharedHandle<DHTNode>& localNode,
+				 const SharedHandle<DHTNode>& remoteNode,
+				 const std::string& transactionID):
   DHTAbstractMessage(localNode, remoteNode, transactionID) {}
 
 DHTQueryMessage::~DHTQueryMessage() {}
 
-string DHTQueryMessage::getType() const
+std::string DHTQueryMessage::getType() const
 {
   return "q";
 }
@@ -60,7 +63,7 @@ bool DHTQueryMessage::isReply() const
   return false;
 }
 
-string DHTQueryMessage::toString() const
+std::string DHTQueryMessage::toString() const
 {
   return "dht query "+getMessageType()+
     " TransactionID="+Util::toHex(_transactionID)+
@@ -68,3 +71,5 @@ string DHTQueryMessage::toString() const
     _remoteNode->getIPAddress()+":"+Util::itos(_remoteNode->getPort())+
     ", id="+Util::toHex(_remoteNode->getID(), DHT_ID_LENGTH);
 }
+
+} // namespace aria2
diff --git a/src/DHTQueryMessage.h b/src/DHTQueryMessage.h
index 29057f67..8bb9a089 100644
--- a/src/DHTQueryMessage.h
+++ b/src/DHTQueryMessage.h
@@ -37,15 +37,17 @@
 
 #include "DHTAbstractMessage.h"
 
+namespace aria2 {
+
 class DHTQueryMessage:public DHTAbstractMessage {
 public:
-  DHTQueryMessage(const DHTNodeHandle& localNode,
-		  const DHTNodeHandle& remoteNode,
-		  const string& transactionID = "");
+  DHTQueryMessage(const SharedHandle<DHTNode>& localNode,
+		  const SharedHandle<DHTNode>& remoteNode,
+		  const std::string& transactionID = "");
 
   virtual ~DHTQueryMessage();
 
-  virtual string getType() const;
+  virtual std::string getType() const;
 
   virtual void fillMessage(Dictionary* message);
 
@@ -53,7 +55,9 @@ public:
   
   virtual bool isReply() const;
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_QUERY_MESSAGE_H_
diff --git a/src/DHTRegistry.cc b/src/DHTRegistry.cc
index 7210c0b3..940e5275 100644
--- a/src/DHTRegistry.cc
+++ b/src/DHTRegistry.cc
@@ -43,23 +43,25 @@
 #include "DHTMessageReceiver.h"
 #include "DHTMessageFactory.h"
 
-DHTNodeHandle DHTRegistry::_localNode = 0;
+namespace aria2 {
 
-DHTRoutingTableHandle DHTRegistry::_routingTable = 0;
+SharedHandle<DHTNode> DHTRegistry::_localNode = 0;
 
-DHTTaskQueueHandle DHTRegistry::_taskQueue = 0;
+SharedHandle<DHTRoutingTable> DHTRegistry::_routingTable = 0;
 
-DHTTaskFactoryHandle DHTRegistry::_taskFactory = 0;
+SharedHandle<DHTTaskQueue> DHTRegistry::_taskQueue = 0;
 
-DHTPeerAnnounceStorageHandle DHTRegistry::_peerAnnounceStorage = 0;
+SharedHandle<DHTTaskFactory> DHTRegistry::_taskFactory = 0;
 
-DHTTokenTrackerHandle DHTRegistry::_tokenTracker = 0;
+SharedHandle<DHTPeerAnnounceStorage> DHTRegistry::_peerAnnounceStorage = 0;
 
-DHTMessageDispatcherHandle DHTRegistry::_messageDispatcher = 0;
+SharedHandle<DHTTokenTracker> DHTRegistry::_tokenTracker = 0;
 
-DHTMessageReceiverHandle DHTRegistry::_messageReceiver = 0;
+SharedHandle<DHTMessageDispatcher> DHTRegistry::_messageDispatcher = 0;
 
-DHTMessageFactoryHandle DHTRegistry::_messageFactory = 0;
+SharedHandle<DHTMessageReceiver> DHTRegistry::_messageReceiver = 0;
+
+SharedHandle<DHTMessageFactory> DHTRegistry::_messageFactory = 0;
 
 void DHTRegistry::clear()
 {
@@ -73,3 +75,5 @@ void DHTRegistry::clear()
   _messageReceiver = 0;
   _messageFactory = 0;
 }
+
+} // namespace aria2
diff --git a/src/DHTRegistry.h b/src/DHTRegistry.h
index 2962b4ee..c1160a39 100644
--- a/src/DHTRegistry.h
+++ b/src/DHTRegistry.h
@@ -36,39 +36,45 @@
 #define _D_DHT_REGISTRY_H_
 
 #include "common.h"
-#include "DHTNodeDecl.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
-#include "DHTPeerAnnounceStorageDecl.h"
-#include "DHTTokenTrackerDecl.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageReceiverDecl.h"
-#include "DHTMessageFactoryDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTNode;
+class DHTRoutingTable;
+class DHTTaskQueue;
+class DHTTaskFactory;
+class DHTPeerAnnounceStorage;
+class DHTTokenTracker;
+class DHTMessageDispatcher;
+class DHTMessageReceiver;
+class DHTMessageFactory;
 
 class DHTRegistry {
 public:
-  static DHTNodeHandle _localNode;
+  static SharedHandle<DHTNode> _localNode;
 
-  static DHTRoutingTableHandle _routingTable;
+  static SharedHandle<DHTRoutingTable> _routingTable;
 
-  static DHTTaskQueueHandle _taskQueue;
+  static SharedHandle<DHTTaskQueue> _taskQueue;
 
-  static DHTTaskFactoryHandle _taskFactory;
+  static SharedHandle<DHTTaskFactory> _taskFactory;
 
-  static DHTPeerAnnounceStorageHandle _peerAnnounceStorage;
+  static SharedHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage;
 
-  static DHTTokenTrackerHandle _tokenTracker;
+  static SharedHandle<DHTTokenTracker> _tokenTracker;
 
-  static DHTMessageDispatcherHandle _messageDispatcher;
+  static SharedHandle<DHTMessageDispatcher> _messageDispatcher;
 
-  static DHTMessageReceiverHandle _messageReceiver;
+  static SharedHandle<DHTMessageReceiver> _messageReceiver;
 
-  static DHTMessageFactoryHandle _messageFactory;
+  static SharedHandle<DHTMessageFactory> _messageFactory;
 
   static void clear();
 private:
   DHTRegistry();
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_REGISTRY_H_
diff --git a/src/DHTReplaceNodeTask.cc b/src/DHTReplaceNodeTask.cc
index 16d5254d..b1e1cdf4 100644
--- a/src/DHTReplaceNodeTask.cc
+++ b/src/DHTReplaceNodeTask.cc
@@ -41,8 +41,10 @@
 #include "DHTMessageCallbackImpl.h"
 #include "Logger.h"
 
-DHTReplaceNodeTask::DHTReplaceNodeTask(const DHTBucketHandle& bucket,
-				       const DHTNodeHandle& newNode):
+namespace aria2 {
+
+DHTReplaceNodeTask::DHTReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+				       const SharedHandle<DHTNode>& newNode):
   _bucket(bucket),
   _newNode(newNode),
   _numRetry(0),
@@ -58,23 +60,23 @@ void DHTReplaceNodeTask::startup()
 
 void DHTReplaceNodeTask::sendMessage()
 {
-  DHTNodeHandle questionableNode = _bucket->getLRUQuestionableNode();
+  SharedHandle<DHTNode> questionableNode = _bucket->getLRUQuestionableNode();
   if(questionableNode.isNull()) {
     _finished = true;
   } else {
-    DHTMessageHandle m = _factory->createPingMessage(questionableNode);
+    SharedHandle<DHTMessage> m = _factory->createPingMessage(questionableNode);
     _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this));
   }
 }
 
-void DHTReplaceNodeTask::onReceived(const DHTMessageHandle& message)
+void DHTReplaceNodeTask::onReceived(const SharedHandle<DHTMessage>& message)
 {
   _logger->info("ReplaceNode: Ping reply received from %s.",
 		message->getRemoteNode()->toString().c_str());
   _finished = true;
 }
 
-void DHTReplaceNodeTask::onTimeout(const DHTNodeHandle& node)
+void DHTReplaceNodeTask::onTimeout(const SharedHandle<DHTNode>& node)
 {
   ++_numRetry;
   if(_numRetry >= MAX_RETRY) {
@@ -89,3 +91,5 @@ void DHTReplaceNodeTask::onTimeout(const DHTNodeHandle& node)
     sendMessage();
   }
 }
+
+} // namespace aria2
diff --git a/src/DHTReplaceNodeTask.h b/src/DHTReplaceNodeTask.h
index 812c3216..214207cf 100644
--- a/src/DHTReplaceNodeTask.h
+++ b/src/DHTReplaceNodeTask.h
@@ -37,13 +37,16 @@
 
 #include "DHTAbstractTask.h"
 #include "DHTMessageCallbackListener.h"
-#include "DHTBucketDecl.h"
+
+namespace aria2 {
+
+class DHTBucket;
 
 class DHTReplaceNodeTask:public DHTAbstractTask, public DHTMessageCallbackListener {
 private:
-  DHTBucketHandle _bucket;
+  SharedHandle<DHTBucket> _bucket;
 
-  DHTNodeHandle _newNode;
+  SharedHandle<DHTNode> _newNode;
 
   static const size_t MAX_RETRY = 2;
 
@@ -53,15 +56,18 @@ private:
 
   void sendMessage();
 public:
-  DHTReplaceNodeTask(const DHTBucketHandle& bucket, const DHTNodeHandle& newNode);
+  DHTReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+		     const SharedHandle<DHTNode>& newNode);
 
   virtual ~DHTReplaceNodeTask();
 
   virtual void startup();
 
-  virtual void onReceived(const DHTMessageHandle& message);
+  virtual void onReceived(const SharedHandle<DHTMessage>& message);
 
-  virtual void onTimeout(const DHTNodeHandle& node);  
+  virtual void onTimeout(const SharedHandle<DHTNode>& node);  
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_REPLACE_NODE_TASK_H_
diff --git a/src/DHTResponseMessage.cc b/src/DHTResponseMessage.cc
index 6c9f4734..ac2b74e9 100644
--- a/src/DHTResponseMessage.cc
+++ b/src/DHTResponseMessage.cc
@@ -35,16 +35,19 @@
 #include "DHTResponseMessage.h"
 #include "DHTNode.h"
 #include "Util.h"
+#include "Dictionary.h"
 #include "Data.h"
 
-DHTResponseMessage::DHTResponseMessage(const DHTNodeHandle& localNode,
-				       const DHTNodeHandle& remoteNode,
-				       const string& transactionID):
+namespace aria2 {
+
+DHTResponseMessage::DHTResponseMessage(const SharedHandle<DHTNode>& localNode,
+				       const SharedHandle<DHTNode>& remoteNode,
+				       const std::string& transactionID):
   DHTAbstractMessage(localNode, remoteNode, transactionID) {}
 
 DHTResponseMessage::~DHTResponseMessage() {}
 
-string DHTResponseMessage::getType() const
+std::string DHTResponseMessage::getType() const
 {
   return "r";
 }
@@ -59,7 +62,7 @@ bool DHTResponseMessage::isReply() const
   return true;
 }
 
-string DHTResponseMessage::toString() const
+std::string DHTResponseMessage::toString() const
 {
   return "dht response "+getMessageType()+
     " TransactionID="+Util::toHex(_transactionID)+
@@ -67,3 +70,5 @@ string DHTResponseMessage::toString() const
     _remoteNode->getIPAddress()+":"+Util::itos(_remoteNode->getPort())+
     ", id="+Util::toHex(_remoteNode->getID(), DHT_ID_LENGTH);
 }
+
+} // namespace aria2
diff --git a/src/DHTResponseMessage.h b/src/DHTResponseMessage.h
index a41335ea..099f0c73 100644
--- a/src/DHTResponseMessage.h
+++ b/src/DHTResponseMessage.h
@@ -37,15 +37,17 @@
 
 #include "DHTAbstractMessage.h"
 
+namespace aria2 {
+
 class DHTResponseMessage:public DHTAbstractMessage {
 public:
-  DHTResponseMessage(const DHTNodeHandle& localNode,
-		     const DHTNodeHandle& remoteNode,
-		     const string& transactionID);
+  DHTResponseMessage(const SharedHandle<DHTNode>& localNode,
+		     const SharedHandle<DHTNode>& remoteNode,
+		     const std::string& transactionID);
 
   virtual ~DHTResponseMessage();
 
-  virtual string getType() const;
+  virtual std::string getType() const;
 
   virtual void fillMessage(Dictionary* message);
 
@@ -53,7 +55,9 @@ public:
   
   virtual bool isReply() const;
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_RESPONSE_MESSAGE_H_
diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc
index bbf6e1f2..82386f4e 100644
--- a/src/DHTRoutingTable.cc
+++ b/src/DHTRoutingTable.cc
@@ -35,14 +35,17 @@
 #include "DHTRoutingTable.h"
 #include "DHTNode.h"
 #include "DHTBucket.h"
-#include "Util.h"
-#include "LogFactory.h"
 #include "BNode.h"
 #include "DHTTaskQueue.h"
 #include "DHTTaskFactory.h"
 #include "DHTTask.h"
+#include "Util.h"
+#include "LogFactory.h"
+#include "Logger.h"
 
-DHTRoutingTable::DHTRoutingTable(const DHTNodeHandle& localNode):
+namespace aria2 {
+
+DHTRoutingTable::DHTRoutingTable(const SharedHandle<DHTNode>& localNode):
   _localNode(localNode),
   _root(new BNode(new DHTBucket(localNode))),
   _numBucket(1),
@@ -56,21 +59,21 @@ DHTRoutingTable::~DHTRoutingTable()
   delete _root;
 }
 
-bool DHTRoutingTable::addNode(const DHTNodeHandle& node)
+bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node)
 {
   return addNode(node, false);
 }
 
-bool DHTRoutingTable::addGoodNode(const DHTNodeHandle& node)
+bool DHTRoutingTable::addGoodNode(const SharedHandle<DHTNode>& node)
 {
   return addNode(node, true);
 }
 
-bool DHTRoutingTable::addNode(const DHTNodeHandle& node, bool good)
+bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
 {
   _logger->debug("Trying to add node:%s", node->toString().c_str());
   BNode* bnode = BNode::findBNodeFor(_root, node->getID());
-  DHTBucketHandle bucket = bnode->getBucket();
+  SharedHandle<DHTBucket> bucket = bnode->getBucket();
   while(1) {
     if(bucket->addNode(node)) {
       _logger->debug("Added DHTNode.");
@@ -79,7 +82,7 @@ bool DHTRoutingTable::addNode(const DHTNodeHandle& node, bool good)
       _logger->debug("Splitting bucket. Range:%s-%s",
 		     Util::toHex(bucket->getMinID(), DHT_ID_LENGTH).c_str(),
 		     Util::toHex(bucket->getMaxID(), DHT_ID_LENGTH).c_str());
-      DHTBucketHandle r = bucket->split();
+      SharedHandle<DHTBucket> r = bucket->split();
 
       bnode->setBucket(0);
       BNode* lbnode = new BNode(bucket);
@@ -105,7 +108,7 @@ bool DHTRoutingTable::addNode(const DHTNodeHandle& node, bool good)
   return false;
 }
 
-DHTNodes DHTRoutingTable::getClosestKNodes(const unsigned char* key) const
+std::deque<SharedHandle<DHTNode> > DHTRoutingTable::getClosestKNodes(const unsigned char* key) const
 {
   return BNode::findClosestKNodes(_root, key);
 }
@@ -117,55 +120,57 @@ size_t DHTRoutingTable::countBucket() const
 
 void DHTRoutingTable::showBuckets() const
 {/*
-  for(DHTBuckets::const_iterator itr = _buckets.begin(); itr != _buckets.end(); ++itr) {
+  for(std::deque<SharedHandle<DHTBucket> >::const_iterator itr = _buckets.begin(); itr != _buckets.end(); ++itr) {
     cerr << "prefix = " << (*itr)->getPrefixLength() << ", "
 	 << "nodes = " << (*itr)->countNode() << endl;
   }
  */
 }
 
-DHTBucketHandle DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const
+SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const
 {
   return BNode::findBucketFor(_root, nodeID);
 }
 
-DHTBucketHandle DHTRoutingTable::getBucketFor(const DHTNodeHandle& node) const
+SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const SharedHandle<DHTNode>& node) const
 {
   return getBucketFor(node->getID());
 }
 
-DHTNodeHandle DHTRoutingTable::getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const
+SharedHandle<DHTNode> DHTRoutingTable::getNode(const unsigned char* nodeID, const std::string& ipaddr, uint16_t port) const
 {
-  DHTBucketHandle bucket = getBucketFor(nodeID);
+  SharedHandle<DHTBucket> bucket = getBucketFor(nodeID);
   return bucket->getNode(nodeID, ipaddr, port);
 }
 
-void DHTRoutingTable::dropNode(const DHTNodeHandle& node)
+void DHTRoutingTable::dropNode(const SharedHandle<DHTNode>& node)
 {
   getBucketFor(node)->dropNode(node);
 }
 /*
-void DHTRoutingTable::moveBucketHead(const DHTNodeHandle& node)
+void DHTRoutingTable::moveBucketHead(const SharedHandle<DHTNode>& node)
 {
   getBucketFor(node)->moveToHead(node);
 }
 */
-void DHTRoutingTable::moveBucketTail(const DHTNodeHandle& node)
+void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node)
 {
   getBucketFor(node)->moveToTail(node);
 }
 
-DHTBuckets DHTRoutingTable::getBuckets() const
+std::deque<SharedHandle<DHTBucket> > DHTRoutingTable::getBuckets() const
 {
   return BNode::enumerateBucket(_root);
 }
 
-void DHTRoutingTable::setTaskQueue(const DHTTaskQueueHandle& taskQueue)
+void DHTRoutingTable::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue)
 {
   _taskQueue = taskQueue;
 }
 
-void DHTRoutingTable::setTaskFactory(const DHTTaskFactoryHandle& taskFactory)
+void DHTRoutingTable::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory)
 {
   _taskFactory = taskFactory;
 }
+
+} // namespace aria2
diff --git a/src/DHTRoutingTable.h b/src/DHTRoutingTable.h
index 7afa9209..89640ae6 100644
--- a/src/DHTRoutingTable.h
+++ b/src/DHTRoutingTable.h
@@ -36,62 +36,68 @@
 #define _D_DHT_ROUTING_TABLE_H_
 
 #include "common.h"
-#include "DHTBucketDecl.h"
-#include "DHTNodeDecl.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
 
+namespace aria2 {
+
+class DHTNode;
+class DHTBucket;
+class DHTTaskQueue;
+class DHTTaskFactory;
 class BNode;
-
 class Logger;
 
 class DHTRoutingTable {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
   BNode* _root;
 
   size_t _numBucket;
 
-  DHTTaskQueueHandle _taskQueue;
+  SharedHandle<DHTTaskQueue> _taskQueue;
 
-  DHTTaskFactoryHandle _taskFactory;
+  SharedHandle<DHTTaskFactory> _taskFactory;
 
   const Logger* _logger;
 
-  bool addNode(const DHTNodeHandle& node, bool good);
+  bool addNode(const SharedHandle<DHTNode>& node, bool good);
 public:
-  DHTRoutingTable(const DHTNodeHandle& localNode);
+  DHTRoutingTable(const SharedHandle<DHTNode>& localNode);
 
   ~DHTRoutingTable();
 
-  bool addNode(const DHTNodeHandle& node);
+  bool addNode(const SharedHandle<DHTNode>& node);
 
-  bool addGoodNode(const DHTNodeHandle& node);
+  bool addGoodNode(const SharedHandle<DHTNode>& node);
 
-  DHTNodes getClosestKNodes(const unsigned char* key) const;
+  std::deque<SharedHandle<DHTNode> > getClosestKNodes(const unsigned char* key) const;
 
   size_t countBucket() const;
 
   void showBuckets() const;
 
-  void dropNode(const DHTNodeHandle& node);
+  void dropNode(const SharedHandle<DHTNode>& node);
 
-  void moveBucketHead(const DHTNodeHandle& node);
+  void moveBucketHead(const SharedHandle<DHTNode>& node);
 
-  void moveBucketTail(const DHTNodeHandle& node);
+  void moveBucketTail(const SharedHandle<DHTNode>& node);
   
-  DHTBucketHandle getBucketFor(const unsigned char* nodeID) const;
+  SharedHandle<DHTBucket> getBucketFor(const unsigned char* nodeID) const;
 
-  DHTBucketHandle getBucketFor(const DHTNodeHandle& node) const;
+  SharedHandle<DHTBucket> getBucketFor(const SharedHandle<DHTNode>& node) const;
 
-  DHTNodeHandle getNode(const unsigned char* id, const string& ipaddr, uint16_t port) const;
+  SharedHandle<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
   
-  DHTBuckets getBuckets() const;
+  std::deque<SharedHandle<DHTBucket> > getBuckets() const;
 
-  void setTaskQueue(const DHTTaskQueueHandle& taskQueue);
+  void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 
-  void setTaskFactory(const DHTTaskFactoryHandle& taskFactory);
+  void setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ROUTING_TABLE_H_
diff --git a/src/DHTRoutingTableDecl.h b/src/DHTRoutingTableDecl.h
deleted file mode 100644
index 517dbf27..00000000
--- a/src/DHTRoutingTableDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_ROUTING_TABLE_DECL_H_
-#define _D_DHT_ROUTING_TABLE_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTRoutingTable;
-typedef SharedHandle<DHTRoutingTable> DHTRoutingTableHandle;
-
-#endif // _D_DHT_ROUTING_TABLE_DECL_H_
diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc
index 17b981f4..c370ff09 100644
--- a/src/DHTRoutingTableDeserializer.cc
+++ b/src/DHTRoutingTableDeserializer.cc
@@ -37,27 +37,31 @@
 #include "DHTConstants.h"
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
+#include "Logger.h"
 #include <arpa/inet.h>
 #include <cerrno>
 #include <cstring>
 #include <istream>
+#include <utility>
+
+namespace aria2 {
 
 DHTRoutingTableDeserializer::DHTRoutingTableDeserializer():
   _localNode(0) {}
 
 DHTRoutingTableDeserializer::~DHTRoutingTableDeserializer() {}
 
-DHTNodeHandle DHTRoutingTableDeserializer::getLocalNode() const
+SharedHandle<DHTNode> DHTRoutingTableDeserializer::getLocalNode() const
 {
   return _localNode;
 }
 
-const DHTNodes& DHTRoutingTableDeserializer::getNodes() const
+const std::deque<SharedHandle<DHTNode> >& DHTRoutingTableDeserializer::getNodes() const
 {
   return _nodes;
 }
 
-void DHTRoutingTableDeserializer::deserialize(istream& in)
+void DHTRoutingTableDeserializer::deserialize(std::istream& in)
 {
   try {
     char header[8];
@@ -92,7 +96,7 @@ void DHTRoutingTableDeserializer::deserialize(istream& in)
     in.read(buf, 8);
     // localnode ID
     in.read(buf, DHT_ID_LENGTH);
-    DHTNodeHandle localNode = new DHTNode(reinterpret_cast<const unsigned char*>(buf));
+    SharedHandle<DHTNode> localNode = new DHTNode(reinterpret_cast<const unsigned char*>(buf));
     // 4bytes reserved
     in.read(buf, 4);
 
@@ -111,13 +115,13 @@ void DHTRoutingTableDeserializer::deserialize(istream& in)
 	in.read(buf, 26);
 	continue;
       }
-      pair<string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
+      std::pair<std::string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
       // 2bytes reserved
       in.read(buf, 2);
       // localnode ID
       in.read(buf, DHT_ID_LENGTH);
 
-      DHTNodeHandle node = new DHTNode(reinterpret_cast<const unsigned char*>(buf));
+      SharedHandle<DHTNode> node = new DHTNode(reinterpret_cast<const unsigned char*>(buf));
       node->setIPAddress(peer.first);
       node->setPort(peer.second);
       // 4bytes reserved
@@ -126,9 +130,11 @@ void DHTRoutingTableDeserializer::deserialize(istream& in)
       _nodes.push_back(node);
     }
     _localNode = localNode;
-  } catch(ios::failure const& exception) {
+  } catch(std::ios::failure const& exception) {
     _nodes.clear();
     throw new DlAbortEx("Failed to load DHT routing table. cause:%s",
 			strerror(errno));
   }
 }
+
+} // namespace aria2
diff --git a/src/DHTRoutingTableDeserializer.h b/src/DHTRoutingTableDeserializer.h
index e3122f55..8998dba6 100644
--- a/src/DHTRoutingTableDeserializer.h
+++ b/src/DHTRoutingTableDeserializer.h
@@ -36,15 +36,20 @@
 #define _D_DHT_ROUTING_TABLE_DESERIALIZER_H_
 
 #include "common.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
+#include <deque>
 #include <iosfwd>
 
+namespace aria2 {
+
+class DHTNode;
+
 class DHTRoutingTableDeserializer {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
-  DHTNodes _nodes;
+  std::deque<SharedHandle<DHTNode> > _nodes;
 
   Time _serializedTime;
 public:
@@ -52,16 +57,18 @@ public:
 
   ~DHTRoutingTableDeserializer();
 
-  DHTNodeHandle getLocalNode() const;
+  SharedHandle<DHTNode> getLocalNode() const;
 
-  const DHTNodes& getNodes() const;
+  const std::deque<SharedHandle<DHTNode> >& getNodes() const;
 
   Time getSerializedTime() const
   {
     return _serializedTime;
   }
 
-  void deserialize(istream& in);
+  void deserialize(std::istream& in);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ROUTING_TABLE_DESERIALIZER_H_
diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc
index cda73ef9..999e5a52 100644
--- a/src/DHTRoutingTableSerializer.cc
+++ b/src/DHTRoutingTableSerializer.cc
@@ -37,26 +37,29 @@
 #include "DlAbortEx.h"
 #include "DHTConstants.h"
 #include "PeerMessageUtil.h"
+#include "Logger.h"
 #include <arpa/inet.h>
 #include <cerrno>
 #include <cstring>
 #include <ostream>
 
+namespace aria2 {
+
 DHTRoutingTableSerializer::DHTRoutingTableSerializer():_localNode(0) {}
 
 DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {}
 
-void DHTRoutingTableSerializer::setLocalNode(const DHTNodeHandle& localNode)
+void DHTRoutingTableSerializer::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
 
-void DHTRoutingTableSerializer::setNodes(const DHTNodes& nodes)
+void DHTRoutingTableSerializer::setNodes(const std::deque<SharedHandle<DHTNode> >& nodes)
 {
   _nodes = nodes;
 }
 
-void DHTRoutingTableSerializer::serialize(ostream& o)
+void DHTRoutingTableSerializer::serialize(std::ostream& o)
 {
   char header[8];
   memset(header, 0, sizeof(header));
@@ -94,8 +97,8 @@ void DHTRoutingTableSerializer::serialize(ostream& o)
     o.write(zero, 4);
 
     // nodes
-    for(DHTNodes::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) {
-      const DHTNodeHandle& node = *i;
+    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) {
+      const SharedHandle<DHTNode>& node = *i;
       // 6bytes: write IP address + port in Compact IP-address/port info form.
       char compactPeer[6];
       if(!PeerMessageUtil::createcompact(compactPeer, node->getIPAddress(), node->getPort())) {
@@ -109,8 +112,10 @@ void DHTRoutingTableSerializer::serialize(ostream& o)
       // 4bytes reserved
       o.write(zero, 4);
     }
-  } catch(ios::failure const& exception) {
+  } catch(std::ios::failure const& exception) {
     throw new DlAbortEx("Failed to save DHT routing table. cause:%s",
 			strerror(errno));
   }
 }
+
+} // namespace aria2
diff --git a/src/DHTRoutingTableSerializer.h b/src/DHTRoutingTableSerializer.h
index 9121379d..5b4f0cd3 100644
--- a/src/DHTRoutingTableSerializer.h
+++ b/src/DHTRoutingTableSerializer.h
@@ -36,24 +36,31 @@
 #define _D_DHT_ROUTING_TABLE_SERIALIZER_H_
 
 #include "common.h"
-#include "DHTNodeDecl.h"
+#include "SharedHandle.h"
+#include <deque>
 #include <iosfwd>
 
+namespace aria2 {
+
+class DHTNode;
+
 class DHTRoutingTableSerializer {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
-  DHTNodes _nodes;
+  std::deque<SharedHandle<DHTNode> > _nodes;
 public:
   DHTRoutingTableSerializer();
 
   ~DHTRoutingTableSerializer();
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 
-  void setNodes(const DHTNodes& nodes);
+  void setNodes(const std::deque<SharedHandle<DHTNode> >& nodes);
 
-  void serialize(ostream& o);
+  void serialize(std::ostream& o);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_ROUTING_TABLE_SERIALIZER_H_
diff --git a/src/DHTSetup.cc b/src/DHTSetup.cc
index d1708921..208c13ed 100644
--- a/src/DHTSetup.cc
+++ b/src/DHTSetup.cc
@@ -34,7 +34,9 @@
 /* copyright --> */
 #include "DHTSetup.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
+#include "File.h"
 #include "DHTNode.h"
 #include "DHTConnectionImpl.h"
 #include "DHTRoutingTable.h"
@@ -58,10 +60,13 @@
 #include "CUIDCounter.h"
 #include "prefs.h"
 #include "Option.h"
+#include "SocketCore.h"
 #include "DlAbortEx.h"
 #include "RecoverableException.h"
 #include <fstream>
 
+namespace aria2 {
+
 size_t DHTSetup::_initialized = 0;
 
 DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {}
@@ -76,14 +81,14 @@ Commands DHTSetup::setup(DownloadEngine* e, const Option* option)
   try {
     // load routing table and localnode id here
 
-    DHTNodeHandle localNode = 0;
+    SharedHandle<DHTNode> localNode = 0;
 
     DHTRoutingTableDeserializer deserializer;
-    string dhtFile = option->get(PREF_DHT_FILE_PATH);
+    std::string dhtFile = option->get(PREF_DHT_FILE_PATH);
     if(File(dhtFile).isFile()) {
       try {
-	ifstream in(dhtFile.c_str());
-	in.exceptions(ios::failbit);
+	std::ifstream in(dhtFile.c_str());
+	in.exceptions(std::ios::failbit);
 	deserializer.deserialize(in);
 	localNode = deserializer.getLocalNode();
       } catch(RecoverableException* e) {
@@ -108,23 +113,23 @@ Commands DHTSetup::setup(DownloadEngine* e, const Option* option)
     _logger->debug("Initialized local node ID=%s",
 		   Util::toHex(localNode->getID(), DHT_ID_LENGTH).c_str());
 
-    DHTRoutingTableHandle routingTable = new DHTRoutingTable(localNode);
+    SharedHandle<DHTRoutingTable> routingTable = new DHTRoutingTable(localNode);
 
     SharedHandle<DHTMessageFactoryImpl> factory = new DHTMessageFactoryImpl();
 
-    DHTMessageTrackerHandle tracker = new DHTMessageTracker();
+    SharedHandle<DHTMessageTracker> tracker = new DHTMessageTracker();
 
-    DHTMessageDispatcherHandle dispatcher = new DHTMessageDispatcher(tracker);
+    SharedHandle<DHTMessageDispatcher> dispatcher = new DHTMessageDispatcher(tracker);
 
-    DHTMessageReceiverHandle receiver = new DHTMessageReceiver(tracker);
+    SharedHandle<DHTMessageReceiver> receiver = new DHTMessageReceiver(tracker);
 
-    DHTTaskQueueHandle taskQueue = new DHTTaskQueueImpl();
+    SharedHandle<DHTTaskQueue> taskQueue = new DHTTaskQueueImpl();
 
     SharedHandle<DHTTaskFactoryImpl> taskFactory = new DHTTaskFactoryImpl();
 
-    DHTPeerAnnounceStorageHandle peerAnnounceStorage = new DHTPeerAnnounceStorage();
+    SharedHandle<DHTPeerAnnounceStorage> peerAnnounceStorage = new DHTPeerAnnounceStorage();
 
-    DHTTokenTrackerHandle tokenTracker = new DHTTokenTracker();
+    SharedHandle<DHTTokenTracker> tokenTracker = new DHTTokenTracker();
 
     // wiring up
     tracker->setRoutingTable(routingTable);
@@ -165,8 +170,8 @@ Commands DHTSetup::setup(DownloadEngine* e, const Option* option)
     DHTRegistry::_messageFactory = factory;
 
     // add deserialized nodes to routing table
-    const DHTNodes& desnodes = deserializer.getNodes();
-    for(DHTNodes::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) {
+    const std::deque<SharedHandle<DHTNode> >& desnodes = deserializer.getNodes();
+    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) {
       routingTable->addNode(*i);
     }
     if(!desnodes.empty() && deserializer.getSerializedTime().elapsed(DHT_BUCKET_REFRESH_INTERVAL)) {
@@ -231,3 +236,5 @@ bool DHTSetup::initialized()
 {
   return _initialized;
 }
+
+} // namespace aria2
diff --git a/src/DHTSetup.h b/src/DHTSetup.h
index eb01eb98..be001877 100644
--- a/src/DHTSetup.h
+++ b/src/DHTSetup.h
@@ -36,12 +36,13 @@
 #define _D_DHT_SETUP_H_
 
 #include "common.h"
+#include <deque>
 
+namespace aria2 {
 class Logger;
 class Option;
 class DownloadEngine;
 class Command;
-typedef deque<Command*> Commands;
 
 class DHTSetup {
 private:
@@ -54,9 +55,11 @@ public:
 
   ~DHTSetup();
 
-  Commands setup(DownloadEngine* e, const Option* option);
+  std::deque<Command*> setup(DownloadEngine* e, const Option* option);
 
   static bool initialized();
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_SETUP_H_
diff --git a/src/DHTTask.h b/src/DHTTask.h
index 59bac5a1..09cce633 100644
--- a/src/DHTTask.h
+++ b/src/DHTTask.h
@@ -36,7 +36,8 @@
 #define _D_DHT_TASK_H_
 
 #include "common.h"
-#include "DHTTaskDecl.h"
+
+namespace aria2  {
 
 class DHTTask {
 public:
@@ -47,4 +48,6 @@ public:
   virtual bool finished() = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TASK_H_
diff --git a/src/DHTTaskDecl.h b/src/DHTTaskDecl.h
deleted file mode 100644
index c837c8fe..00000000
--- a/src/DHTTaskDecl.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_TASK_DECL_H_
-#define _D_DHT_TASK_DECL_H_
-
-#include "SharedHandle.h"
-#include <deque>
-
-class DHTTask;
-typedef SharedHandle<DHTTask> DHTTaskHandle;
-typedef std::deque<DHTTaskHandle> DHTTasks;
-
-#endif // _D_DHT_TASK_DECL_H_
diff --git a/src/DHTTaskFactory.h b/src/DHTTaskFactory.h
index a603b35d..c0149729 100644
--- a/src/DHTTaskFactory.h
+++ b/src/DHTTaskFactory.h
@@ -36,29 +36,39 @@
 #define _D_DHT_TASK_FACTORY_H_
 
 #include "common.h"
-#include "DHTTaskFactoryDecl.h"
-#include "DHTTaskDecl.h"
-#include "DHTNodeDecl.h"
-#include "DHTBucketDecl.h"
-#include "BtContextDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class BtContext;
+class DHTTask;
+class DHTNode;
+class DHTBucket;
 
 class DHTTaskFactory {
 public:
   virtual ~DHTTaskFactory() {}
 
-  virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode,
-				       size_t numRetry = 0) = 0;
+  virtual SharedHandle<DHTTask>
+  createPingTask(const SharedHandle<DHTNode>& remoteNode,
+		 size_t numRetry = 0) = 0;
 
-  virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID) = 0;
+  virtual SharedHandle<DHTTask>
+  createNodeLookupTask(const unsigned char* targetID) = 0;
 
-  virtual DHTTaskHandle createBucketRefreshTask() = 0;
+  virtual SharedHandle<DHTTask> createBucketRefreshTask() = 0;
 
-  virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx) = 0;
+  virtual SharedHandle<DHTTask>
+  createPeerLookupTask(const SharedHandle<BtContext>& ctx) = 0;
   
-  virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash) = 0;
+  virtual SharedHandle<DHTTask>
+  createPeerAnnounceTask(const unsigned char* infoHash) = 0;
 
-  virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket,
-					      const DHTNodeHandle& newNode) = 0;
+  virtual SharedHandle<DHTTask>
+  createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+			const SharedHandle<DHTNode>& newNode) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TASK_FACTORY_H_
diff --git a/src/DHTTaskFactoryDecl.h b/src/DHTTaskFactoryDecl.h
deleted file mode 100644
index a1e442e5..00000000
--- a/src/DHTTaskFactoryDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_TASK_FACTORY_DECL_H_
-#define _D_DHT_TASK_FACTORY_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTTaskFactory;
-typedef SharedHandle<DHTTaskFactory> DHTTaskFactoryHandle;
-
-#endif // _D_DHT_TASK_FACTORY_DECL_H_
diff --git a/src/DHTTaskFactoryImpl.cc b/src/DHTTaskFactoryImpl.cc
index 9fd31342..c4f2101e 100644
--- a/src/DHTTaskFactoryImpl.cc
+++ b/src/DHTTaskFactoryImpl.cc
@@ -39,6 +39,7 @@
 #include "DHTMessageFactory.h"
 #include "DHTTaskQueue.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "DHTPingTask.h"
 #include "DHTNodeLookupTask.h"
 #include "DHTBucketRefreshTask.h"
@@ -50,6 +51,8 @@
 #include "PeerStorage.h"
 #include "BtRuntime.h"
 
+namespace aria2 {
+
 DHTTaskFactoryImpl::DHTTaskFactoryImpl():_localNode(0),
 					 _routingTable(0),
 					 _dispatcher(0),
@@ -59,8 +62,8 @@ DHTTaskFactoryImpl::DHTTaskFactoryImpl():_localNode(0),
 
 DHTTaskFactoryImpl::~DHTTaskFactoryImpl() {}
 
-DHTTaskHandle
-DHTTaskFactoryImpl::createPingTask(const DHTNodeHandle& remoteNode,
+SharedHandle<DHTTask>
+DHTTaskFactoryImpl::createPingTask(const SharedHandle<DHTNode>& remoteNode,
 				   size_t numRetry)
 {
   SharedHandle<DHTPingTask> task = new DHTPingTask(remoteNode, numRetry);
@@ -68,7 +71,7 @@ DHTTaskFactoryImpl::createPingTask(const DHTNodeHandle& remoteNode,
   return task;
 }
 
-DHTTaskHandle
+SharedHandle<DHTTask>
 DHTTaskFactoryImpl::createNodeLookupTask(const unsigned char* targetID)
 {
   SharedHandle<DHTNodeLookupTask> task = new DHTNodeLookupTask(targetID);
@@ -76,7 +79,7 @@ DHTTaskFactoryImpl::createNodeLookupTask(const unsigned char* targetID)
   return task;
 }
 
-DHTTaskHandle
+SharedHandle<DHTTask>
 DHTTaskFactoryImpl::createBucketRefreshTask()
 {
   SharedHandle<DHTBucketRefreshTask> task = new DHTBucketRefreshTask();
@@ -84,31 +87,31 @@ DHTTaskFactoryImpl::createBucketRefreshTask()
   return task;
 }
 
-DHTTaskHandle
-DHTTaskFactoryImpl::createPeerLookupTask(const BtContextHandle& ctx)
+SharedHandle<DHTTask>
+DHTTaskFactoryImpl::createPeerLookupTask(const SharedHandle<BtContext>& ctx)
 {
   SharedHandle<DHTPeerLookupTask> task = new DHTPeerLookupTask(ctx);
   setCommonProperty(task);
   return task;
 }
 
-DHTTaskHandle
+SharedHandle<DHTTask>
 DHTTaskFactoryImpl::createPeerAnnounceTask(const unsigned char* infoHash)
 {
   // TODO
   return 0;
 }
 
-DHTTaskHandle
-DHTTaskFactoryImpl::createReplaceNodeTask(const DHTBucketHandle& bucket,
-					  const DHTNodeHandle& newNode)
+SharedHandle<DHTTask>
+DHTTaskFactoryImpl::createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+					  const SharedHandle<DHTNode>& newNode)
 {
   SharedHandle<DHTReplaceNodeTask> task = new DHTReplaceNodeTask(bucket, newNode);
   setCommonProperty(task);
   return task;
 }
 
-void DHTTaskFactoryImpl::setCommonProperty(const DHTAbstractTaskHandle& task)
+void DHTTaskFactoryImpl::setCommonProperty(const SharedHandle<DHTAbstractTask>& task)
 {
   task->setRoutingTable(_routingTable);
   task->setMessageDispatcher(_dispatcher);
@@ -137,7 +140,9 @@ void DHTTaskFactoryImpl::setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue)
   _taskQueue = taskQueue;
 }
 
-void DHTTaskFactoryImpl::setLocalNode(const DHTNodeHandle& localNode)
+void DHTTaskFactoryImpl::setLocalNode(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
+
+} // namespace aria2
diff --git a/src/DHTTaskFactoryImpl.h b/src/DHTTaskFactoryImpl.h
index 0324f101..f8ab278e 100644
--- a/src/DHTTaskFactoryImpl.h
+++ b/src/DHTTaskFactoryImpl.h
@@ -36,18 +36,20 @@
 #define _D_DHT_TASK_FACTORY_IMPL_H_
 
 #include "DHTTaskFactory.h"
-#include "DHTNodeDecl.h"
-#include "DHTRoutingTableDecl.h"
-#include "DHTMessageDispatcherDecl.h"
-#include "DHTMessageFactoryDecl.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTAbstractTaskDecl.h"
 
+namespace aria2 {
+
+class DHTNode;
+class DHTRoutingTable;
+class DHTMessageDispatcher;
+class DHTMessageFactory;
+class DHTTaskQueue;
+class DHTAbstractTask;
 class Logger;
 
 class DHTTaskFactoryImpl:public DHTTaskFactory {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 
   WeakHandle<DHTRoutingTable> _routingTable;
 
@@ -59,25 +61,30 @@ private:
 
   const Logger* _logger;
 
-  void setCommonProperty(const DHTAbstractTaskHandle& task);
+  void setCommonProperty(const SharedHandle<DHTAbstractTask>& task);
 public:
   DHTTaskFactoryImpl();
 
   virtual ~DHTTaskFactoryImpl();
 
-  virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode,
-				       size_t numRetry = 0);
+  virtual SharedHandle<DHTTask>
+  createPingTask(const SharedHandle<DHTNode>& remoteNode,
+		 size_t numRetry = 0);
 
-  virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID);
+  virtual SharedHandle<DHTTask>
+  createNodeLookupTask(const unsigned char* targetID);
 
-  virtual DHTTaskHandle createBucketRefreshTask();
+  virtual SharedHandle<DHTTask> createBucketRefreshTask();
 
-  virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx);
+  virtual SharedHandle<DHTTask>
+  createPeerLookupTask(const SharedHandle<BtContext>& ctx);
 
-  virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash);
+  virtual SharedHandle<DHTTask>
+  createPeerAnnounceTask(const unsigned char* infoHash);
 
-  virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket,
-					      const DHTNodeHandle& newNode);
+  virtual SharedHandle<DHTTask>
+  createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+			const SharedHandle<DHTNode>& newNode);
 
   void setRoutingTable(const WeakHandle<DHTRoutingTable> routingTable);
 
@@ -87,8 +94,10 @@ public:
 
   void setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue);
 
-  void setLocalNode(const DHTNodeHandle& localNode);
+  void setLocalNode(const SharedHandle<DHTNode>& localNode);
 
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TASK_FACTORY_IMPL_H_
diff --git a/src/DHTTaskQueue.h b/src/DHTTaskQueue.h
index 46427ba4..fd03d782 100644
--- a/src/DHTTaskQueue.h
+++ b/src/DHTTaskQueue.h
@@ -36,8 +36,11 @@
 #define _D_DHT_TASK_QUEUE_H_
 
 #include "common.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTTask;
 
 class DHTTaskQueue {
 public:
@@ -45,11 +48,13 @@ public:
 
   virtual void executeTask() = 0;
 
-  virtual void addPeriodicTask1(const DHTTaskHandle& task) = 0;
+  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task) = 0;
 
-  virtual void addPeriodicTask2(const DHTTaskHandle& task) = 0;
+  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task) = 0;
 
-  virtual void addImmediateTask(const DHTTaskHandle& task) = 0;
+  virtual void addImmediateTask(const SharedHandle<DHTTask>& task) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TASK_QUEUE_H_
diff --git a/src/DHTTaskQueueImpl.cc b/src/DHTTaskQueueImpl.cc
index 85a4e13e..fe01cdf8 100644
--- a/src/DHTTaskQueueImpl.cc
+++ b/src/DHTTaskQueueImpl.cc
@@ -35,13 +35,16 @@
 #include "DHTTaskQueueImpl.h"
 #include "DHTTask.h"
 
+namespace aria2 {
+
 DHTTaskQueueImpl::DHTTaskQueueImpl():_periodicTask1(0),
 				     _periodicTask2(0),
 				     _immediateTask(0) {}
 
 DHTTaskQueueImpl::~DHTTaskQueueImpl() {}
 
-void DHTTaskQueueImpl::executeTask(DHTTaskHandle& task, DHTTasks& taskQueue)
+void DHTTaskQueueImpl::executeTask(SharedHandle<DHTTask>& task,
+				   std::deque<SharedHandle<DHTTask> >& taskQueue)
 {
   while(1) {
     if(task.isNull() || task->finished()) {
@@ -65,17 +68,19 @@ void DHTTaskQueueImpl::executeTask()
   executeTask(_immediateTask, _immediateTaskQueue);
 }
 
-void DHTTaskQueueImpl::addPeriodicTask1(const DHTTaskHandle& task)
+void DHTTaskQueueImpl::addPeriodicTask1(const SharedHandle<DHTTask>& task)
 {
   _periodicTaskQueue1.push_back(task);
 }
 
-void DHTTaskQueueImpl::addPeriodicTask2(const DHTTaskHandle& task)
+void DHTTaskQueueImpl::addPeriodicTask2(const SharedHandle<DHTTask>& task)
 {
   _periodicTaskQueue2.push_back(task);
 }
 
-void DHTTaskQueueImpl::addImmediateTask(const DHTTaskHandle& task)
+void DHTTaskQueueImpl::addImmediateTask(const SharedHandle<DHTTask>& task)
 {
   _immediateTaskQueue.push_back(task);
 }
+
+} // namespace aria2
diff --git a/src/DHTTaskQueueImpl.h b/src/DHTTaskQueueImpl.h
index 951aa2ba..b573dba6 100644
--- a/src/DHTTaskQueueImpl.h
+++ b/src/DHTTaskQueueImpl.h
@@ -36,23 +36,26 @@
 #define _D_DHT_TASK_QUEUE_IMPL_H_
 
 #include "DHTTaskQueue.h"
+#include <deque>
+
+namespace aria2 {
 
 class DHTTaskQueueImpl:public DHTTaskQueue {
 private:
 
-  DHTTaskHandle _periodicTask1;
+  SharedHandle<DHTTask> _periodicTask1;
 
-  DHTTaskHandle _periodicTask2;
+  SharedHandle<DHTTask> _periodicTask2;
 
-  DHTTaskHandle _immediateTask;
+  SharedHandle<DHTTask> _immediateTask;
 
-  DHTTasks _periodicTaskQueue1;
+  std::deque<SharedHandle<DHTTask> > _periodicTaskQueue1;
 
-  DHTTasks _periodicTaskQueue2;
+  std::deque<SharedHandle<DHTTask> > _periodicTaskQueue2;
 
-  DHTTasks _immediateTaskQueue;
+  std::deque<SharedHandle<DHTTask> > _immediateTaskQueue;
 
-  void executeTask(DHTTaskHandle& task, DHTTasks& taskQueue);
+  void executeTask(SharedHandle<DHTTask>& task, std::deque<SharedHandle<DHTTask> >& taskQueue);
 public:
   DHTTaskQueueImpl();
 
@@ -60,11 +63,13 @@ public:
 
   virtual void executeTask();
 
-  virtual void addPeriodicTask1(const DHTTaskHandle& task);
+  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task);
 
-  virtual void addPeriodicTask2(const DHTTaskHandle& task);
+  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task);
 
-  virtual void addImmediateTask(const DHTTaskHandle& task);
+  virtual void addImmediateTask(const SharedHandle<DHTTask>& task);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TASK_QUEUE_IMPL_H_
diff --git a/src/DHTTokenTracker.cc b/src/DHTTokenTracker.cc
index aaede48a..60bec983 100644
--- a/src/DHTTokenTracker.cc
+++ b/src/DHTTokenTracker.cc
@@ -38,6 +38,9 @@
 #include "DlAbortEx.h"
 #include "DHTConstants.h"
 #include "MessageDigestHelper.h"
+#include <cstring>
+
+namespace aria2 {
 
 DHTTokenTracker::DHTTokenTracker()
 {
@@ -53,9 +56,9 @@ DHTTokenTracker::DHTTokenTracker(const char* initialSecret)
 
 DHTTokenTracker::~DHTTokenTracker() {}
 
-string DHTTokenTracker::generateToken(const unsigned char* infoHash,
-				      const string& ipaddr, uint16_t port,
-				      const char* secret) const
+std::string DHTTokenTracker::generateToken(const unsigned char* infoHash,
+					   const std::string& ipaddr, uint16_t port,
+					   const char* secret) const
 {
   char src[DHT_ID_LENGTH+6+SECRET_SIZE];
   if(!PeerMessageUtil::createcompact(src+DHT_ID_LENGTH, ipaddr, port)) {
@@ -67,15 +70,15 @@ string DHTTokenTracker::generateToken(const unsigned char* infoHash,
   return MessageDigestHelper::digest("sha1", src, sizeof(src));
 }
 
-string DHTTokenTracker::generateToken(const unsigned char* infoHash,
-				      const string& ipaddr, uint16_t port) const
+std::string DHTTokenTracker::generateToken(const unsigned char* infoHash,
+					   const std::string& ipaddr, uint16_t port) const
 {
   return generateToken(infoHash, ipaddr, port, _secret[0]);
 }
 
-bool DHTTokenTracker::validateToken(const string& token,
+bool DHTTokenTracker::validateToken(const std::string& token,
 				    const unsigned char* infoHash,
-				    const string& ipaddr, uint16_t port) const
+				    const std::string& ipaddr, uint16_t port) const
 {
   for(int i = 0; i < 2; ++i) {
     if(generateToken(infoHash, ipaddr, port, _secret[i]) == token) {
@@ -90,3 +93,5 @@ void DHTTokenTracker::updateTokenSecret()
   memcpy(_secret[1], _secret[0], SECRET_SIZE);
   DHTUtil::generateRandomData(_secret[0], SECRET_SIZE);
 }
+
+} // namespace aria2
diff --git a/src/DHTTokenTracker.h b/src/DHTTokenTracker.h
index 2c510a91..9fb2f788 100644
--- a/src/DHTTokenTracker.h
+++ b/src/DHTTokenTracker.h
@@ -36,7 +36,9 @@
 #define _D_DHT_TOKEN_TRACKER_H_
 
 #include "common.h"
-#include "DHTTokenTrackerDecl.h"
+#include <string>
+
+namespace aria2 {
 
 class DHTTokenTracker {
 private:
@@ -44,9 +46,9 @@ private:
 
   char _secret[2][SECRET_SIZE];
 
-  string generateToken(const unsigned char* infoHash,
-		       const string& ipaddr, uint16_t port,
-		       const char* secret) const;
+  std::string generateToken(const unsigned char* infoHash,
+			    const std::string& ipaddr, uint16_t port,
+			    const char* secret) const;
 public:
   DHTTokenTracker();
 
@@ -55,14 +57,16 @@ public:
   ~DHTTokenTracker();
 
   // TODO handle exception thrown by this function.
-  string generateToken(const unsigned char* infoHash,
-		       const string& ipaddr, uint16_t port) const;
+  std::string generateToken(const unsigned char* infoHash,
+			    const std::string& ipaddr, uint16_t port) const;
 
-  bool validateToken(const string& token,
+  bool validateToken(const std::string& token,
 		     const unsigned char* infoHash,
-		     const string& ipaddr, uint16_t port) const;
+		     const std::string& ipaddr, uint16_t port) const;
 
   void updateTokenSecret();
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TOKEN_TRACKER_H_
diff --git a/src/DHTTokenTrackerDecl.h b/src/DHTTokenTrackerDecl.h
deleted file mode 100644
index a95672e3..00000000
--- a/src/DHTTokenTrackerDecl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_DHT_TOKEN_TRACKER_DECL_H_
-#define _D_DHT_TOKEN_TRACKER_DECL_H_
-
-#include "SharedHandle.h"
-
-class DHTTokenTracker;
-typedef SharedHandle<DHTTokenTracker> DHTTokenTrackerHandle;
-
-#endif // _D_DHT_TOKEN_TRACKER_DECL_H_
diff --git a/src/DHTTokenUpdateCommand.cc b/src/DHTTokenUpdateCommand.cc
index 63020169..a76c73cd 100644
--- a/src/DHTTokenUpdateCommand.cc
+++ b/src/DHTTokenUpdateCommand.cc
@@ -34,11 +34,13 @@
 /* copyright --> */
 #include "DHTTokenUpdateCommand.h"
 #include "DHTTokenTracker.h"
-#include "SingletonHolder.h"
 #include "DownloadEngine.h"
 #include "RequestGroupMan.h"
 #include "RecoverableException.h"
 #include "message.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 DHTTokenUpdateCommand::DHTTokenUpdateCommand(int32_t cuid,
 					     DownloadEngine* e,
@@ -64,7 +66,9 @@ void DHTTokenUpdateCommand::process()
   }
 }
 
-void DHTTokenUpdateCommand::setTokenTracker(const DHTTokenTrackerHandle& tokenTracker)
+void DHTTokenUpdateCommand::setTokenTracker(const SharedHandle<DHTTokenTracker>& tokenTracker)
 {
   _tokenTracker = tokenTracker;
 }
+
+} // namespace aria2
diff --git a/src/DHTTokenUpdateCommand.h b/src/DHTTokenUpdateCommand.h
index 1030e843..3dfa9220 100644
--- a/src/DHTTokenUpdateCommand.h
+++ b/src/DHTTokenUpdateCommand.h
@@ -36,11 +36,15 @@
 #define _D_DHT_TOKEN_UPDATE_COMMAND_H_
 
 #include "TimeBasedCommand.h"
-#include "DHTTokenTrackerDecl.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DHTTokenTracker;
 
 class DHTTokenUpdateCommand:public TimeBasedCommand {
 private:
-  DHTTokenTrackerHandle _tokenTracker;
+  SharedHandle<DHTTokenTracker> _tokenTracker;
 public:
   DHTTokenUpdateCommand(int32_t cuid, DownloadEngine* e, time_t interval);
 
@@ -50,7 +54,9 @@ public:
 
   virtual void process();
 
-  void setTokenTracker(const DHTTokenTrackerHandle& tokenTracker);
+  void setTokenTracker(const SharedHandle<DHTTokenTracker>& tokenTracker);
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_TOKEN_UPDATE_COMMAND_H_
diff --git a/src/DHTUnknownMessage.cc b/src/DHTUnknownMessage.cc
index bccc8ed9..a9836896 100644
--- a/src/DHTUnknownMessage.cc
+++ b/src/DHTUnknownMessage.cc
@@ -37,9 +37,11 @@
 #include "Util.h"
 #include <cstring>
 
-DHTUnknownMessage::DHTUnknownMessage(const DHTNodeHandle& localNode,
+namespace aria2 {
+
+DHTUnknownMessage::DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
 				     const char* data, size_t length,
-				     const string& ipaddr, uint16_t port):
+				     const std::string& ipaddr, uint16_t port):
   DHTMessage(localNode, 0),
   _length(length),
   _ipaddr(ipaddr),
@@ -69,19 +71,21 @@ bool DHTUnknownMessage::isReply() const
 
 void DHTUnknownMessage::validate() const {}
   
-string DHTUnknownMessage::getMessageType() const
+std::string DHTUnknownMessage::getMessageType() const
 {
   return "unknown";
 }
 
-string DHTUnknownMessage::toString() const
+std::string DHTUnknownMessage::toString() const
 {
   size_t sampleLength = 8;
   if(_length < sampleLength) {
     sampleLength = _length;
   }
-  string sample = string(&_data[0], &_data[sampleLength]);
+  std::string sample(&_data[0], &_data[sampleLength]);
 
   return "dht unknown Remote:"+_ipaddr+":"+Util::uitos(_port)+" length="+
     Util::uitos(_length)+", first 8 bytes(hex)="+Util::toHex(sample);
 }
+
+} // namespace aria2
diff --git a/src/DHTUnknownMessage.h b/src/DHTUnknownMessage.h
index 7034a417..5f6c966d 100644
--- a/src/DHTUnknownMessage.h
+++ b/src/DHTUnknownMessage.h
@@ -37,17 +37,19 @@
 
 #include "DHTMessage.h"
 
+namespace aria2 {
+
 class DHTUnknownMessage:public DHTMessage {
 private:
   char* _data;
   size_t _length;
-  string _ipaddr;
+  std::string _ipaddr;
   uint16_t _port;
 public:
   // _remoteNode is always null
-  DHTUnknownMessage(const DHTNodeHandle& localNode,
+  DHTUnknownMessage(const SharedHandle<DHTNode>& localNode,
 		    const char* data, size_t length,
-		    const string& ipaddr, uint16_t port);
+		    const std::string& ipaddr, uint16_t port);
 
   virtual ~DHTUnknownMessage();
 
@@ -63,10 +65,12 @@ public:
   virtual void validate() const;
   
   // returns "unknown"
-  virtual string getMessageType() const;
+  virtual std::string getMessageType() const;
 
   // show some sample bytes
-  virtual string toString() const;
+  virtual std::string toString() const;
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_UNKNOWN_MESSAGE_H_
diff --git a/src/DHTUtil.cc b/src/DHTUtil.cc
index 7c32853e..c4edd3b7 100644
--- a/src/DHTUtil.cc
+++ b/src/DHTUtil.cc
@@ -34,9 +34,12 @@
 /* copyright --> */
 #include "DHTUtil.h"
 #include "MessageDigestHelper.h"
+#include <cassert>
 #include <fstream>
 #include <iomanip>
 
+namespace aria2 {
+
 void DHTUtil::generateRandomKey(unsigned char* key)
 {
   char bytes[40];
@@ -46,7 +49,7 @@ void DHTUtil::generateRandomKey(unsigned char* key)
 
 void DHTUtil::generateRandomData(char* data, size_t length)
 {
-  ifstream i("/dev/urandom");
+  std::ifstream i("/dev/urandom");
   i.read(data, length);
 }
 
@@ -57,3 +60,5 @@ void DHTUtil::flipBit(unsigned char* data, size_t length, size_t bitIndex)
   unsigned char mask = 128 >> (bitIndex%8);
   data[byteIndex] ^= mask;
 }
+
+} // namespace aria2
diff --git a/src/DHTUtil.h b/src/DHTUtil.h
index 9cd59e3b..098192c8 100644
--- a/src/DHTUtil.h
+++ b/src/DHTUtil.h
@@ -36,6 +36,9 @@
 #define _D_DHT_UTIL_H_
 
 #include "common.h"
+#include <cstdlib>
+
+namespace aria2 {
 
 class DHTUtil {
 public:
@@ -53,4 +56,6 @@ public:
 
 };
 
+} // namespace aria2
+
 #endif // _D_DHT_UTIL_H_
diff --git a/src/DNSCache.h b/src/DNSCache.h
index 861fda91..7c116192 100644
--- a/src/DNSCache.h
+++ b/src/DNSCache.h
@@ -36,15 +36,20 @@
 #define _D_DNS_CACHE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include "SingletonHolder.h"
+#include <string>
 #include <map>
 
+namespace aria2 {
+
 class DNSCache {
 public:
   virtual ~DNSCache() {}
 
-  virtual string find(const string& hostname) = 0;
+  virtual std::string find(const std::string& hostname) = 0;
 
-  virtual void put(const string& hostname, const string& ipaddr) = 0;
+  virtual void put(const std::string& hostname, const std::string& ipaddr) = 0;
 };
 
 typedef SharedHandle<DNSCache> DNSCacheHandle;
@@ -52,18 +57,18 @@ typedef SingletonHolder<DNSCacheHandle> DNSCacheSingletonHolder;
 
 class SimpleDNSCache : public DNSCache {
 private:
-  map<string, string> _table;
+  std::map<std::string, std::string> _table;
 public:
   SimpleDNSCache() {}
 
   virtual ~SimpleDNSCache() {}
 
-  virtual string find(const string& hostname)
+  virtual std::string find(const std::string& hostname)
   {
     return _table[hostname];
   }
 
-  virtual void put(const string& hostname, const string& ipaddr)
+  virtual void put(const std::string& hostname, const std::string& ipaddr)
   {
     _table[hostname] = ipaddr;
   }
@@ -74,9 +79,11 @@ class NullDNSCache : public DNSCache {
 public:
   virtual ~NullDNSCache() {}
 
-  virtual string find(const string& hostname) { return ""; }
+  virtual std::string find(const std::string& hostname) { return ""; }
 
-  virtual void put(const string& hostname, const string& ipaddr) {}
+  virtual void put(const std::string& hostname, const std::string& ipaddr) {}
 };
 
+} // namespace aria2
+
 #endif // _D_DNS_CACHE_H_
diff --git a/src/Data.cc b/src/Data.cc
index 5767a580..61cae140 100644
--- a/src/Data.cc
+++ b/src/Data.cc
@@ -34,6 +34,9 @@
 /* copyright --> */
 #include "Data.h"
 #include "MetaEntryVisitor.h"
+#include <cstring>
+
+namespace aria2 {
 
 Data::Data(const char* data, int32_t len, bool number):number(number) {
   init(data, len);
@@ -43,7 +46,7 @@ Data::Data(const unsigned char* data, int32_t len, bool number):number(number) {
   init(reinterpret_cast<const char*>(data), len);
 }
 
-Data::Data(const string& data, bool number):number(number)
+Data::Data(const std::string& data, bool number):number(number)
 {
   init(data.c_str(), data.size());
 }
@@ -64,8 +67,8 @@ Data::~Data() {
   delete [] data;
 }
 
-string Data::toString() const {
-  return string(&data[0], &data[len]);
+std::string Data::toString() const {
+  return std::string(&data[0], &data[len]);
 }
 
 const char* Data::getData() const {
@@ -99,3 +102,5 @@ bool Data::isNumber() const {
 void Data::accept(MetaEntryVisitor* v) const {
   v->visit(this);
 }
+
+} // namespace aria2
diff --git a/src/Data.h b/src/Data.h
index 4d394c12..977c9815 100644
--- a/src/Data.h
+++ b/src/Data.h
@@ -38,7 +38,7 @@
 #include "MetaEntry.h"
 #include <string>
 
-using namespace std;
+namespace aria2 {
 
 class Data : public MetaEntry {
 private:
@@ -56,11 +56,11 @@ public:
 
   Data(const unsigned char* data, int32_t len, bool number = false);
 
-  Data(const string& data, bool number = false);
+  Data(const std::string& data, bool number = false);
 
   ~Data();
 
-  string toString() const;
+  std::string toString() const;
   int32_t toInt() const;
   int64_t toLLInt() const;
   
@@ -71,4 +71,6 @@ public:
   void accept(MetaEntryVisitor* v) const;
 };
 
+} // namespace aria2
+
 #endif // _D_DATA_H_
diff --git a/src/DefaultAuthResolver.cc b/src/DefaultAuthResolver.cc
index 622f4909..82d808aa 100644
--- a/src/DefaultAuthResolver.cc
+++ b/src/DefaultAuthResolver.cc
@@ -33,8 +33,13 @@
  */
 /* copyright --> */
 #include "DefaultAuthResolver.h"
+#include "AuthConfig.h"
 
-AuthConfigHandle DefaultAuthResolver::resolveAuthConfig(const string& hostname)
+namespace aria2 {
+
+DefaultAuthResolver::~DefaultAuthResolver() {}
+
+AuthConfigHandle DefaultAuthResolver::resolveAuthConfig(const std::string& hostname)
 {
   if(_userDefinedAuthConfig.isNull()) {
     return _defaultAuthConfig;
@@ -42,3 +47,5 @@ AuthConfigHandle DefaultAuthResolver::resolveAuthConfig(const string& hostname)
     return _userDefinedAuthConfig;
   }
 }
+
+} // namespace aria2
diff --git a/src/DefaultAuthResolver.h b/src/DefaultAuthResolver.h
index 63415bae..e11e68db 100644
--- a/src/DefaultAuthResolver.h
+++ b/src/DefaultAuthResolver.h
@@ -37,13 +37,17 @@
 
 #include "AbstractAuthResolver.h"
 
+namespace aria2 {
+
 class DefaultAuthResolver : public AbstractAuthResolver {
 public:
-  virtual ~DefaultAuthResolver() {}
+  virtual ~DefaultAuthResolver();
 
-  virtual AuthConfigHandle resolveAuthConfig(const string& hostname);
+  virtual SharedHandle<AuthConfig> resolveAuthConfig(const std::string& hostname);
 };
 
 typedef SharedHandle<DefaultAuthResolver> DefaultAuthResolverHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_AUTH_RESOLVER_H_
diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc
index 3d76404d..809a65f2 100644
--- a/src/DefaultBtAnnounce.cc
+++ b/src/DefaultBtAnnounce.cc
@@ -35,6 +35,7 @@
 #include "DefaultBtAnnounce.h"
 #include "BtRegistry.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "MetaFileUtil.h"
 #include "Dictionary.h"
 #include "List.h"
@@ -45,8 +46,15 @@
 #include "DlAbortEx.h"
 #include "message.h"
 #include "SimpleRandomizer.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "BtRuntime.h"
+#include "PeerStorage.h"
+#include "Peer.h"
 
-DefaultBtAnnounce::DefaultBtAnnounce(BtContextHandle btContext,
+namespace aria2 {
+
+DefaultBtAnnounce::DefaultBtAnnounce(const BtContextHandle& btContext,
 				     const Option* option):
   btContext(btContext),
   trackers(0),
@@ -98,7 +106,7 @@ bool DefaultBtAnnounce::isAnnounceReady() {
     isDefaultAnnounceReady();
 }
 
-string DefaultBtAnnounce::getAnnounceUrl() {
+std::string DefaultBtAnnounce::getAnnounceUrl() {
   if(isStoppedAnnounceReady()) {
     if(!announceList.currentTierAcceptsStoppedEvent()) {
       announceList.moveToStoppedAllowedTier();
@@ -130,7 +138,7 @@ string DefaultBtAnnounce::getAnnounceUrl() {
   if(left < 0) {
     left = 0;
   }
-  string url = announceList.getAnnounce()+"?"+
+  std::string url = announceList.getAnnounce()+"?"+
     "info_hash="+Util::torrentUrlencode(btContext->getInfoHash(),
 					btContext->getInfoHashLength())+"&"+
     "peer_id="+Util::torrentUrlencode(btContext->getPeerId(), 20)+"&"+
@@ -142,14 +150,14 @@ string DefaultBtAnnounce::getAnnounceUrl() {
     "numwant="+Util::itos(numWant)+"&"+
     "no_peer_id=1";
   if(btRuntime->getListenPort() > 0) {
-    url += string("&")+"port="+Util::itos(btRuntime->getListenPort());
+    url += std::string("&")+"port="+Util::itos(btRuntime->getListenPort());
   }
-  string event = announceList.getEventString();
+  std::string event = announceList.getEventString();
   if(!event.empty()) {
-    url += string("&")+"event="+event;
+    url += std::string("&")+"event="+event;
   }
   if(!trackerId.empty()) {
-    url += string("&")+"trackerid="+Util::torrentUrlencode((const unsigned char*)trackerId.c_str(),
+    url += std::string("&")+"trackerid="+Util::torrentUrlencode((const unsigned char*)trackerId.c_str(),
 							   trackerId.size());
   }
   return url;
@@ -260,3 +268,35 @@ void DefaultBtAnnounce::setRandomizer(const RandomizerHandle& randomizer)
 {
   _randomizer = randomizer;
 }
+
+void DefaultBtAnnounce::setBtRuntime(const BtRuntimeHandle& btRuntime)
+{
+  this->btRuntime = btRuntime;
+}
+
+BtRuntimeHandle DefaultBtAnnounce::getBtRuntime() const
+{
+  return btRuntime;
+}
+
+void DefaultBtAnnounce::setPieceStorage(const PieceStorageHandle& pieceStorage)
+{
+  this->pieceStorage = pieceStorage;
+}
+
+PieceStorageHandle DefaultBtAnnounce::getPieceStorage() const
+{
+  return pieceStorage;
+}
+
+void DefaultBtAnnounce::setPeerStorage(const PeerStorageHandle& peerStorage)
+{
+  this->peerStorage = peerStorage;
+}
+
+PeerStorageHandle DefaultBtAnnounce::getPeerStorage() const
+{
+  return peerStorage;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtAnnounce.h b/src/DefaultBtAnnounce.h
index 12e819de..77144a10 100644
--- a/src/DefaultBtAnnounce.h
+++ b/src/DefaultBtAnnounce.h
@@ -36,23 +36,24 @@
 #define _D_DEFAULT_BT_ANNOUNCE_H_
 
 #include "BtAnnounce.h"
-#include "BtContext.h"
 #include "TimeA2.h"
 #include "AnnounceList.h"
-#include "Option.h"
-#include "Logger.h"
-#include "BtRuntime.h"
-#include "PieceStorage.h"
-#include "PeerStorage.h"
 
-class Randomizer;
-typedef SharedHandle<Randomizer> RandomizerHandle;
+namespace aria2 {
 
 #define DEFAULT_ANNOUNCE_INTERVAL 1800
 
+class BtContext;
+class Option;
+class Logger;
+class BtRuntime;
+class PieceStorage;
+class PeerStorage;
+class Randomizer;
+
 class DefaultBtAnnounce : public BtAnnounce {
 private:
-  BtContextHandle btContext;
+  SharedHandle<BtContext> btContext;
   int32_t trackers;
   Time prevAnnounceTime;
   int32_t interval;
@@ -60,32 +61,31 @@ private:
   int32_t complete;
   int32_t incomplete;
   AnnounceList announceList;
-  string trackerId;
-  string key;
+  std::string trackerId;
+  std::string key;
   const Option* option;
   Logger* logger;
-  RandomizerHandle _randomizer;
-  BtRuntimeHandle btRuntime;
-  PieceStorageHandle pieceStorage;
-  PeerStorageHandle peerStorage;
+  SharedHandle<Randomizer> _randomizer;
+  SharedHandle<BtRuntime> btRuntime;
+  SharedHandle<PieceStorage> pieceStorage;
+  SharedHandle<PeerStorage> peerStorage;
 public:
-  DefaultBtAnnounce(BtContextHandle btContext, const Option* option);
+  DefaultBtAnnounce(const SharedHandle<BtContext>& btContext,
+		    const Option* option);
+
   virtual ~DefaultBtAnnounce();
 
-  void setBtRuntime(const BtRuntimeHandle& btRuntime) {
-    this->btRuntime = btRuntime;
-  }
-  BtRuntimeHandle getBtRuntime() const { return btRuntime; }
+  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime);
 
-  void setPieceStorage(const PieceStorageHandle& pieceStorage) {
-    this->pieceStorage = pieceStorage;
-  }
-  PieceStorageHandle getPieceStorage() const { return pieceStorage; }
+  SharedHandle<BtRuntime> getBtRuntime() const;
 
-  void setPeerStorage(const PeerStorageHandle& peerStorage) {
-    this->peerStorage = peerStorage;
-  }
-  PeerStorageHandle getPeerStorage() const { return peerStorage; }
+  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
+
+  SharedHandle<PieceStorage> getPieceStorage() const;
+
+  void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage);
+
+  SharedHandle<PeerStorage> getPeerStorage() const;
 
   bool isDefaultAnnounceReady();
 
@@ -95,7 +95,7 @@ public:
 
   virtual bool isAnnounceReady();
 
-  virtual string getAnnounceUrl();
+  virtual std::string getAnnounceUrl();
 
   virtual void announceStart();
 
@@ -116,7 +116,7 @@ public:
 
   void generateKey();
 
-  void setRandomizer(const RandomizerHandle& randomizer);
+  void setRandomizer(const SharedHandle<Randomizer>& randomizer);
 
   int32_t getInterval() const
   {
@@ -138,10 +138,12 @@ public:
     return incomplete;
   }
 
-  const string& getTrackerID() const
+  const std::string& getTrackerID() const
   {
     return trackerId;
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_ANNOUNCE_H_
diff --git a/src/DefaultBtContext.cc b/src/DefaultBtContext.cc
index 1bc0dd72..891006e5 100644
--- a/src/DefaultBtContext.cc
+++ b/src/DefaultBtContext.cc
@@ -45,8 +45,16 @@
 #include "AnnounceTier.h"
 #include "SimpleRandomizer.h"
 #include "LogFactory.h"
+#include "Logger.h"
+#include "FileEntry.h"
 #include "message.h"
-#include <libgen.h>
+#include <cassert>
+#include <cstring>
+#include <ostream>
+#include <functional>
+#include <algorithm>
+
+namespace aria2 {
 
 DefaultBtContext::DefaultBtContext():_peerIdPrefix("-aria2-"),
 				     _randomizer(SimpleRandomizer::getInstance()),
@@ -55,8 +63,8 @@ DefaultBtContext::DefaultBtContext():_peerIdPrefix("-aria2-"),
 
 DefaultBtContext::~DefaultBtContext() {}
 
-string DefaultBtContext::generatePeerId() const {
-  string peerId = _peerIdPrefix;
+std::string DefaultBtContext::generatePeerId() const {
+  std::string peerId = _peerIdPrefix;
   peerId += Util::randomAlpha(20-_peerIdPrefix.size(), _randomizer);
   if(peerId.size() > 20) {
     peerId.erase(20);
@@ -72,7 +80,7 @@ int32_t DefaultBtContext::getInfoHashLength() const {
   return INFO_HASH_LENGTH;
 }
 
-string DefaultBtContext::getInfoHashAsString() const {
+std::string DefaultBtContext::getInfoHashAsString() const {
   return infoHashString;
 }
 
@@ -105,15 +113,13 @@ void DefaultBtContext::extractPieceHash(const unsigned char* hashData,
 }
 
 void DefaultBtContext::extractFileEntries(const Dictionary* infoDic,
-					  const string& defaultName,
-					  const Strings& urlList) {
+					  const std::string& defaultName,
+					  const std::deque<std::string>& urlList) {
   const Data* nameData = dynamic_cast<const Data*>(infoDic->get("name"));
   if(nameData) {
     name = nameData->toString();
   } else {
-    char* basec = strdup(defaultName.c_str());
-    name = string(basename(basec))+".file";
-    free(basec);
+    name = File(defaultName).getBasename()+".file";
   }
   const List* files = dynamic_cast<const List*>(infoDic->get("files"));
   if(files) {
@@ -121,8 +127,8 @@ void DefaultBtContext::extractFileEntries(const Dictionary* infoDic,
     int64_t offset = 0;
     // multi-file mode
     fileMode = BtContext::MULTI;
-    const MetaList& metaList = files->getList();
-    for(MetaList::const_iterator itr = metaList.begin();
+    const std::deque<MetaEntry*>& metaList = files->getList();
+    for(std::deque<MetaEntry*>::const_iterator itr = metaList.begin();
 	itr != metaList.end(); itr++) {
       const Dictionary* fileDic = dynamic_cast<const Dictionary*>((*itr));
       if(!fileDic) {
@@ -138,8 +144,8 @@ void DefaultBtContext::extractFileEntries(const Dictionary* infoDic,
       if(!pathList) {
 	throw new DlAbortEx(MSG_SOMETHING_MISSING_IN_TORRENT, "file path list");
       }
-      const MetaList& paths = pathList->getList();
-      string path;
+      const std::deque<MetaEntry*>& paths = pathList->getList();
+      std::string path;
       for(int32_t i = 0; i < (int32_t)paths.size()-1; i++) {
 	const Data* subpath = dynamic_cast<const Data*>(paths[i]);
 	if(subpath) {
@@ -155,9 +161,9 @@ void DefaultBtContext::extractFileEntries(const Dictionary* infoDic,
 	throw new DlAbortEx(MSG_SOMETHING_MISSING_IN_TORRENT, "file path element");
       }
 
-      Strings uris;
-      transform(urlList.begin(), urlList.end(), back_inserter(uris),
-		bind2nd(plus<string>(), "/"+name+"/"+path));
+      std::deque<std::string> uris;
+      std::transform(urlList.begin(), urlList.end(), back_inserter(uris),
+		     std::bind2nd(std::plus<std::string>(), "/"+name+"/"+path));
       FileEntryHandle fileEntry(new FileEntry(path,
 					      lengthData->toLLInt(),
 					      offset,
@@ -181,20 +187,20 @@ void DefaultBtContext::extractFileEntries(const Dictionary* infoDic,
 }
 
 void DefaultBtContext::extractAnnounce(const Data* announceData) {
-  Strings urls;
+  std::deque<std::string> urls;
   urls.push_back(Util::trim(announceData->toString()));
   announceTiers.push_back(AnnounceTierHandle(new AnnounceTier(urls)));
 }
 
 void DefaultBtContext::extractAnnounceList(const List* announceListData) {
-  for(MetaList::const_iterator itr = announceListData->getList().begin();
+  for(std::deque<MetaEntry*>::const_iterator itr = announceListData->getList().begin();
       itr != announceListData->getList().end(); itr++) {
     const List* elem = dynamic_cast<const List*>(*itr);
     if(!elem) {
       continue;
     }
-    Strings urls;
-    for(MetaList::const_iterator elemItr = elem->getList().begin();
+    std::deque<std::string> urls;
+    for(std::deque<MetaEntry*>::const_iterator elemItr = elem->getList().begin();
 	elemItr != elem->getList().end(); elemItr++) {
       const Data* data = dynamic_cast<const Data*>(*elemItr);
       if(data) {
@@ -208,12 +214,12 @@ void DefaultBtContext::extractAnnounceList(const List* announceListData) {
   }
 }
 
-Strings DefaultBtContext::extractUrlList(const MetaEntry* obj)
+std::deque<std::string> DefaultBtContext::extractUrlList(const MetaEntry* obj)
 {
-  Strings uris;
+  std::deque<std::string> uris;
   if(dynamic_cast<const List*>(obj)) {
     const List* urlList = reinterpret_cast<const List*>(obj);
-    for(MetaList::const_iterator itr = urlList->getList().begin();
+    for(std::deque<MetaEntry*>::const_iterator itr = urlList->getList().begin();
 	itr != urlList->getList().end(); ++itr) {
       const Data* data = dynamic_cast<const Data*>(*itr);
       if(data) {
@@ -227,7 +233,7 @@ Strings DefaultBtContext::extractUrlList(const MetaEntry* obj)
   return uris;
 }
 
-void DefaultBtContext::loadFromMemory(const char* content, int32_t length, const string& defaultName)
+void DefaultBtContext::loadFromMemory(const char* content, int32_t length, const std::string& defaultName)
 {
   SharedHandle<MetaEntry> rootEntry = MetaFileUtil::bdecoding(content, length);
   const Dictionary* rootDic = dynamic_cast<const Dictionary*>(rootEntry.get());
@@ -237,7 +243,7 @@ void DefaultBtContext::loadFromMemory(const char* content, int32_t length, const
   processRootDictionary(rootDic, defaultName);
 }
 
-void DefaultBtContext::load(const string& torrentFile) {
+void DefaultBtContext::load(const std::string& torrentFile) {
   SharedHandle<MetaEntry> rootEntry = MetaFileUtil::parseMetaFile(torrentFile);
   const Dictionary* rootDic = dynamic_cast<const Dictionary*>(rootEntry.get());
   if(!rootDic) {
@@ -246,7 +252,7 @@ void DefaultBtContext::load(const string& torrentFile) {
   processRootDictionary(rootDic, torrentFile);
 }
 
-void DefaultBtContext::processRootDictionary(const Dictionary* rootDic, const string& defaultName)
+void DefaultBtContext::processRootDictionary(const Dictionary* rootDic, const std::string& defaultName)
 {
   clear();
   const Dictionary* infoDic = dynamic_cast<const Dictionary*>(rootDic->get("info"));
@@ -285,7 +291,7 @@ void DefaultBtContext::processRootDictionary(const Dictionary* rootDic, const st
   // retrieve uri-list.
   // This implemantation obeys HTTP-Seeding specification:
   // see http://www.getright.com/seedtorrent.html
-  Strings urlList = extractUrlList(rootDic->get("url-list"));
+  std::deque<std::string> urlList = extractUrlList(rootDic->get("url-list"));
   // retrieve file entries
   extractFileEntries(infoDic, defaultName, urlList);
   if((totalLength+pieceLength-1)/pieceLength != numPieces) {
@@ -304,7 +310,7 @@ void DefaultBtContext::processRootDictionary(const Dictionary* rootDic, const st
   }
 }
 
-string DefaultBtContext::getPieceHash(int32_t index) const {
+std::string DefaultBtContext::getPieceHash(int32_t index) const {
   if(index < 0 || numPieces <= index) {
     return "";
   }
@@ -327,7 +333,7 @@ AnnounceTiers DefaultBtContext::getAnnounceTiers() const {
   return announceTiers;
 }
 
-string DefaultBtContext::getName() const {
+std::string DefaultBtContext::getName() const {
   return name;
 }
 
@@ -339,14 +345,14 @@ int32_t DefaultBtContext::getNumPieces() const {
   return numPieces;
 }
 
-string DefaultBtContext::getActualBasePath() const
+std::string DefaultBtContext::getActualBasePath() const
 {
   return _dir+"/"+name;
 }
 
-Integers DefaultBtContext::computeFastSet(const string& ipaddr, int32_t fastSetSize)
+std::deque<int32_t> DefaultBtContext::computeFastSet(const std::string& ipaddr, int32_t fastSetSize)
 {
-  Integers fastSet;
+  std::deque<int32_t> fastSet;
   struct in_addr saddr;
   if(inet_aton(ipaddr.c_str(), &saddr) == 0) {
     abort();
@@ -369,7 +375,7 @@ Integers DefaultBtContext::computeFastSet(const string& ipaddr, int32_t fastSetS
       memcpy(&ny, x+j, 4);
       uint32_t y = ntohl(ny);
       int32_t index = y%numPieces;
-      if(find(fastSet.begin(), fastSet.end(), index) == fastSet.end()) {
+      if(std::find(fastSet.begin(), fastSet.end(), index) == fastSet.end()) {
 	fastSet.push_back(index);
       }
     }
@@ -380,7 +386,7 @@ Integers DefaultBtContext::computeFastSet(const string& ipaddr, int32_t fastSetS
   return fastSet;
 }
 
-ostream& operator<<(ostream& o, const DefaultBtContext& ctx)
+std::ostream& operator<<(std::ostream& o, const DefaultBtContext& ctx)
 {
   o << "*** BitTorrent File Information ***" << "\n";
   o << "Mode: " << (ctx.getFileMode() == DownloadContext::SINGLE ? "Single File Torrent":"Multi File Torrent") << "\n";
@@ -388,7 +394,7 @@ ostream& operator<<(ostream& o, const DefaultBtContext& ctx)
   AnnounceTiers tiers = ctx.getAnnounceTiers();
   for(AnnounceTiers::const_iterator itr = tiers.begin(); itr != tiers.end(); ++itr) {
     const AnnounceTierHandle& tier = *itr;
-    for(Strings::const_iterator uriItr = tier->urls.begin(); uriItr != tier->urls.end(); ++uriItr) {
+    for(std::deque<std::string>::const_iterator uriItr = tier->urls.begin(); uriItr != tier->urls.end(); ++uriItr) {
       o << " " << *uriItr;
     }
     o << "\n";
@@ -408,3 +414,5 @@ void DefaultBtContext::setRandomizer(const RandomizerHandle& randomizer)
 {
   _randomizer = randomizer;
 }
+
+} // namespace aria2
diff --git a/src/DefaultBtContext.h b/src/DefaultBtContext.h
index 05a9256a..bcf7e37c 100644
--- a/src/DefaultBtContext.h
+++ b/src/DefaultBtContext.h
@@ -36,34 +36,35 @@
 #define _D_DEFAULT_BT_CONTEXT_H_
 
 #include "BtContext.h"
-#include "Dictionary.h"
-#include "Data.h"
-#include "List.h"
+#include <iosfwd>
+
+namespace aria2 {
 
 class Randomizer;
-typedef SharedHandle<Randomizer> RandomizerHandle;
 class Logger;
+class MetaEntry;
+class Dictionary;
+class List;
+class Data;
 
 #define INFO_HASH_LENGTH 20
 #define PIECE_HASH_LENGTH 20
 
-typedef Strings PieceHashes;
-
 class DefaultBtContext : public BtContext {
 private:
   unsigned char infoHash[INFO_HASH_LENGTH];
-  string infoHashString;
-  PieceHashes pieceHashes;
-  FileEntries fileEntries;
+  std::string infoHashString;
+  std::deque<std::string> pieceHashes;
+  std::deque<SharedHandle<FileEntry> > fileEntries;
   FILE_MODE fileMode;
   int64_t totalLength;
   int32_t pieceLength;
-  string name;
+  std::string name;
   int32_t numPieces;
-  string peerId;
-  string _peerIdPrefix;
-  AnnounceTiers announceTiers;
-  RandomizerHandle _randomizer;
+  std::string peerId;
+  std::string _peerIdPrefix;
+  std::deque<SharedHandle<AnnounceTier> > announceTiers;
+  SharedHandle<Randomizer> _randomizer;
 
   RequestGroup* _ownerRequestGroup;
 
@@ -74,14 +75,14 @@ private:
 			int32_t hashDataLength,
 			int32_t hashLength);
   void extractFileEntries(const Dictionary* infoDic,
-			  const string& defaultName,
-			  const Strings& urlList);
+			  const std::string& defaultName,
+			  const std::deque<std::string>& urlList);
   void extractAnnounce(const Data* announceData);
   void extractAnnounceList(const List* announceListData);
 
-  Strings extractUrlList(const MetaEntry* obj);
+  std::deque<std::string> extractUrlList(const MetaEntry* obj);
 
-  void processRootDictionary(const Dictionary* rootDic, const string& defaultName);
+  void processRootDictionary(const Dictionary* rootDic, const std::string& defaultName);
 
  public:
   DefaultBtContext();
@@ -91,11 +92,11 @@ private:
 
   virtual int32_t getInfoHashLength() const;
 
-  virtual string getInfoHashAsString() const;
+  virtual std::string getInfoHashAsString() const;
 
-  virtual string getPieceHash(int32_t index) const;
+  virtual std::string getPieceHash(int32_t index) const;
 
-  virtual const Strings& getPieceHashes() const
+  virtual const std::deque<std::string>& getPieceHashes() const
   {
     return pieceHashes;
   }
@@ -104,26 +105,26 @@ private:
 
   virtual FILE_MODE getFileMode() const;
 
-  virtual FileEntries getFileEntries() const;
+  virtual std::deque<SharedHandle<FileEntry> > getFileEntries() const;
 
-  virtual string getPieceHashAlgo() const
+  virtual std::string getPieceHashAlgo() const
   {
     return "sha1";
   }
 
-  virtual AnnounceTiers getAnnounceTiers() const;
+  virtual std::deque<SharedHandle<AnnounceTier> > getAnnounceTiers() const;
 
-  virtual void load(const string& torrentFile);
+  virtual void load(const std::string& torrentFile);
 
-  void loadFromMemory(const char* content, int32_t length, const string& defaultName);
+  void loadFromMemory(const char* content, int32_t length, const std::string& defaultName);
 
-  virtual string getName() const;
+  virtual std::string getName() const;
 
   virtual int32_t getPieceLength() const;
   
   virtual int32_t getNumPieces() const;
 
-  virtual string getActualBasePath() const;
+  virtual std::string getActualBasePath() const;
 
   virtual const unsigned char* getPeerId() {
     if(peerId == "") {
@@ -132,16 +133,16 @@ private:
     return (const unsigned char*)peerId.c_str();
   }
 
-  virtual Integers computeFastSet(const string& ipaddr, int32_t fastSetSize);
+  virtual std::deque<int32_t> computeFastSet(const std::string& ipaddr, int32_t fastSetSize);
 
   virtual RequestGroup* getOwnerRequestGroup()
   {
     return _ownerRequestGroup;
   }
 
-  string generatePeerId() const;
+  std::string generatePeerId() const;
 
-  void setPeerIdPrefix(const string& peerIdPrefix)
+  void setPeerIdPrefix(const std::string& peerIdPrefix)
   {
     _peerIdPrefix = peerIdPrefix;
   }
@@ -162,11 +163,13 @@ private:
     _ownerRequestGroup = owner;
   }
 
-  void setRandomizer(const RandomizerHandle& randomizer);
+  void setRandomizer(const SharedHandle<Randomizer>& randomizer);
 
-  friend ostream& operator<<(ostream& o, const DefaultBtContext& ctx);
+  friend std::ostream& operator<<(std::ostream& o, const DefaultBtContext& ctx);
 };
 
 typedef SharedHandle<DefaultBtContext> DefaultBtContextHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_CONTEXT_H_
diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc
index 66b68ce2..eb93ecfc 100644
--- a/src/DefaultBtInteractive.cc
+++ b/src/DefaultBtInteractive.cc
@@ -49,9 +49,40 @@
 #include "DefaultExtensionMessageFactory.h"
 #include "BtRegistry.h"
 #include "DHTNode.h"
+#include "PeerObject.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "PeerStorage.h"
+#include "BtRuntime.h"
+#include "BtMessageReceiver.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "PeerConnection.h"
+#include "BtRegistry.h"
+#include "Logger.h"
+#include "LogFactory.h"
+
+namespace aria2 {
+
+DefaultBtInteractive::DefaultBtInteractive(const SharedHandle<BtContext>& btContext, const SharedHandle<Peer>& peer):
+  BtContextAwareCommand(btContext),
+  peer(peer),
+  logger(LogFactory::getInstance()),
+  allowedFastSetSize(10),
+  keepAliveInterval(120),
+  maxDownloadSpeedLimit(0),
+  _utPexEnabled(false),
+  _dhtEnabled(false)
+{}
+
+DefaultBtInteractive::~DefaultBtInteractive() {}
+
 
 void DefaultBtInteractive::initiateHandshake() {
-  BtHandshakeMessageHandle message =
+  SharedHandle<BtHandshakeMessage> message =
     messageFactory->createHandshakeMessage(btContext->getInfoHash(),
 					   btContext->getPeerId());
   dispatcher->addMessageToQueue(message);
@@ -59,35 +90,35 @@ void DefaultBtInteractive::initiateHandshake() {
 }
 
 BtMessageHandle DefaultBtInteractive::receiveHandshake(bool quickReply) {
-    BtHandshakeMessageHandle message =
-      btMessageReceiver->receiveHandshake(quickReply);
-    if(message.isNull()) {
-      return 0;
-    }
-    peer->setPeerId(message->getPeerId());
+  SharedHandle<BtHandshakeMessage> message =
+    btMessageReceiver->receiveHandshake(quickReply);
+  if(message.isNull()) {
+    return 0;
+  }
+  peer->setPeerId(message->getPeerId());
     
-    if(message->isFastExtensionSupported()) {
-      peer->setFastExtensionEnabled(true);
-      logger->info(MSG_FAST_EXTENSION_ENABLED, cuid);
+  if(message->isFastExtensionSupported()) {
+    peer->setFastExtensionEnabled(true);
+    logger->info(MSG_FAST_EXTENSION_ENABLED, cuid);
+  }
+  if(message->isExtendedMessagingEnabled()) {
+    peer->setExtendedMessagingEnabled(true);
+    DefaultExtensionMessageFactoryHandle factory = 
+      new DefaultExtensionMessageFactory(btContext, peer);
+    if(!_utPexEnabled) {
+      factory->removeExtension("ut_pex");
     }
-    if(message->isExtendedMessagingEnabled()) {
-      peer->setExtendedMessagingEnabled(true);
-      DefaultExtensionMessageFactoryHandle factory = 
-	new DefaultExtensionMessageFactory(btContext, peer);
-      if(!_utPexEnabled) {
-	factory->removeExtension("ut_pex");
-      }
-      PEER_OBJECT(btContext, peer)->extensionMessageFactory = factory;
-      logger->info(MSG_EXTENDED_MESSAGING_ENABLED, cuid);
-    }
-    if(message->isDHTEnabled()) {
-      peer->setDHTEnabled(true);
-      logger->info(MSG_DHT_ENABLED_PEER, cuid);
-    }
-    logger->info(MSG_RECEIVE_PEER_MESSAGE, cuid,
-		 peer->ipaddr.c_str(), peer->port,
-		 message->toString().c_str());
-    return message;
+    PEER_OBJECT(btContext, peer)->extensionMessageFactory = factory;
+    logger->info(MSG_EXTENDED_MESSAGING_ENABLED, cuid);
+  }
+  if(message->isDHTEnabled()) {
+    peer->setDHTEnabled(true);
+    logger->info(MSG_DHT_ENABLED_PEER, cuid);
+  }
+  logger->info(MSG_RECEIVE_PEER_MESSAGE, cuid,
+	       peer->ipaddr.c_str(), peer->port,
+	       message->toString().c_str());
+  return message;
 }
 
 BtMessageHandle DefaultBtInteractive::receiveAndSendHandshake() {
@@ -145,9 +176,9 @@ void DefaultBtInteractive::addBitfieldMessageToQueue() {
 
 void DefaultBtInteractive::addAllowedFastMessageToQueue() {
   if(peer->isFastExtensionEnabled()) {
-    Integers fastSet = btContext->computeFastSet(peer->ipaddr,
+    std::deque<int32_t> fastSet = btContext->computeFastSet(peer->ipaddr,
 						 allowedFastSetSize);
-    for(Integers::const_iterator itr = fastSet.begin();
+    for(std::deque<int32_t>::const_iterator itr = fastSet.begin();
 	itr != fastSet.end(); itr++) {
       dispatcher->addMessageToQueue(messageFactory->createAllowedFastMessage(*itr));
     }
@@ -167,7 +198,7 @@ void DefaultBtInteractive::decideChoking() {
 }
 
 void DefaultBtInteractive::checkHave() {
-  Integers indexes =
+  std::deque<int32_t> indexes =
     pieceStorage->getAdvertisedPieceIndexes(cuid, haveCheckPoint);
   haveCheckPoint.reset();
   if(indexes.size() >= 20) {
@@ -177,7 +208,7 @@ void DefaultBtInteractive::checkHave() {
       dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
     }
   } else {
-    for(Integers::iterator itr = indexes.begin(); itr != indexes.end(); itr++) {
+    for(std::deque<int32_t>::iterator itr = indexes.begin(); itr != indexes.end(); itr++) {
       dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
     }
   }
@@ -404,3 +435,45 @@ void DefaultBtInteractive::setLocalNode(const WeakHandle<DHTNode>& node)
 {
   _localNode = node;
 }
+
+int32_t DefaultBtInteractive::countPendingMessage()
+{
+  return dispatcher->countMessageInQueue();
+}
+  
+bool DefaultBtInteractive::isSendingMessageInProgress()
+{
+  return dispatcher->isSendingInProgress();
+}
+
+void DefaultBtInteractive::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+void DefaultBtInteractive::setBtMessageReceiver(const BtMessageReceiverWeakHandle& receiver)
+{
+  this->btMessageReceiver = receiver;
+}
+
+void DefaultBtInteractive::setDispatcher(const BtMessageDispatcherWeakHandle& dispatcher)
+{
+  this->dispatcher = dispatcher;
+}
+
+void DefaultBtInteractive::setBtRequestFactory(const BtRequestFactoryWeakHandle& factory)
+{
+  this->btRequestFactory = factory;
+}
+
+void DefaultBtInteractive::setPeerConnection(const PeerConnectionWeakHandle& peerConnection)
+{
+  this->peerConnection  = peerConnection;
+}
+
+void DefaultBtInteractive::setBtMessageFactory(const BtMessageFactoryWeakHandle& factory)
+{
+  this->messageFactory = factory;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtInteractive.h b/src/DefaultBtInteractive.h
index 9247c8ac..6b4d6670 100644
--- a/src/DefaultBtInteractive.h
+++ b/src/DefaultBtInteractive.h
@@ -36,19 +36,20 @@
 #define _D_DEFAULT_BT_INTERACTIVE_H_
 
 #include "BtInteractive.h"
-#include "Peer.h"
-#include "BtContext.h"
-#include "PieceStorage.h"
-#include "PeerStorage.h"
-#include "BtMessageReceiver.h"
-#include "BtMessageDispatcher.h"
-#include "BtRequestFactory.h"
-#include "PeerConnection.h"
-#include "BtRegistry.h"
-#include "Logger.h"
-#include "LogFactory.h"
+#include "BtContextAwareCommand.h"
 #include "TimeA2.h"
-#include "DHTNodeDecl.h"
+
+namespace aria2 {
+
+class Peer;
+class BtMessage;
+class BtMessageReceiver;
+class BtMessageDispatcher;
+class BtMessageFactory;
+class BtRequestFactory;
+class PeerConnection;
+class DHTNode;
+class Logger;
 
 class FloodingStat {
 private:
@@ -83,20 +84,19 @@ public:
   }
 };
 
-class DefaultBtInteractive : public BtInteractive {
+class DefaultBtInteractive : public BtInteractive, public BtContextAwareCommand {
 private:
   int32_t cuid;
-  PeerHandle peer;
-  BtContextHandle btContext;
-  PeerStorageHandle peerStorage;
-  PieceStorageHandle pieceStorage;
-  BtRuntimeHandle btRuntime;
-  BtMessageReceiverWeakHandle btMessageReceiver;
-  BtMessageDispatcherWeakHandle dispatcher;
-  BtRequestFactoryWeakHandle btRequestFactory;
-  PeerConnectionWeakHandle peerConnection;
-  BtMessageFactoryWeakHandle messageFactory;
+  SharedHandle<Peer> peer;
+
+  WeakHandle<BtMessageReceiver> btMessageReceiver;
+  WeakHandle<BtMessageDispatcher> dispatcher;
+  WeakHandle<BtRequestFactory> btRequestFactory;
+  WeakHandle<PeerConnection> peerConnection;
+  WeakHandle<BtMessageFactory> messageFactory;
+
   WeakHandle<DHTNode> _localNode;
+
   const Logger* logger;
   int32_t allowedFastSetSize;
   Time haveCheckPoint;
@@ -127,30 +127,16 @@ private:
   void addPortMessageToQueue();
 
 public:
-  DefaultBtInteractive():peer(0),
-			 btContext(0),
-			 peerStorage(0),
-			 pieceStorage(0),
-			 btRuntime(0),
-			 btMessageReceiver(0),
-			 dispatcher(0),
-			 btRequestFactory(0),
-			 peerConnection(0),
-			 logger(LogFactory::getInstance()),
-			 allowedFastSetSize(10),
-			 keepAliveInterval(120),
-			 maxDownloadSpeedLimit(0),
-			 _utPexEnabled(false),
-			 _dhtEnabled(false)
-  {}
+  DefaultBtInteractive(const SharedHandle<BtContext>& btContext,
+		       const SharedHandle<Peer>& peer);
 
-  virtual ~DefaultBtInteractive() {}
+  virtual ~DefaultBtInteractive();
 
   virtual void initiateHandshake();
 
-  virtual BtMessageHandle receiveHandshake(bool quickReply = false);
+  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false);
 
-  virtual BtMessageHandle receiveAndSendHandshake();
+  virtual SharedHandle<BtMessage> receiveAndSendHandshake();
 
   virtual void doPostHandshakeProcessing();
 
@@ -162,44 +148,25 @@ public:
 
   void receiveMessages();
 
-  virtual int32_t countPendingMessage() {
-    return dispatcher->countMessageInQueue();
-  }
+  virtual int32_t countPendingMessage();
   
-  virtual bool isSendingMessageInProgress() {
-    return dispatcher->isSendingInProgress();
-  }
+  virtual bool isSendingMessageInProgress();
 
   void setCuid(int32_t cuid) {
     this->cuid = cuid;
   }
 
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-    this->peerStorage = PEER_STORAGE(btContext);
-    this->pieceStorage = PIECE_STORAGE(btContext);
-    this->btRuntime = BT_RUNTIME(btContext);
-  }
+  void setBtMessageReceiver(const WeakHandle<BtMessageReceiver>& receiver);
 
-  void setBtMessageReceiver(const BtMessageReceiverWeakHandle& receiver) {
-    this->btMessageReceiver = receiver;
-  }
+  void setDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher);
 
-  void setDispatcher(const BtMessageDispatcherWeakHandle& dispatcher) {
-    this->dispatcher = dispatcher;
-  }
+  void setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory);
 
-  void setBtRequestFactory(const BtRequestFactoryWeakHandle& factory) {
-    this->btRequestFactory = factory;
-  }
+  void setPeerConnection(const WeakHandle<PeerConnection>& peerConnection);
 
-  void setPeerConnection(const PeerConnectionWeakHandle& peerConnection) {
-    this->peerConnection  = peerConnection;
-  }
+  void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
 
   void setKeepAliveInterval(int32_t keepAliveInterval) {
     this->keepAliveInterval = keepAliveInterval;
@@ -209,10 +176,6 @@ public:
     this->maxDownloadSpeedLimit = maxDownloadSpeedLimit;
   }
 
-  void setBtMessageFactory(const BtMessageFactoryWeakHandle& factory) {
-    this->messageFactory = factory;
-  }
-
   void setUTPexEnabled(bool f)
   {
     _utPexEnabled = f;
@@ -228,4 +191,6 @@ public:
 
 typedef SharedHandle<DefaultBtInteractive> DefaultBtInteractiveHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_INTERACTIVE_H_
diff --git a/src/DefaultBtMessageDispatcher.cc b/src/DefaultBtMessageDispatcher.cc
index 98744ecc..09233685 100644
--- a/src/DefaultBtMessageDispatcher.cc
+++ b/src/DefaultBtMessageDispatcher.cc
@@ -33,15 +33,39 @@
  */
 /* copyright --> */
 #include "DefaultBtMessageDispatcher.h"
-#include "BtRegistry.h"
 #include "prefs.h"
 #include "BtAbortOutstandingRequestEvent.h"
 #include "BtCancelSendingPieceEvent.h"
 #include "BtChokedEvent.h"
 #include "BtChokingEvent.h"
-#include "BtRegistry.h"
 #include "BtMessageFactory.h"
 #include "message.h"
+#include "BtContext.h"
+#include "PeerStorage.h"
+#include "PieceStorage.h"
+#include "BtMessage.h"
+#include "BtRegistry.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "LogFactory.h"
+#include "Logger.h"
+
+namespace aria2 {
+
+DefaultBtMessageDispatcher::DefaultBtMessageDispatcher():
+  cuid(0),
+  btContext(0),
+  peerStorage(0),
+  pieceStorage(0),
+  peer(0),
+  maxUploadSpeedLimit(0),
+  requestTimeout(0),
+  logger(LogFactory::getInstance()) {}
+
+DefaultBtMessageDispatcher::~DefaultBtMessageDispatcher()
+{
+  logger->debug("DefaultBtMessageDispatcher::deleted");
+}
 
 void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessageHandle& btMessage)
 {
@@ -212,3 +236,61 @@ bool DefaultBtMessageDispatcher::isOutstandingRequest(int32_t index, int32_t blo
   }
   return false;
 }
+
+RequestSlot
+DefaultBtMessageDispatcher::getOutstandingRequest(int32_t index, int32_t begin, int32_t length)
+{
+  for(RequestSlots::iterator itr = requestSlots.begin();
+      itr != requestSlots.end(); itr++) {
+    if(itr->getIndex() == index &&
+       itr->getBegin() == begin &&
+       itr->getLength() == length) {
+      return *itr;
+    }
+  }
+  return RequestSlot::nullSlot;
+}
+
+void DefaultBtMessageDispatcher::removeOutstandingRequest(const RequestSlot& slot)
+{
+  RequestSlots temp;
+  std::remove_copy(requestSlots.begin(), requestSlots.end(), back_inserter(temp), slot);
+  requestSlots = temp;
+}
+
+void DefaultBtMessageDispatcher::addOutstandingRequest(const RequestSlot& requestSlot)
+{
+  if(!isOutstandingRequest(requestSlot.getIndex(), requestSlot.getBlockIndex())) {
+    requestSlots.push_back(requestSlot);
+  }
+}
+
+std::deque<SharedHandle<BtMessage> >&
+DefaultBtMessageDispatcher::getMessageQueue()
+{
+  return messageQueue;
+}
+
+std::deque<RequestSlot>& DefaultBtMessageDispatcher::getRequestSlots()
+{
+  return requestSlots;
+}
+
+void DefaultBtMessageDispatcher::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+void DefaultBtMessageDispatcher::setBtContext(const BtContextHandle& btContext)
+{
+  this->btContext = btContext;
+  this->pieceStorage = PIECE_STORAGE(btContext);
+  this->peerStorage = PEER_STORAGE(btContext);
+}
+
+void DefaultBtMessageDispatcher::setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory)
+{
+  this->messageFactory = factory;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtMessageDispatcher.h b/src/DefaultBtMessageDispatcher.h
index 5a7e2ca3..4f6cdcfa 100644
--- a/src/DefaultBtMessageDispatcher.h
+++ b/src/DefaultBtMessageDispatcher.h
@@ -36,58 +36,47 @@
 #define _D_DEFAULT_BT_MESSAGE_DISPATCHER_H_
 
 #include "BtMessageDispatcher.h"
-#include "BtContext.h"
-#include "PeerStorage.h"
-#include "PieceStorage.h"
-#include "RequestSlot.h"
-#include "BtMessage.h"
-#include "Peer.h"
-#include "LogFactory.h"
-#include "Logger.h"
-#include "BtRegistry.h"
+
+namespace aria2 {
+
+class BtContext;
+class PeerStorage;
+class PieceStorage;
+class BtMessage;
+class BtMessageFactory;
+class Peer;
+class Piece;
+class Logger;
 
 class DefaultBtMessageDispatcher : public BtMessageDispatcher {
 private:
   int32_t cuid;
-  BtMessages messageQueue;
-  RequestSlots requestSlots;
-  BtContextHandle btContext;
-  PeerStorageHandle peerStorage;
-  PieceStorageHandle pieceStorage;
-  BtMessageFactoryWeakHandle messageFactory;
-  PeerHandle peer;
+  std::deque<SharedHandle<BtMessage> > messageQueue;
+  std::deque<RequestSlot> requestSlots;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<PeerStorage> peerStorage;
+  SharedHandle<PieceStorage> pieceStorage;
+  WeakHandle<BtMessageFactory> messageFactory;
+  SharedHandle<Peer> peer;
   int32_t maxUploadSpeedLimit;
   int32_t requestTimeout;
   const Logger* logger;
 public:
-  DefaultBtMessageDispatcher():
-    cuid(0),
-    btContext(0),
-    peerStorage(0),
-    pieceStorage(0),
-    peer(0),
-    maxUploadSpeedLimit(0),
-    requestTimeout(0),
-    logger(LogFactory::getInstance())
-  {
-    logger->debug("DefaultBtMessageDispatcher::instantiated");
-  }
+  DefaultBtMessageDispatcher();
 
-  virtual ~DefaultBtMessageDispatcher() {
-    logger->debug("DefaultBtMessageDispatcher::deleted");
-  }
+  virtual ~DefaultBtMessageDispatcher();
   
-  virtual void addMessageToQueue(const BtMessageHandle& btMessage);
+  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
 
-  virtual void addMessageToQueue(const BtMessages& btMessages);
+  virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages);
 
   virtual void sendMessages();
 
   virtual void doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length);
 
-  virtual void doCancelSendingPieceAction(const PieceHandle& piece);
+  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece);
 
-  virtual void doAbortOutstandingRequestAction(const PieceHandle& piece);
+  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece);
 
   virtual void doChokedAction();
 
@@ -105,47 +94,21 @@ public:
 
   virtual bool isOutstandingRequest(int32_t index, int32_t blockIndex);
 
-  virtual RequestSlot getOutstandingRequest(int32_t index, int32_t begin, int32_t length) {
-    for(RequestSlots::iterator itr = requestSlots.begin();
-	itr != requestSlots.end(); itr++) {
-      if(itr->getIndex() == index &&
-	 itr->getBegin() == begin &&
-	 itr->getLength() == length) {
-	return *itr;
-      }
-    }
-    return RequestSlot::nullSlot;
-  }
+  virtual RequestSlot getOutstandingRequest(int32_t index, int32_t begin, int32_t length);
 
-  virtual void removeOutstandingRequest(const RequestSlot& slot) {
-    RequestSlots temp;
-    remove_copy(requestSlots.begin(), requestSlots.end(), back_inserter(temp), slot);
-    requestSlots = temp;
-  }
+  virtual void removeOutstandingRequest(const RequestSlot& slot);
 
-  virtual void addOutstandingRequest(const RequestSlot& requestSlot) {
-    if(!isOutstandingRequest(requestSlot.getIndex(), requestSlot.getBlockIndex())) {
-      requestSlots.push_back(requestSlot);
-    }
-  }
+  virtual void addOutstandingRequest(const RequestSlot& requestSlot);
 
-  BtMessages& getMessageQueue() {
-    return messageQueue;
-  }
+  std::deque<SharedHandle<BtMessage> >& getMessageQueue();
 
-  RequestSlots& getRequestSlots() {
-    return requestSlots;
-  }
+  RequestSlots& getRequestSlots();
 
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-    this->pieceStorage = PIECE_STORAGE(btContext);
-    this->peerStorage = PEER_STORAGE(btContext);
-  }
+  void setBtContext(const SharedHandle<BtContext>& btContext);
+
+  void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
 
   void setCuid(int32_t cuid) {
     this->cuid = cuid;
@@ -159,10 +122,10 @@ public:
     this->requestTimeout = requestTimeout;
   }
 
-  void setBtMessageFactory(const BtMessageFactoryWeakHandle& factory) {
-    this->messageFactory = factory;
-  }
 };
 
 typedef SharedHandle<DefaultBtMessageDispatcher> DefaultBtMessageDispatcherHandle;
+
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_MESSAGE_DISPATCHER_H_
diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc
index 48819d48..7cfec8be 100644
--- a/src/DefaultBtMessageFactory.cc
+++ b/src/DefaultBtMessageFactory.cc
@@ -63,6 +63,13 @@
 #include "BtHandshakeMessageValidator.h"
 #include "BtExtendedMessage.h"
 #include "ExtensionMessage.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "BtRegistry.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+
+namespace aria2 {
 
 DefaultBtMessageFactory::DefaultBtMessageFactory():cuid(0),
 						   btContext(0),
@@ -205,7 +212,7 @@ void DefaultBtMessageFactory::setCommonProperty(const AbstractBtMessageHandle& m
 BtMessageHandle
 DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* data, int32_t dataLength)
 {
-  BtHandshakeMessageHandle msg = BtHandshakeMessage::create(data, dataLength);
+  SharedHandle<BtHandshakeMessage> msg = BtHandshakeMessage::create(data, dataLength);
   BtMessageValidatorHandle validator =
     new BtHandshakeMessageValidator(msg.get(),
 				    btContext->getInfoHash());
@@ -218,7 +225,7 @@ BtMessageHandle
 DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
 						const unsigned char* peerId)
 {
-  BtHandshakeMessageHandle msg = new BtHandshakeMessage(infoHash, peerId);
+  SharedHandle<BtHandshakeMessage> msg = new BtHandshakeMessage(infoHash, peerId);
   BtMessageValidatorHandle validator =
     new BtHandshakeMessageValidator(msg.get(),
 				    btContext->getInfoHash());
@@ -383,7 +390,7 @@ DefaultBtMessageFactory::createPortMessage(uint16_t port)
 }
 
 BtMessageHandle
-DefaultBtMessageFactory::createBtExtendedMessage(const ExensionMessageHandle& msg)
+DefaultBtMessageFactory::createBtExtendedMessage(const ExtensionMessageHandle& msg)
 {
   BtExtendedMessageHandle m = new BtExtendedMessage(msg);
   setCommonProperty(m);
@@ -399,3 +406,31 @@ void DefaultBtMessageFactory::setTaskFactory(const WeakHandle<DHTTaskFactory>& t
 {
   _taskFactory = taskFactory;
 }
+
+void DefaultBtMessageFactory::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+void DefaultBtMessageFactory::setBtContext(const SharedHandle<BtContext>& btContext)
+{
+  this->btContext = btContext;
+  this->pieceStorage = PIECE_STORAGE(btContext);
+}
+
+void DefaultBtMessageFactory::setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher)
+{
+  this->dispatcher = dispatcher;
+}
+  
+void DefaultBtMessageFactory::setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory)
+{
+  this->requestFactory = factory;
+}
+
+void DefaultBtMessageFactory::setPeerConnection(const WeakHandle<PeerConnection>& connection)
+{
+  this->peerConnection = connection;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtMessageFactory.h b/src/DefaultBtMessageFactory.h
index 6b1ad1aa..b7ddb9b8 100644
--- a/src/DefaultBtMessageFactory.h
+++ b/src/DefaultBtMessageFactory.h
@@ -36,99 +36,94 @@
 #define _D_DEFAULT_BT_MESSAGE_FACTORY_H_
 
 #include "BtMessageFactory.h"
-#include "Peer.h"
-#include "AbstractBtMessage.h"
-#include "BtRegistry.h"
-#include "DHTTaskQueueDecl.h"
-#include "DHTTaskFactoryDecl.h"
+
+namespace aria2 {
+
+class BtContext;
+class Peer;
+class AbstractBtMessage;
+class BtMessageDispatcher;
+class BtRequestFactory;
+class PeerConnection;
+class PieceStorage;
+class DHTTaskQueue;
+class DHTTaskFactory;
 
 class DefaultBtMessageFactory : public BtMessageFactory {
 private:
   int32_t cuid;
-  BtContextHandle btContext;
-  PieceStorageHandle pieceStorage;
-  PeerHandle peer;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<PieceStorage> pieceStorage;
+  SharedHandle<Peer> peer;
 
   bool _dhtEnabled;
 
-  BtMessageDispatcherWeakHandle dispatcher;
+  WeakHandle<BtMessageDispatcher> dispatcher;
 
-  BtRequestFactoryWeakHandle requestFactory;
+  WeakHandle<BtRequestFactory> requestFactory;
 
-  PeerConnectionWeakHandle peerConnection;
+  WeakHandle<PeerConnection> peerConnection;
 
   WeakHandle<DHTTaskQueue> _taskQueue;
 
   WeakHandle<DHTTaskFactory> _taskFactory;
 
-  void setCommonProperty(const AbstractBtMessageHandle& msg);
+  void setCommonProperty(const SharedHandle<AbstractBtMessage>& msg);
 public:
   DefaultBtMessageFactory();
 
   virtual ~DefaultBtMessageFactory();
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createBtMessage(const unsigned char* msg, int32_t msgLength);
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* msg, int32_t msgLength);
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* infoHash,
 			 const unsigned char* peerId);
 
-  virtual BtMessageHandle
-  createRequestMessage(const PieceHandle& piece, int32_t blockIndex);
+  virtual SharedHandle<BtMessage>
+  createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex);
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createCancelMessage(int32_t index, int32_t begin, int32_t length);
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createPieceMessage(int32_t index, int32_t begin, int32_t length);
 
-  virtual BtMessageHandle createHaveMessage(int32_t index);
+  virtual SharedHandle<BtMessage> createHaveMessage(int32_t index);
 
-  virtual BtMessageHandle createChokeMessage();
+  virtual SharedHandle<BtMessage> createChokeMessage();
 
-  virtual BtMessageHandle createUnchokeMessage();
+  virtual SharedHandle<BtMessage> createUnchokeMessage();
   
-  virtual BtMessageHandle createInterestedMessage();
+  virtual SharedHandle<BtMessage> createInterestedMessage();
 
-  virtual BtMessageHandle createNotInterestedMessage();
+  virtual SharedHandle<BtMessage> createNotInterestedMessage();
 
-  virtual BtMessageHandle createBitfieldMessage();
+  virtual SharedHandle<BtMessage> createBitfieldMessage();
 
-  virtual BtMessageHandle createKeepAliveMessage();
+  virtual SharedHandle<BtMessage> createKeepAliveMessage();
   
-  virtual BtMessageHandle createHaveAllMessage();
+  virtual SharedHandle<BtMessage> createHaveAllMessage();
 
-  virtual BtMessageHandle createHaveNoneMessage();
+  virtual SharedHandle<BtMessage> createHaveNoneMessage();
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createRejectMessage(int32_t index, int32_t begin, int32_t length);
 
-  virtual BtMessageHandle createAllowedFastMessage(int32_t index);
+  virtual SharedHandle<BtMessage> createAllowedFastMessage(int32_t index);
 
-  virtual BtMessageHandle createPortMessage(uint16_t port);
+  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port);
 
-  virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle& msg);
+  virtual SharedHandle<BtMessage>
+  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& msg);
 
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  PeerHandle getPeer() const {
-    return peer;
-  }
-
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-    this->pieceStorage = PIECE_STORAGE(btContext);
-  }
-
-  BtContextHandle getBtContext() const {
-    return btContext;
-  }
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
   void setCuid(int32_t cuid) {
     this->cuid = cuid;
@@ -138,18 +133,11 @@ public:
     _dhtEnabled = enabled;
   }
 
-  void setBtMessageDispatcher(const BtMessageDispatcherWeakHandle& dispatcher)
-  {
-    this->dispatcher = dispatcher;
-  }
+  void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher);
   
-  void setBtRequestFactory(const BtRequestFactoryWeakHandle& factory) {
-    this->requestFactory = factory;
-  }
+  void setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory);
 
-  void setPeerConnection(const PeerConnectionWeakHandle& connection) {
-    this->peerConnection = connection;
-  }
+  void setPeerConnection(const WeakHandle<PeerConnection>& connection);
   
   void setTaskQueue(const WeakHandle<DHTTaskQueue>& taskQueue);
 
@@ -158,4 +146,6 @@ public:
 
 typedef SharedHandle<DefaultBtMessageFactory> DefaultBtMessageFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_MESSAGE_FACTORY_H_
diff --git a/src/DefaultBtMessageReceiver.cc b/src/DefaultBtMessageReceiver.cc
index 7bee71b4..332886ab 100644
--- a/src/DefaultBtMessageReceiver.cc
+++ b/src/DefaultBtMessageReceiver.cc
@@ -35,6 +35,34 @@
 #include "DefaultBtMessageReceiver.h"
 #include "BtHandshakeMessage.h"
 #include "message.h"
+#include "BtContext.h"
+#include "BtRegistry.h"
+#include "Peer.h"
+#include "PeerConnection.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageFactory.h"
+#include "Logger.h"
+#include "LogFactory.h"
+#include <cstring>
+
+namespace aria2 {
+
+DefaultBtMessageReceiver::DefaultBtMessageReceiver():
+  cuid(0),
+  handshakeSent(false),
+  btContext(0),
+  peer(0),
+  peerConnection(0),
+  dispatcher(0),
+  logger(LogFactory::getInstance())
+{
+  logger->debug("DefaultBtMessageReceiver::instantiated");
+}
+
+DefaultBtMessageReceiver::~DefaultBtMessageReceiver()
+{
+  logger->debug("DefaultBtMessageReceiver::deleted");
+}
 
 BtMessageHandle DefaultBtMessageReceiver::receiveHandshake(bool quickReply) {
   unsigned char data[BtHandshakeMessage::MESSAGE_LENGTH];
@@ -51,8 +79,8 @@ BtMessageHandle DefaultBtMessageReceiver::receiveHandshake(bool quickReply) {
   if(!retval) {
     return 0;
   }
-  BtHandshakeMessageHandle msg = messageFactory->createHandshakeMessage(data, dataLength);
-  Errors errors;
+  SharedHandle<BtHandshakeMessage> msg = messageFactory->createHandshakeMessage(data, dataLength);
+  std::deque<std::string> errors;
   msg->validate(errors);
   return msg;
 }
@@ -62,7 +90,7 @@ BtMessageHandle DefaultBtMessageReceiver::receiveAndSendHandshake() {
 }
 
 void DefaultBtMessageReceiver::sendHandshake() {
-  BtHandshakeMessageHandle msg =
+  SharedHandle<BtHandshakeMessage> msg =
     messageFactory->createHandshakeMessage(btContext->getInfoHash(),
 					   btContext->getPeerId());
   dispatcher->addMessageToQueue(msg);
@@ -76,7 +104,7 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
     return 0;
   }
   BtMessageHandle msg = messageFactory->createBtMessage(data, dataLength);
-  Errors errors;
+  std::deque<std::string> errors;
   if(msg->validate(errors)) {
     return msg;
   } else {
@@ -85,3 +113,29 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
   }
 }
 
+void DefaultBtMessageReceiver::setBtContext(const SharedHandle<BtContext>& btContext)
+{
+  this->btContext = btContext;
+}
+
+void DefaultBtMessageReceiver::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+void DefaultBtMessageReceiver::setPeerConnection(const WeakHandle<PeerConnection>& peerConnection)
+{
+  this->peerConnection = peerConnection;
+}
+
+void DefaultBtMessageReceiver::setDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher)
+{
+  this->dispatcher = dispatcher;
+}
+
+void DefaultBtMessageReceiver::setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory)
+{
+  this->messageFactory = factory;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtMessageReceiver.h b/src/DefaultBtMessageReceiver.h
index 7a598386..040062be 100644
--- a/src/DefaultBtMessageReceiver.h
+++ b/src/DefaultBtMessageReceiver.h
@@ -36,48 +36,38 @@
 #define _D_DEFAULT_BT_MESSAGE_RECEIVER_H_
 
 #include "BtMessageReceiver.h"
-#include "BtContext.h"
-#include "BtRegistry.h"
-#include "Peer.h"
-#include "PeerConnection.h"
-#include "BtMessageDispatcher.h"
-#include "Logger.h"
-#include "LogFactory.h"
+
+namespace aria2 {
+
+class BtContext;
+class Peer;
+class PeerConnection;
+class BtMessageDispatcher;
+class BtMessageFactory;
+class Logger;
 
 class DefaultBtMessageReceiver : public BtMessageReceiver {
 private:
   int32_t cuid;
   bool handshakeSent;
-  BtContextHandle btContext;
-  PeerHandle peer;
-  PeerConnectionWeakHandle peerConnection;
-  BtMessageDispatcherWeakHandle dispatcher;
-  BtMessageFactoryWeakHandle messageFactory;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<Peer> peer;
+  WeakHandle<PeerConnection> peerConnection;
+  WeakHandle<BtMessageDispatcher> dispatcher;
+  WeakHandle<BtMessageFactory> messageFactory;
   const Logger* logger;
 
   void sendHandshake();
 public:
-  DefaultBtMessageReceiver():cuid(0),
-			     handshakeSent(false),
-			     btContext(0),
-			     peer(0),
-			     peerConnection(0),
-			     dispatcher(0),
-			     logger(LogFactory::getInstance())
-  {
-    logger->debug("DefaultBtMessageReceiver::instantiated");
-  }
+  DefaultBtMessageReceiver();
 
-  virtual ~DefaultBtMessageReceiver()
-  {
-    logger->debug("DefaultBtMessageReceiver::deleted");
-  }
+  virtual ~DefaultBtMessageReceiver();
 
-  virtual BtMessageHandle receiveHandshake(bool quickReply = false);
+  virtual SharedHandle<BtMessage> receiveHandshake(bool quickReply = false);
 
-  virtual BtMessageHandle receiveAndSendHandshake();
+  virtual SharedHandle<BtMessage> receiveAndSendHandshake();
 
-  virtual BtMessageHandle receiveMessage();
+  virtual SharedHandle<BtMessage> receiveMessage();
 
   void setCuid(int32_t cuid) {
     this->cuid = cuid;
@@ -87,39 +77,19 @@ public:
     return cuid;
   }
 
-  void setPeerConnection(const PeerConnectionWeakHandle& peerConnection) {
-    this->peerConnection = peerConnection;
-  }
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  PeerConnectionWeakHandle getPeerConnection() const {
-    return peerConnection;
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-  }
+  void setPeerConnection(const WeakHandle<PeerConnection>& peerConnection);
 
-  BtContextHandle getBtContext() const {
-    return btContext;
-  }
+  void setDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher);
 
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
-
-  PeerHandle getPeer() const {
-    return peer;
-  }
-
-  void setDispatcher(const BtMessageDispatcherWeakHandle& dispatcher) {
-    this->dispatcher = dispatcher;
-  }
-
-  void setBtMessageFactory(const BtMessageFactoryWeakHandle& factory) {
-    this->messageFactory = factory;
-  }
+  void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
 };
 
 typedef SharedHandle<DefaultBtMessageReceiver> DefaultBtMessageReceiverHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_MESSAGE_RECEIVER_H_
diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc
index 5d6a5a95..2c813dc5 100644
--- a/src/DefaultBtProgressInfoFile.cc
+++ b/src/DefaultBtProgressInfoFile.cc
@@ -33,11 +33,17 @@
  */
 /* copyright --> */
 #include "DefaultBtProgressInfoFile.h"
-#include "DownloadContext.h"
+#include "BtContext.h"
 #include "PieceStorage.h"
+#include "Piece.h"
+#include "PeerStorage.h"
+#include "BtRuntime.h"
+#include "BitfieldMan.h"
 #include "Option.h"
+#include "TransferStat.h"
 #include "BtRegistry.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "prefs.h"
 #include "DlAbortEx.h"
 #include "message.h"
@@ -46,7 +52,9 @@
 #include "a2io.h"
 #include "DownloadFailureException.h"
 #include <fstream>
-#include <errno.h>
+#include <cerrno>
+
+namespace aria2 {
 
 DefaultBtProgressInfoFile::DefaultBtProgressInfoFile(const DownloadContextHandle& dctx,
 						     const PieceStorageHandle& pieceStorage,
@@ -68,9 +76,9 @@ bool DefaultBtProgressInfoFile::isTorrentDownload()
 
 void DefaultBtProgressInfoFile::save() {
   _logger->info(MSG_SAVING_SEGMENT_FILE, _filename.c_str());
-  string filenameTemp = _filename+"__temp";
-  ofstream o(filenameTemp.c_str(), ios::out|ios::binary);
-  o.exceptions(ios::failbit);
+  std::string filenameTemp = _filename+"__temp";
+  std::ofstream o(filenameTemp.c_str(), std::ios::out|std::ios::binary);
+  o.exceptions(std::ios::failbit);
   try {
     bool torrentDownload = isTorrentDownload();
     // file version: 16 bits
@@ -138,8 +146,8 @@ void DefaultBtProgressInfoFile::save() {
 
     o.close();
     _logger->info(MSG_SAVED_SEGMENT_FILE);
-  } catch(ios::failure const& exception) {
-    // TODO ios::failure doesn't give us the reasons of failure...
+  } catch(std::ios::failure const& exception) {
+    // TODO std::ios::failure doesn't give us the reasons of failure...
     throw new DlAbortEx(EX_SEGMENT_FILE_WRITE,
 			_filename.c_str(), strerror(errno));
   }
@@ -152,14 +160,14 @@ void DefaultBtProgressInfoFile::save() {
 void DefaultBtProgressInfoFile::load() 
 {
   _logger->info(MSG_LOADING_SEGMENT_FILE, _filename.c_str());
-  ifstream in(_filename.c_str(), ios::in|ios::binary);
-  in.exceptions(ios::failbit);
+  std::ifstream in(_filename.c_str(), std::ios::in|std::ios::binary);
+  in.exceptions(std::ios::failbit);
   unsigned char* savedInfoHash = 0;
   unsigned char* savedBitfield = 0;
   try {
     unsigned char version[2];
     in.read((char*)version, sizeof(version));
-    if(string("0000") != Util::toHex(version, sizeof(version))) {
+    if(std::string("0000") != Util::toHex(version, sizeof(version))) {
       throw new DlAbortEx("Unsupported ctrl file version: %s",
 			  Util::toHex(version, sizeof(version)).c_str());
     }
@@ -272,10 +280,10 @@ void DefaultBtProgressInfoFile::load()
       savedBitfield = 0;
     }
     _logger->info(MSG_LOADED_SEGMENT_FILE);
-  } catch(ios::failure const& exception) {
+  } catch(std::ios::failure const& exception) {
     delete [] savedBitfield;
     delete [] savedInfoHash;
-    // TODO ios::failure doesn't give us the reasons of failure...
+    // TODO std::ios::failure doesn't give us the reasons of failure...
     throw new DlAbortEx(EX_SEGMENT_FILE_READ,
 			_filename.c_str(), strerror(errno));
   } 
@@ -298,3 +306,5 @@ bool DefaultBtProgressInfoFile::exists() {
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/DefaultBtProgressInfoFile.h b/src/DefaultBtProgressInfoFile.h
index e11249eb..f52ff67e 100644
--- a/src/DefaultBtProgressInfoFile.h
+++ b/src/DefaultBtProgressInfoFile.h
@@ -37,31 +37,31 @@
 
 #include "BtProgressInfoFile.h"
 
+namespace aria2 {
+
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class PieceStorage;
-typedef SharedHandle<PieceStorage> PieceStorageHandle;
 class Logger;
 class Option;
 
 class DefaultBtProgressInfoFile : public BtProgressInfoFile {
 private:
-  DownloadContextHandle _dctx;
-  PieceStorageHandle _pieceStorage;
+  SharedHandle<DownloadContext> _dctx;
+  SharedHandle<PieceStorage> _pieceStorage;
   const Option* _option;
   const Logger* _logger;
-  string _filename;
+  std::string _filename;
 
   bool isTorrentDownload();
 
 public:
-  DefaultBtProgressInfoFile(const DownloadContextHandle& btContext,
-			    const PieceStorageHandle& pieceStorage,
+  DefaultBtProgressInfoFile(const SharedHandle<DownloadContext>& btContext,
+			    const SharedHandle<PieceStorage>& pieceStorage,
 			    const Option* option);
 
   virtual ~DefaultBtProgressInfoFile();
 
-  virtual string getFilename() { return _filename; }
+  virtual std::string getFilename() { return _filename; }
   
   virtual bool exists();
 
@@ -73,4 +73,6 @@ public:
 
 };
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_PROGRESS_INFO_FILE_H_
diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc
index c73ec230..6a94461c 100644
--- a/src/DefaultBtRequestFactory.cc
+++ b/src/DefaultBtRequestFactory.cc
@@ -33,6 +33,38 @@
  */
 /* copyright --> */
 #include "DefaultBtRequestFactory.h"
+#include "LogFactory.h"
+#include "Logger.h"
+#include "Piece.h"
+#include "Peer.h"
+#include "BtContext.h"
+#include "PieceStorage.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageFactory.h"
+#include "BtMessage.h"
+#include "BtRegistry.h"
+
+namespace aria2 {
+
+DefaultBtRequestFactory::DefaultBtRequestFactory():
+  cuid(0),
+  btContext(0),
+  pieceStorage(0),
+  peer(0),
+  dispatcher(0)
+{
+  LogFactory::getInstance()->debug("DefaultBtRequestFactory::instantiated");
+}
+
+DefaultBtRequestFactory::~DefaultBtRequestFactory()
+{
+  LogFactory::getInstance()->debug("DefaultBtRequestFactory::deleted");
+}
+
+void DefaultBtRequestFactory::addTargetPiece(const PieceHandle& piece)
+{
+  pieces.push_back(piece);
+}
 
 void DefaultBtRequestFactory::removeCompletedPiece() {
   for(Pieces::iterator itr = pieces.begin(); itr != pieces.end();) {
@@ -95,9 +127,9 @@ BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(int32_t max)
   for(Pieces::iterator itr = pieces.begin();
       itr != pieces.end() && requests.size() < (size_t)max; itr++) {
     PieceHandle& piece = *itr;
-    BlockIndexes missingBlockIndexes = piece->getAllMissingBlockIndexes();
+    std::deque<int32_t> missingBlockIndexes = piece->getAllMissingBlockIndexes();
     random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end());
-    for(BlockIndexes::const_iterator bitr = missingBlockIndexes.begin();
+    for(std::deque<int32_t>::const_iterator bitr = missingBlockIndexes.begin();
 	bitr != missingBlockIndexes.end() && requests.size() < (size_t)max;
 	bitr++) {
       int32_t blockIndex = *bitr;
@@ -109,3 +141,31 @@ BtMessages DefaultBtRequestFactory::createRequestMessagesOnEndGame(int32_t max)
   }
   return requests;
 }
+
+std::deque<SharedHandle<Piece> >& DefaultBtRequestFactory::getTargetPieces()
+{
+  return pieces;
+}
+
+void DefaultBtRequestFactory::setBtContext(const SharedHandle<BtContext>& btContext)
+{
+  this->btContext = btContext;
+  this->pieceStorage = PIECE_STORAGE(btContext);
+}
+
+void DefaultBtRequestFactory::setPeer(const SharedHandle<Peer>& peer)
+{
+  this->peer = peer;
+}
+
+void DefaultBtRequestFactory::setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher)
+{
+  this->dispatcher = dispatcher;
+}
+
+void DefaultBtRequestFactory::setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory)
+{
+  this->messageFactory = factory;
+}
+
+} // namespace aria2
diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h
index ab93d6aa..f71f0627 100644
--- a/src/DefaultBtRequestFactory.h
+++ b/src/DefaultBtRequestFactory.h
@@ -36,44 +36,33 @@
 #define _D_DEFAULT_BT_REQUEST_FACTORY_H_
 
 #include "BtRequestFactory.h"
-#include "BtContext.h"
-#include "PieceStorage.h"
-#include "Piece.h"
-#include "Peer.h"
-#include "BtMessageDispatcher.h"
-#include "BtRegistry.h"
-#include "LogFactory.h"
+
+namespace aria2 {
+
+class BtContext;
+class PieceStorage;
+class Peer;
+class BtMessageDispatcher;
+class BtMessageFactory;
+class Piece;
 
 class DefaultBtRequestFactory : public BtRequestFactory {
 private:
   int32_t cuid;
-  BtContextHandle btContext;
-  PieceStorageHandle pieceStorage;
-  PeerHandle peer;
-  BtMessageDispatcherWeakHandle dispatcher;
-  BtMessageFactoryWeakHandle messageFactory;
-  Pieces pieces;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<PieceStorage> pieceStorage;
+  SharedHandle<Peer> peer;
+  WeakHandle<BtMessageDispatcher> dispatcher;
+  WeakHandle<BtMessageFactory> messageFactory;
+  std::deque<SharedHandle<Piece> > pieces;
 public:
-  DefaultBtRequestFactory():
-    cuid(0),
-    btContext(0),
-    pieceStorage(0),
-    peer(0),
-    dispatcher(0)
-  {
-    LogFactory::getInstance()->debug("DefaultBtRequestFactory::instantiated");
-  }
+  DefaultBtRequestFactory();
 
-  virtual ~DefaultBtRequestFactory()
-  {
-    LogFactory::getInstance()->debug("DefaultBtRequestFactory::deleted");
-  }
+  virtual ~DefaultBtRequestFactory();
 
-  virtual void addTargetPiece(const PieceHandle& piece) {
-    pieces.push_back(piece);
-  }
+  virtual void addTargetPiece(const SharedHandle<Piece>& piece);
 
-  virtual void removeTargetPiece(const PieceHandle& piece);
+  virtual void removeTargetPiece(const SharedHandle<Piece>& piece);
 
   virtual void removeAllTargetPiece();
 
@@ -85,49 +74,30 @@ public:
 
   virtual void doChokedAction();
 
-  virtual BtMessages createRequestMessages(int32_t max);
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessages(int32_t max);
 
-  virtual BtMessages createRequestMessagesOnEndGame(int32_t max);
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessagesOnEndGame(int32_t max);
 
-  Pieces& getTargetPieces() {
-    return pieces;
-  }
+  std::deque<SharedHandle<Piece> >& getTargetPieces();
 
-  void setCuid(int32_t cuid) {
+  void setCuid(int32_t cuid)
+  {
     this->cuid = cuid;
   }
 
-  int32_t getCuid() const {
-    return cuid;
-  }
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  void setBtContext(const BtContextHandle& btContext) {
-    this->btContext = btContext;
-    this->pieceStorage = PIECE_STORAGE(btContext);
-  }
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  BtContextHandle getBtContext() const {
-    return btContext;
-  }
+  void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dispatcher);
 
-  PeerHandle getPeer() const {
-    return peer;
-  }
-
-  void setPeer(const PeerHandle& peer) {
-    this->peer = peer;
-  }
-
-  void setBtMessageDispatcher(const BtMessageDispatcherWeakHandle& dispatcher)
-  {
-    this->dispatcher = dispatcher;
-  }
-
-  void setBtMessageFactory(const BtMessageFactoryWeakHandle& factory) {
-    this->messageFactory = factory;
-  }
+  void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
 };
 
 typedef SharedHandle<DefaultBtRequestFactory> DefaultBtRequestFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_BT_REQUEST_FACTORY_H_
diff --git a/src/DefaultDiskWriter.cc b/src/DefaultDiskWriter.cc
index f2bf72f9..ec194e87 100644
--- a/src/DefaultDiskWriter.cc
+++ b/src/DefaultDiskWriter.cc
@@ -34,12 +34,16 @@
 /* copyright --> */
 #include "DefaultDiskWriter.h"
 
+namespace aria2 {
+
 DefaultDiskWriter::DefaultDiskWriter():AbstractDiskWriter() {}
 
 DefaultDiskWriter::~DefaultDiskWriter() {}
 
-void DefaultDiskWriter::initAndOpenFile(const string& filename,
+void DefaultDiskWriter::initAndOpenFile(const std::string& filename,
 					int64_t totalLength)
 {
   createFile(filename);
 }
+
+} // namespace aria2
diff --git a/src/DefaultDiskWriter.h b/src/DefaultDiskWriter.h
index 80052d1c..4939f447 100644
--- a/src/DefaultDiskWriter.h
+++ b/src/DefaultDiskWriter.h
@@ -36,7 +36,8 @@
 #define _D_DEFAULT_DISK_WRITER_H_
 
 #include "AbstractDiskWriter.h"
-#include "Option.h"
+
+namespace aria2 {
 
 class DefaultDiskWriter:public AbstractDiskWriter {
 public:
@@ -44,9 +45,11 @@ public:
 
   virtual ~DefaultDiskWriter();
 
-  virtual void initAndOpenFile(const string& filename, int64_t totalLength = 0);
+  virtual void initAndOpenFile(const std::string& filename, int64_t totalLength = 0);
 };
 
 typedef SharedHandle<DefaultDiskWriter> DefaultDiskWriterHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_DISK_WRITER_H_
diff --git a/src/DHTTaskQueueDecl.h b/src/DefaultDiskWriterFactory.cc
similarity index 88%
rename from src/DHTTaskQueueDecl.h
rename to src/DefaultDiskWriterFactory.cc
index d8105fbf..ed6bb1da 100644
--- a/src/DHTTaskQueueDecl.h
+++ b/src/DefaultDiskWriterFactory.cc
@@ -32,11 +32,14 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
-#ifndef _D_DHT_TASK_QUEUE_DECL_H_
-#define _D_DHT_TASK_QUEUE_DECL_H_
+#include "DefaultDiskWriterFactory.h"
+#include "DefaultDiskWriter.h"
 
-#include "SharedHandle.h"
+namespace aria2 {
 
-class DHTTaskQueue;
-typedef SharedHandle<DHTTaskQueue> DHTTaskQueueHandle;
-#endif // _D_DHT_TASK_QUEUE_DECL_H_
+SharedHandle<DiskWriter> DefaultDiskWriterFactory::newDiskWriter()
+{
+  return new DefaultDiskWriter();
+}
+
+} // namespace aria2
diff --git a/src/DefaultDiskWriterFactory.h b/src/DefaultDiskWriterFactory.h
index 1a8a1156..c8b38ece 100644
--- a/src/DefaultDiskWriterFactory.h
+++ b/src/DefaultDiskWriterFactory.h
@@ -36,17 +36,19 @@
 #define _D_DEFAULT_DISK_WRITER_FACTORY_H_
 
 #include "DiskWriterFactory.h"
-#include "DefaultDiskWriter.h"
+
+namespace aria2 {
+
+class DiskWriter;
 
 class DefaultDiskWriterFactory:public DiskWriterFactory
 {
 public:
-  DiskWriterHandle newDiskWriter()
-  {
-    return new DefaultDiskWriter();
-  }
+  virtual SharedHandle<DiskWriter> newDiskWriter();
 };
 
 typedef SharedHandle<DefaultDiskWriterFactory> DefaultDiskWriterFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_DISK_WRITER_FACTORY_H_
diff --git a/src/DefaultExtensionMessageFactory.cc b/src/DefaultExtensionMessageFactory.cc
index 91ae48b9..65ba36fc 100644
--- a/src/DefaultExtensionMessageFactory.cc
+++ b/src/DefaultExtensionMessageFactory.cc
@@ -39,8 +39,11 @@
 #include "HandshakeExtensionMessage.h"
 #include "UTPexExtensionMessage.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "BtRegistry.h"
 
+namespace aria2 {
+
 DefaultExtensionMessageFactory::DefaultExtensionMessageFactory():
   _btContext(0),
   _peer(0),
@@ -65,7 +68,7 @@ DefaultExtensionMessageFactory::createMessage(const char* data, size_t length)
     m->setPeer(_peer);
     return m;
   } else {
-    string extensionName = getExtensionName(extensionMessageID);
+    std::string extensionName = getExtensionName(extensionMessageID);
     if(extensionName.empty()) {
       throw new DlAbortEx("No extension registered for extended message ID %u",
 			  extensionMessageID);
@@ -91,3 +94,5 @@ void DefaultExtensionMessageFactory::setPeer(const PeerHandle& peer)
 {
   _peer = peer;
 }
+
+} // namespace aria2
diff --git a/src/DefaultExtensionMessageFactory.h b/src/DefaultExtensionMessageFactory.h
index 71c780a5..0912c80e 100644
--- a/src/DefaultExtensionMessageFactory.h
+++ b/src/DefaultExtensionMessageFactory.h
@@ -37,34 +37,38 @@
 
 #include "ExtensionMessageFactory.h"
 
+namespace aria2 {
+
 class BtContext;
-typedef SharedHandle<BtContext> BtContextHandle;
 class Peer;
-typedef SharedHandle<Peer> PeerHandle;
 class Logger;
 
 class DefaultExtensionMessageFactory:public ExtensionMessageFactory {
 private:
-  BtContextHandle _btContext;
+  SharedHandle<BtContext> _btContext;
 
-  PeerHandle _peer;
+  SharedHandle<Peer> _peer;
 
   const Logger* _logger;
 
 public:
   DefaultExtensionMessageFactory();
 
-  DefaultExtensionMessageFactory(const BtContextHandle& btContext,
-				 const PeerHandle& peer);
+  DefaultExtensionMessageFactory(const SharedHandle<BtContext>& btContext,
+				 const SharedHandle<Peer>& peer);
 
   virtual ~DefaultExtensionMessageFactory();
 
-  virtual ExtensionMessageHandle createMessage(const char* data, size_t length);
+  virtual SharedHandle<ExtensionMessage>
+  createMessage(const char* data, size_t length);
 
-  void setBtContext(const BtContextHandle& btContext);
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  void setPeer(const PeerHandle& peer);
+  void setPeer(const SharedHandle<Peer>& peer);
 };
 
 typedef SharedHandle<DefaultExtensionMessageFactory> DefaultExtensionMessageFactoryHandle;
+
+} // namespace aria2
+
 #endif // _D_DEFAULT_EXTENSION_MESSAGE_FACTORY_H_
diff --git a/src/DefaultPeerListProcessor.cc b/src/DefaultPeerListProcessor.cc
index ea8eeaca..d7660e2d 100644
--- a/src/DefaultPeerListProcessor.cc
+++ b/src/DefaultPeerListProcessor.cc
@@ -33,10 +33,19 @@
  */
 /* copyright --> */
 #include "DefaultPeerListProcessor.h"
+#include "Peer.h"
 #include "List.h"
 #include "Dictionary.h"
 #include "Data.h"
 
+namespace aria2 {
+
+DefaultPeerListProcessor::DefaultPeerListProcessor(int32_t pieceLength, int64_t totalLength):
+  pieceLength(pieceLength),
+  totalLength(totalLength) {}
+
+DefaultPeerListProcessor::~DefaultPeerListProcessor() {}
+
 bool DefaultPeerListProcessor::canHandle(const MetaEntry* peersEntry) const {
   const List* peersList = dynamic_cast<const List*>(peersEntry);
   return peersList != 0;
@@ -48,8 +57,8 @@ Peers DefaultPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
   if(!peersList) {
     return peers;
   }
-  const MetaList& metaList = peersList->getList();
-  for(MetaList::const_iterator itr = metaList.begin();
+  const std::deque<MetaEntry*>& metaList = peersList->getList();
+  for(std::deque<MetaEntry*>::const_iterator itr = metaList.begin();
       itr != metaList.end(); itr++) {
     const Dictionary* peerDic = dynamic_cast<const Dictionary*>(*itr);
     if(!peerDic) {
@@ -65,3 +74,5 @@ Peers DefaultPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
   }
   return peers;
 }
+
+} // namespace aria2
diff --git a/src/DefaultPeerListProcessor.h b/src/DefaultPeerListProcessor.h
index 223322d0..5a172500 100644
--- a/src/DefaultPeerListProcessor.h
+++ b/src/DefaultPeerListProcessor.h
@@ -37,20 +37,23 @@
 
 #include "PeerListProcessor.h"
 
+namespace aria2 {
+
 class DefaultPeerListProcessor : public PeerListProcessor {
 private:
   int32_t pieceLength;
   int64_t totalLength;
 public:
-  DefaultPeerListProcessor(int32_t pieceLength, int64_t totalLength)
-  :pieceLength(pieceLength),
-   totalLength(totalLength) {}
+  DefaultPeerListProcessor(int32_t pieceLength, int64_t totalLength);
 
-  virtual ~DefaultPeerListProcessor() {}
+  virtual ~DefaultPeerListProcessor();
 
-  virtual Peers extractPeer(const MetaEntry* peersEntry);
+  virtual std::deque<SharedHandle<Peer> >
+  extractPeer(const MetaEntry* peersEntry);
 
   virtual bool canHandle(const MetaEntry* peersEntry) const;
 };
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_PEER_LIST_PROCESSOR_H_
diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc
index 65dbf7b5..a00409c1 100644
--- a/src/DefaultPeerStorage.cc
+++ b/src/DefaultPeerStorage.cc
@@ -34,11 +34,18 @@
 /* copyright --> */
 #include "DefaultPeerStorage.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "BtRegistry.h"
 #include "message.h"
 #include "a2time.h"
+#include "Peer.h"
+#include "BtContext.h"
+#include "BtRuntime.h"
+#include <algorithm>
 
-DefaultPeerStorage::DefaultPeerStorage(BtContextHandle btContext,
+namespace aria2 {
+
+DefaultPeerStorage::DefaultPeerStorage(const BtContextHandle& btContext,
 				       const Option* option):
   btContext(btContext),
   option(option),
@@ -66,7 +73,7 @@ public:
 
 bool DefaultPeerStorage::isPeerAlreadyAdded(const PeerHandle& peer)
 {
-  return find_if(peers.begin(), peers.end(), FindIdenticalPeer(peer)) != peers.end();
+  return std::find_if(peers.begin(), peers.end(), FindIdenticalPeer(peer)) != peers.end();
 }
 
 bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
@@ -104,8 +111,8 @@ public:
 };
 
 PeerHandle DefaultPeerStorage::getUnusedPeer() {
-  Peers::const_iterator itr = find_if(peers.begin(), peers.end(),
-				      FindFinePeer());
+  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
+					   FindFinePeer());
   if(itr == peers.end()) {
     return 0;
   } else {
@@ -115,20 +122,20 @@ PeerHandle DefaultPeerStorage::getUnusedPeer() {
 
 class FindPeer {
 private:
-  string ipaddr;
+  std::string ipaddr;
   int32_t port;
 public:
-  FindPeer(const string& ipaddr, int32_t port):ipaddr(ipaddr), port(port) {}
+  FindPeer(const std::string& ipaddr, int32_t port):ipaddr(ipaddr), port(port) {}
 
   bool operator()(const PeerHandle& peer) const {
     return ipaddr == peer->ipaddr && port == peer->port;
   }
 };
 
-PeerHandle DefaultPeerStorage::getPeer(const string& ipaddr,
+PeerHandle DefaultPeerStorage::getPeer(const std::string& ipaddr,
 				       int32_t port) const {
-  Peers::const_iterator itr = find_if(peers.begin(), peers.end(),
-				      FindPeer(ipaddr, port));
+  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
+					   FindPeer(ipaddr, port));
   if(itr == peers.end()) {
     return 0;
   } else {
@@ -159,7 +166,7 @@ public:
 };
 
 Peers DefaultPeerStorage::getActivePeers() {
-  return for_each(peers.begin(), peers.end(), CollectActivePeer()).getActivePeers();
+  return std::for_each(peers.begin(), peers.end(), CollectActivePeer()).getActivePeers();
 }
 
 class CalculateStat {
@@ -186,7 +193,7 @@ public:
 };
 
 TransferStat DefaultPeerStorage::calculateStat() {
-  TransferStat stat = for_each(peers.begin(), peers.end(), CalculateStat()).getTransferStat();
+  TransferStat stat = std::for_each(peers.begin(), peers.end(), CalculateStat()).getTransferStat();
   stat.sessionDownloadLength += removedPeerSessionDownloadLength;
   stat.sessionUploadLength += removedPeerSessionUploadLength;
   stat.setAllTimeUploadLength(btRuntime->getUploadLengthAtStartup()+
@@ -218,7 +225,7 @@ void DefaultPeerStorage::onErasingPeer(const PeerHandle& peer)
 
 void DefaultPeerStorage::returnPeer(const PeerHandle& peer)
 {
-  Peers::iterator itr = find(peers.begin(), peers.end(), peer);
+  Peers::iterator itr = std::find(peers.begin(), peers.end(), peer);
   if(itr == peers.end()) {
     logger->debug("Cannot find peer %s:%u in PeerStorage.", peer->ipaddr.c_str(), peer->port);
   } else {
@@ -233,3 +240,5 @@ void DefaultPeerStorage::returnPeer(const PeerHandle& peer)
     }
   }
 }
+
+} // namespace aria2
diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h
index c2b5d49f..ae4d52ec 100644
--- a/src/DefaultPeerStorage.h
+++ b/src/DefaultPeerStorage.h
@@ -36,54 +36,60 @@
 #define _D_DEFAULT_PEER_STORAGE_H_
 
 #include "PeerStorage.h"
-#include "BtContext.h"
-#include "Option.h"
-#include "Logger.h"
-#include "BtRuntime.h"
+
+namespace aria2 {
 
 #define MAX_PEER_LIST_SIZE 60
 #define MAX_PEER_ERROR 5
 
+class BtContext;
+class Option;
+class Logger;
+class BtRuntime;
+
 class DefaultPeerStorage : public PeerStorage {
 private:
-  BtContextHandle btContext;
+  SharedHandle<BtContext> btContext;
   const Option* option;
-  Peers peers;
+  std::deque<SharedHandle<Peer> > peers;
   int32_t maxPeerListSize;
   Logger* logger;
-  BtRuntimeHandle btRuntime;
+  SharedHandle<BtRuntime> btRuntime;
   int64_t removedPeerSessionDownloadLength;
   int64_t removedPeerSessionUploadLength;
 
-  bool isPeerAlreadyAdded(const PeerHandle& peer);
+  bool isPeerAlreadyAdded(const SharedHandle<Peer>& peer);
 public:
-  DefaultPeerStorage(BtContextHandle btContext, const Option* option);
+  DefaultPeerStorage(const SharedHandle<BtContext>& btContext,
+		     const Option* option);
+
   virtual ~DefaultPeerStorage();
 
-  void setBtRuntime(const BtRuntimeHandle& btRuntime) {
+  void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) {
     this->btRuntime = btRuntime;
   }
-  BtRuntimeHandle getBtRuntime() const { return btRuntime; }
 
-  virtual bool addPeer(const PeerHandle& peer);
+  SharedHandle<BtRuntime> getBtRuntime() const { return btRuntime; }
+
+  virtual bool addPeer(const SharedHandle<Peer>& peer);
 
   int32_t countPeer() const;
 
-  virtual PeerHandle getUnusedPeer();
+  virtual SharedHandle<Peer> getUnusedPeer();
 
-  PeerHandle getPeer(const string& ipaddr, int32_t port) const;
+  SharedHandle<Peer> getPeer(const std::string& ipaddr, int32_t port) const;
 
-  virtual void addPeer(const Peers& peers);
+  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers);
 
-  virtual const Peers& getPeers();
+  virtual const std::deque<SharedHandle<Peer> >& getPeers();
 
   virtual bool isPeerAvailable();
 
-  virtual Peers getActivePeers();
+  virtual std::deque<SharedHandle<Peer> > getActivePeers();
 
   virtual TransferStat calculateStat();
 
-  virtual void returnPeer(const PeerHandle& peer);
+  virtual void returnPeer(const SharedHandle<Peer>& peer);
 
   void setMaxPeerListSize(int32_t size) { this->maxPeerListSize = size; }
  
@@ -91,7 +97,9 @@ public:
 
   void deleteUnusedPeer(int32_t delSize);
   
-  void onErasingPeer(const PeerHandle& peer);
+  void onErasingPeer(const SharedHandle<Peer>& peer);
 };
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_PEER_STORAGE_H_
diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc
index 36128da5..75ddf769 100644
--- a/src/DefaultPieceStorage.cc
+++ b/src/DefaultPieceStorage.cc
@@ -37,18 +37,25 @@
 #include "Piece.h"
 #include "Peer.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "prefs.h"
 #include "DirectDiskAdaptor.h"
 #include "MultiDiskAdaptor.h"
 #include "CopyDiskAdaptor.h"
 #include "DiskWriter.h"
 #include "BitfieldManFactory.h"
+#include "BitfieldMan.h"
 #include "message.h"
 #include "DefaultDiskWriterFactory.h"
+#include "FileEntry.h"
 #include "DlAbortEx.h"
 #include "Util.h"
 #include "a2functional.h"
+#include "Option.h"
 #include <numeric>
+#include <algorithm>
+
+namespace aria2 {
 
 DefaultPieceStorage::DefaultPieceStorage(const DownloadContextHandle& downloadContext, const Option* option):
   downloadContext(downloadContext),
@@ -147,9 +154,9 @@ public:
 
 PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const
 {
-  Pieces::const_iterator itr = find_if(usedPieces.begin(),
-				       usedPieces.end(),
-				       FindPiece(index));
+  Pieces::const_iterator itr = std::find_if(usedPieces.begin(),
+					    usedPieces.end(),
+					    FindPiece(index));
   if(itr == usedPieces.end()) {
     return 0;
   } else {
@@ -169,7 +176,7 @@ int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer)
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
     BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
 			     bitfieldMan->getTotalLength());
-    for(Integers::const_iterator itr = peer->getPeerAllowedIndexSet().begin();
+    for(std::deque<int32_t>::const_iterator itr = peer->getPeerAllowedIndexSet().begin();
 	itr != peer->getPeerAllowedIndexSet().end(); itr++) {
       if(!bitfieldMan->isBitSet(index) && peer->hasPiece(*itr)) {
 	tempBitfield.setBit(*itr);
@@ -241,7 +248,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
   if(piece.isNull()) {
     return;
   }
-  Pieces::iterator itr = find(usedPieces.begin(), usedPieces.end(), piece);
+  Pieces::iterator itr = std::find(usedPieces.begin(), usedPieces.end(), piece);
   if(itr != usedPieces.end()) {
     usedPieces.erase(itr);
   }
@@ -370,17 +377,17 @@ int64_t DefaultPieceStorage::getFilteredCompletedLength()
 
 int32_t DefaultPieceStorage::getInFlightPieceCompletedLength() const
 {
-  return accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(plus<int32_t>(), mem_fun_sh(&Piece::getCompletedLength)));
+  return std::accumulate(usedPieces.begin(), usedPieces.end(), 0, adopt2nd(std::plus<int32_t>(), mem_fun_sh(&Piece::getCompletedLength)));
 }
 
 // not unittested
-void DefaultPieceStorage::setFileFilter(const Strings& filePaths)
+void DefaultPieceStorage::setFileFilter(const std::deque<std::string>& filePaths)
 {
   if(downloadContext->getFileMode() != DownloadContext::MULTI || filePaths.empty()) {
     return;
   }
   diskAdaptor->removeAllDownloadEntry();
-  for(Strings::const_iterator pitr = filePaths.begin();
+  for(std::deque<std::string>::const_iterator pitr = filePaths.begin();
       pitr != filePaths.end(); pitr++) {
     if(!diskAdaptor->addDownloadEntry(*pitr)) {
       throw new DlAbortEx(EX_NO_SUCH_FILE_ENTRY, (*pitr).c_str());
@@ -393,14 +400,14 @@ void DefaultPieceStorage::setFileFilter(const Strings& filePaths)
 
 void DefaultPieceStorage::setFileFilter(IntSequence seq)
 {
-  Integers fileIndexes = seq.flush();
+  std::deque<int32_t> fileIndexes = seq.flush();
   // TODO Is sorting necessary?
-  sort(fileIndexes.begin(), fileIndexes.end());
-  fileIndexes.erase(unique(fileIndexes.begin(), fileIndexes.end()), fileIndexes.end());
-  Strings filePaths;
+  std::sort(fileIndexes.begin(), fileIndexes.end());
+  fileIndexes.erase(std::unique(fileIndexes.begin(), fileIndexes.end()), fileIndexes.end());
+  std::deque<std::string> filePaths;
   const FileEntries& entries = diskAdaptor->getFileEntries();
   for(int32_t i = 0; i < (int32_t)entries.size(); i++) {
-    if(find(fileIndexes.begin(), fileIndexes.end(), i+1) != fileIndexes.end()) {
+    if(std::find(fileIndexes.begin(), fileIndexes.end(), i+1) != fileIndexes.end()) {
       logger->debug("index=%d is %s", i+1, entries[i]->getPath().c_str());
       filePaths.push_back(entries[i]->getPath());
     }
@@ -497,10 +504,10 @@ void DefaultPieceStorage::advertisePiece(int32_t cuid, int32_t index)
   haves.push_front(entry);
 }
 
-Integers DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
+std::deque<int32_t> DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid,
 							const Time& lastCheckTime)
 {
-  Integers indexes;
+  std::deque<int32_t> indexes;
   for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
     const Haves::value_type& have = *itr;
     if(have.getCuid() == myCuid) {
@@ -533,7 +540,7 @@ public:
 void DefaultPieceStorage::removeAdvertisedPiece(int32_t elapsed)
 {
   Haves::iterator itr =
-    find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
+    std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
   if(itr != haves.end()) {
     logger->debug(MSG_REMOVED_HAVE_ENTRY, haves.end()-itr);
     haves.erase(itr, haves.end());
@@ -589,3 +596,5 @@ void DefaultPieceStorage::setDiskWriterFactory(const DiskWriterFactoryHandle& di
 {
   _diskWriterFactory = diskWriterFactory;
 }
+
+} // namespace aria2
diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h
index 5832ac48..0f14505d 100644
--- a/src/DefaultPieceStorage.h
+++ b/src/DefaultPieceStorage.h
@@ -37,16 +37,14 @@
 
 #include "PieceStorage.h"
 
+namespace aria2 {
+
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class BitfieldMan;
 class Logger;
 class Option;
-typedef deque<PieceHandle> Pieces;
 class DiskWriterFactory;
-typedef SharedHandle<DiskWriterFactory> DiskWriterFactoryHandle;
 class FileEntry;
-typedef SharedHandle<FileEntry> FileEntryHandle;
 
 #define END_GAME_PIECE_NUM 20
 
@@ -67,50 +65,50 @@ public:
   const Time& getRegisteredTime() const { return registeredTime; }
 };
 
-typedef deque<HaveEntry> Haves;
+typedef std::deque<HaveEntry> Haves;
 
 class DefaultPieceStorage : public PieceStorage {
 private:
-  DownloadContextHandle downloadContext;
+  SharedHandle<DownloadContext> downloadContext;
   BitfieldMan* bitfieldMan;
-  DiskAdaptorHandle diskAdaptor;
-  DiskWriterFactoryHandle _diskWriterFactory;
-  Pieces usedPieces;
+  SharedHandle<DiskAdaptor> diskAdaptor;
+  SharedHandle<DiskWriterFactory> _diskWriterFactory;
+  std::deque<SharedHandle<Piece> > usedPieces;
   int32_t endGamePieceNum;
   Logger* logger;
   const Option* option;
   Haves haves;
 
-  int32_t getMissingPieceIndex(const PeerHandle& peer);
-  int32_t getMissingFastPieceIndex(const PeerHandle& peer);
-  PieceHandle checkOutPiece(int32_t index);
+  int32_t getMissingPieceIndex(const SharedHandle<Peer>& peer);
+  int32_t getMissingFastPieceIndex(const SharedHandle<Peer>& peer);
+  SharedHandle<Piece> checkOutPiece(int32_t index);
   int32_t deleteUsedPiecesByFillRate(int32_t fillRate, int32_t toDelete);
   void reduceUsedPieces(int32_t delMax);
-  void deleteUsedPiece(const PieceHandle& piece);
-  PieceHandle findUsedPiece(int32_t index) const;
+  void deleteUsedPiece(const SharedHandle<Piece>& piece);
+  SharedHandle<Piece> findUsedPiece(int32_t index) const;
 
   int32_t getInFlightPieceCompletedLength() const;
 
 public:
-  DefaultPieceStorage(const DownloadContextHandle& downloadContext, const Option* option);
+  DefaultPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option);
   virtual ~DefaultPieceStorage();
 
-  virtual bool hasMissingPiece(const PeerHandle& peer);
+  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer);
 
-  virtual PieceHandle getMissingPiece(const PeerHandle& peer);
+  virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer);
 
-  virtual PieceHandle getMissingFastPiece(const PeerHandle& peer);
+  virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer);
 
-  virtual PieceHandle getMissingPiece();
-  virtual PieceHandle getMissingPiece(const FileEntryHandle& fileEntry);
+  virtual SharedHandle<Piece> getMissingPiece();
+  virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<FileEntry>& fileEntry);
 
-  virtual PieceHandle getMissingPiece(int32_t index);
+  virtual SharedHandle<Piece> getMissingPiece(int32_t index);
 
-  virtual PieceHandle getPiece(int32_t index);
+  virtual SharedHandle<Piece> getPiece(int32_t index);
 
-  virtual void completePiece(const PieceHandle& piece);
+  virtual void completePiece(const SharedHandle<Piece>& piece);
 
-  virtual void cancelPiece(const PieceHandle& piece);
+  virtual void cancelPiece(const SharedHandle<Piece>& piece);
 
   virtual bool hasPiece(int32_t index);
 
@@ -126,7 +124,7 @@ public:
 
   virtual void initStorage();
 
-  virtual void setFileFilter(const Strings& filePaths);
+  virtual void setFileFilter(const std::deque<std::string>& filePaths);
 
   virtual void setFileFilter(IntSequence seq);
 
@@ -157,14 +155,14 @@ public:
 
   virtual bool isEndGame();
   
-  virtual DiskAdaptorHandle getDiskAdaptor();
+  virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
 
   virtual int32_t getPieceLength(int32_t index);
 
   virtual void advertisePiece(int32_t cuid, int32_t index);
 
-  virtual Integers getAdvertisedPieceIndexes(int32_t myCuid,
-					     const Time& lastCheckTime);
+  virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid,
+							const Time& lastCheckTime);
 
   virtual void removeAdvertisedPiece(int32_t elapsed);
 
@@ -174,20 +172,22 @@ public:
 
   virtual void markPieceMissing(int32_t index);
 
-  virtual void addInFlightPiece(const Pieces& pieces);
+  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
 
   virtual int32_t countInFlightPiece();
 
-  virtual Pieces getInFlightPieces();
+  virtual std::deque<SharedHandle<Piece> > getInFlightPieces();
 
   /**
    * This method is made private for test purpose only.
    */
-  void addUsedPiece(const PieceHandle& piece);
+  void addUsedPiece(const SharedHandle<Piece>& piece);
 
-  void setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory);
+  void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
 };
 
 typedef SharedHandle<DefaultPieceStorage> DefaultPieceStorageHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_PIECE_STORAGE_H_
diff --git a/src/DefaultSegmentManFactory.cc b/src/DefaultSegmentManFactory.cc
index 00d66e9a..a9bb6df2 100644
--- a/src/DefaultSegmentManFactory.cc
+++ b/src/DefaultSegmentManFactory.cc
@@ -33,11 +33,17 @@
  */
 /* copyright --> */
 #include "DefaultSegmentManFactory.h"
-#include "prefs.h"
+#include "DownloadContext.h"
+#include "PieceStorage.h"
 #include "DefaultDiskWriter.h"
+#include "SegmentMan.h"
+#include "prefs.h"
 
-SegmentManHandle DefaultSegmentManFactory::createNewInstance(const DownloadContextHandle& dctx,
-							     const PieceStorageHandle& ps)
+namespace aria2 {
+
+SegmentManHandle
+DefaultSegmentManFactory::createNewInstance(const DownloadContextHandle& dctx,
+					    const PieceStorageHandle& ps)
 {
   SegmentManHandle segmentMan = new SegmentMan(_option, dctx, ps);
   //segmentMan->diskWriter = new DefaultDiskWriter();
@@ -47,3 +53,5 @@ SegmentManHandle DefaultSegmentManFactory::createNewInstance(const DownloadConte
   //segmentMan->option = _option;
   return segmentMan;
 }
+
+} // namespace aria2
diff --git a/src/DefaultSegmentManFactory.h b/src/DefaultSegmentManFactory.h
index e09d1b29..f2da752c 100644
--- a/src/DefaultSegmentManFactory.h
+++ b/src/DefaultSegmentManFactory.h
@@ -37,16 +37,21 @@
 
 #include "AbstractSegmentManFactory.h"
 
+namespace aria2 {
+
 class DefaultSegmentManFactory : public AbstractSegmentManFactory {
 public:
   DefaultSegmentManFactory(const Option* option):AbstractSegmentManFactory(option) {}
 
   virtual ~DefaultSegmentManFactory() {}
 
-  virtual SegmentManHandle createNewInstance(const DownloadContextHandle& dc,
-					     const PieceStorageHandle& ps);
+  virtual SharedHandle<SegmentMan>
+  createNewInstance(const SharedHandle<DownloadContext>& dc,
+		    const SharedHandle<PieceStorage>& ps);
 };
 
 typedef SharedHandle<DefaultSegmentManFactory> DefaultSegmentManFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_DEFAULT_SEGMENT_MAN_FACTORY_H_
diff --git a/src/DelegatingPeerListProcessor.cc b/src/DelegatingPeerListProcessor.cc
index 38f9395c..77e21581 100644
--- a/src/DelegatingPeerListProcessor.cc
+++ b/src/DelegatingPeerListProcessor.cc
@@ -32,10 +32,25 @@
  */
 /* copyright --> */
 #include "DelegatingPeerListProcessor.h"
+#include "DefaultPeerListProcessor.h"
+#include "CompactPeerListProcessor.h"
+#include "Peer.h"
+
+namespace aria2 {
+
+DelegatingPeerListProcessor::DelegatingPeerListProcessor(int32_t pieceLength, int64_t totalLength):
+  pieceLength(pieceLength),
+  totalLength(totalLength)
+{
+  processors.push_back(new DefaultPeerListProcessor(pieceLength, totalLength));
+  processors.push_back(new CompactPeerListProcessor(pieceLength, totalLength));
+}
+
+DelegatingPeerListProcessor::~DelegatingPeerListProcessor() {}
 
 Peers DelegatingPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
   Peers peers;
-  for(PeerListProcessors::iterator itr = processors.begin();
+  for(std::deque<SharedHandle<PeerListProcessor> >::iterator itr = processors.begin();
       itr != processors.end(); itr++) {
     PeerListProcessorHandle processor = *itr;
     if(processor->canHandle(peersEntry)) {
@@ -48,7 +63,7 @@ Peers DelegatingPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
 }
 
 bool DelegatingPeerListProcessor::canHandle(const MetaEntry* peersEntry) const {
-  for(PeerListProcessors::const_iterator itr = processors.begin();
+  for(std::deque<SharedHandle<PeerListProcessor> >::const_iterator itr = processors.begin();
       itr != processors.end(); itr++) {
     if((*itr)->canHandle(peersEntry)) {
       return true;
@@ -56,3 +71,5 @@ bool DelegatingPeerListProcessor::canHandle(const MetaEntry* peersEntry) const {
   }
   return false;
 }
+
+} // namespace aria2
diff --git a/src/DelegatingPeerListProcessor.h b/src/DelegatingPeerListProcessor.h
index a0688641..f5aeae25 100644
--- a/src/DelegatingPeerListProcessor.h
+++ b/src/DelegatingPeerListProcessor.h
@@ -35,29 +35,25 @@
 #define _D_DELEGATING_PEER_LIST_PROCESSOR_H_
 
 #include "PeerListProcessor.h"
-#include "DefaultPeerListProcessor.h"
-#include "CompactPeerListProcessor.h"
 
-typedef deque<PeerListProcessorHandle> PeerListProcessors;
+namespace aria2 {
 
 class DelegatingPeerListProcessor : public PeerListProcessor {
 private:
   int32_t pieceLength;
   int64_t totalLength;
-  PeerListProcessors processors;
+  std::deque<SharedHandle<PeerListProcessor> > processors;
 public:
-  DelegatingPeerListProcessor(int32_t pieceLength, int64_t totalLength)
-  :pieceLength(pieceLength),
-   totalLength(totalLength) {
-    processors.push_back(new DefaultPeerListProcessor(pieceLength, totalLength));
-    processors.push_back(new CompactPeerListProcessor(pieceLength, totalLength));
-  }
+  DelegatingPeerListProcessor(int32_t pieceLength, int64_t totalLength);
 
-  virtual ~DelegatingPeerListProcessor() {}
+  virtual ~DelegatingPeerListProcessor();
 
-  virtual Peers extractPeer(const MetaEntry* peersEntry);
+  virtual std::deque<SharedHandle<Peer> >
+  extractPeer(const MetaEntry* peersEntry);
 
   virtual bool canHandle(const MetaEntry* peersEntry) const;
 };
 
+} // namespace aria2
+
 #endif // _D_DELEGATING_PEER_LIST_PROCESSOR_H_
diff --git a/src/Dependency.h b/src/Dependency.h
index 0851f66c..d08ad925 100644
--- a/src/Dependency.h
+++ b/src/Dependency.h
@@ -36,6 +36,9 @@
 #define _D_DEPENDENCY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class Dependency {
 public:
@@ -46,4 +49,6 @@ public:
 
 typedef SharedHandle<Dependency> DependencyHandle;
 
+} // namespace aria2
+
 #endif // _D_DEPENDENCY_H_
diff --git a/src/Dictionary.cc b/src/Dictionary.cc
index 821753dc..81a4b484 100644
--- a/src/Dictionary.cc
+++ b/src/Dictionary.cc
@@ -35,6 +35,8 @@
 #include "Dictionary.h"
 #include "MetaEntryVisitor.h"
 
+namespace aria2 {
+
 Dictionary::Dictionary() {}
 
 Dictionary::~Dictionary() {
@@ -42,13 +44,14 @@ Dictionary::~Dictionary() {
 }
 
 void Dictionary::clearTable() {
-  for(MetaTable::iterator itr = table.begin(); itr != table.end(); itr++) {
+  for(std::map<std::string, MetaEntry*>::iterator itr = table.begin();
+      itr != table.end(); itr++) {
     delete itr->second;
   }
 }
 
-const MetaEntry* Dictionary::get(const string& name) const {
-  MetaTable::const_iterator itr = table.find(name);
+const MetaEntry* Dictionary::get(const std::string& name) const {
+  std::map<std::string, MetaEntry*>::const_iterator itr = table.find(name);
   if(itr == table.end()) {
     return NULL;
   } else {
@@ -56,12 +59,12 @@ const MetaEntry* Dictionary::get(const string& name) const {
   }
 }
 
-void Dictionary::put(const string& name, MetaEntry* entry) {
+void Dictionary::put(const std::string& name, MetaEntry* entry) {
   table[name] = entry;
   order.push_back(name);
 }
 
-void Dictionary::remove(const string& name)
+void Dictionary::remove(const std::string& name)
 {
   table.erase(name);
   order.erase(std::remove(order.begin(), order.end(), name), order.end());
@@ -71,6 +74,8 @@ void Dictionary::accept(MetaEntryVisitor* v) const {
   v->visit(this);
 }
 
-const Order& Dictionary::getOrder() const {
+const std::deque<std::string>& Dictionary::getOrder() const {
   return order;
 }
+
+} // namespace aria2
diff --git a/src/Dictionary.h b/src/Dictionary.h
index 85c56d04..a8e4cfd9 100644
--- a/src/Dictionary.h
+++ b/src/Dictionary.h
@@ -40,27 +40,26 @@
 #include <deque>
 #include <string>
 
-using namespace std;
-
-typedef map<string, MetaEntry*> MetaTable;
-typedef deque<string> Order;
+namespace aria2 {
 
 class Dictionary : public MetaEntry {
 private:
-  MetaTable table;
-  Order order;
+  std::map<std::string, MetaEntry*> table;
+  std::deque<std::string> order;
   void clearTable();
 public:
   Dictionary();
   ~Dictionary();
 
-  const MetaEntry* get(const string& name) const;
-  void put(const string& name, MetaEntry* entry);
-  void remove(const string& name);
+  const MetaEntry* get(const std::string& name) const;
+  void put(const std::string& name, MetaEntry* entry);
+  void remove(const std::string& name);
 
   void accept(MetaEntryVisitor* v) const;
-  const Order& getOrder() const;
+  const std::deque<std::string>& getOrder() const;
   
 };
 
+} // namespace aria2
+
 #endif // _D_DICTIONARY_H_
diff --git a/src/DirectDiskAdaptor.cc b/src/DirectDiskAdaptor.cc
index 25fe58ab..8fb8a123 100644
--- a/src/DirectDiskAdaptor.cc
+++ b/src/DirectDiskAdaptor.cc
@@ -33,8 +33,11 @@
  */
 /* copyright --> */
 #include "DirectDiskAdaptor.h"
+#include "FileEntry.h"
 
-string DirectDiskAdaptor::getFilePath()
+namespace aria2 {
+
+std::string DirectDiskAdaptor::getFilePath()
 {
   return storeDir+"/"+fileEntries.front()->getPath();
 }
@@ -44,3 +47,5 @@ void DirectDiskAdaptor::onDownloadComplete()
   closeFile();
   openFile();
 }
+
+} // namespace aria2
diff --git a/src/DirectDiskAdaptor.h b/src/DirectDiskAdaptor.h
index 16b01f36..f8458a4d 100644
--- a/src/DirectDiskAdaptor.h
+++ b/src/DirectDiskAdaptor.h
@@ -37,16 +37,20 @@
 
 #include "AbstractSingleDiskAdaptor.h"
 
+namespace aria2 {
+
 class DirectDiskAdaptor : public AbstractSingleDiskAdaptor {
 public:
   DirectDiskAdaptor() {};
   virtual ~DirectDiskAdaptor() {};
 
-  virtual string getFilePath();
+  virtual std::string getFilePath();
 
   virtual void onDownloadComplete();
 };
 
 typedef SharedHandle<DirectDiskAdaptor> DirectDiskAdaptorHandle;
 
+} // namespace aria2
+
 #endif // _D_DIRECT_DISK_ADAPTOR_H_
diff --git a/src/DiskAdaptor.cc b/src/DiskAdaptor.cc
index 9dd62418..2a9ccec8 100644
--- a/src/DiskAdaptor.cc
+++ b/src/DiskAdaptor.cc
@@ -33,15 +33,19 @@
  */
 /* copyright --> */
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "message.h"
 #include "DlAbortEx.h"
 
+namespace aria2 {
+
 DiskAdaptor::DiskAdaptor():logger(LogFactory::getInstance()) {}
 
 DiskAdaptor::~DiskAdaptor() {}
 
-FileEntryHandle DiskAdaptor::getFileEntryFromPath(const string& fileEntryPath) const
+FileEntryHandle DiskAdaptor::getFileEntryFromPath(const std::string& fileEntryPath) const
 {
   for(FileEntries::const_iterator itr = fileEntries.begin();
       itr != fileEntries.end(); itr++) {
@@ -52,7 +56,7 @@ FileEntryHandle DiskAdaptor::getFileEntryFromPath(const string& fileEntryPath) c
   throw new DlAbortEx(EX_NO_SUCH_FILE_ENTRY, fileEntryPath.c_str());
 }
 
-bool DiskAdaptor::addDownloadEntry(const string& fileEntryPath)
+bool DiskAdaptor::addDownloadEntry(const std::string& fileEntryPath)
 {
   for(FileEntries::iterator itr = fileEntries.begin();
       itr != fileEntries.end(); itr++) {
@@ -88,3 +92,14 @@ void DiskAdaptor::removeAllDownloadEntry()
     (*itr)->setRequested(false);
   }
 }
+
+void DiskAdaptor::setFileEntries(const FileEntries& fileEntries) {
+  this->fileEntries = fileEntries;
+}
+
+const FileEntries& DiskAdaptor::getFileEntries() const
+{
+  return fileEntries;
+}
+
+} // namespace aria2
diff --git a/src/DiskAdaptor.h b/src/DiskAdaptor.h
index 28a88a44..11c56c13 100644
--- a/src/DiskAdaptor.h
+++ b/src/DiskAdaptor.h
@@ -36,14 +36,19 @@
 #define _D_DISK_ADAPTOR_H_
 
 #include "BinaryStream.h"
-#include "FileEntry.h"
-#include "Logger.h"
-#include "FileAllocationIterator.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class FileEntry;
+class Logger;
+class FileAllocationIterator;
 
 class DiskAdaptor:public BinaryStream {
 protected:
-  string storeDir;
-  FileEntries fileEntries;
+  std::string storeDir;
+  std::deque<SharedHandle<FileEntry> > fileEntries;
   const Logger* logger;
 public:
   DiskAdaptor();
@@ -61,22 +66,20 @@ public:
 
   virtual bool fileExists() = 0;
 
-  virtual string getFilePath() = 0;
+  virtual std::string getFilePath() = 0;
 
   virtual int64_t size() const = 0;
 
   // optional behavior
   virtual void truncate(int64_t length) {}
 
-  void setFileEntries(const FileEntries& fileEntries) {
-    this->fileEntries = fileEntries;
-  }
+  void setFileEntries(const std::deque<SharedHandle<FileEntry> >& fileEntries);
 
-  FileEntryHandle getFileEntryFromPath(const string& fileEntryPath) const;
+  SharedHandle<FileEntry> getFileEntryFromPath(const std::string& fileEntryPath) const;
 
-  const FileEntries& getFileEntries() const { return fileEntries; }
+  const std::deque<SharedHandle<FileEntry> >& getFileEntries() const;
 
-  bool addDownloadEntry(const string& fileEntryPath);
+  bool addDownloadEntry(const std::string& fileEntryPath);
 
   bool addDownloadEntry(int index);
 
@@ -84,11 +87,11 @@ public:
 
   void removeAllDownloadEntry();
 
-  void setStoreDir(const string& storeDir) { this->storeDir = storeDir; }
+  void setStoreDir(const std::string& storeDir) { this->storeDir = storeDir; }
 
-  const string& getStoreDir() const { return this->storeDir; }
+  const std::string& getStoreDir() const { return this->storeDir; }
 
-  virtual FileAllocationIteratorHandle fileAllocationIterator() = 0;
+  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator() = 0;
 
   virtual void enableDirectIO() {}
 
@@ -97,4 +100,6 @@ public:
 
 typedef SharedHandle<DiskAdaptor> DiskAdaptorHandle;
 
+} // namespace aria2
+
 #endif // _D_DISK_ADAPTOR_H_
diff --git a/src/DiskWriter.h b/src/DiskWriter.h
index 1b81e82f..fa6adbaf 100644
--- a/src/DiskWriter.h
+++ b/src/DiskWriter.h
@@ -37,6 +37,8 @@
 
 #include "BinaryStream.h"
 
+namespace aria2 {
+
 /**
  * Interface for writing to a binary stream of bytes.
  *
@@ -54,9 +56,9 @@ public:
    * If the file exists, then it is truncated to 0 length.
    * @param filename the file name to be opened.
    */
-  virtual void initAndOpenFile(const string& filename, int64_t totalLength = 0)  = 0;
+  virtual void initAndOpenFile(const std::string& filename, int64_t totalLength = 0)  = 0;
   
-  virtual void openFile(const string& filename, int64_t totalLength = 0) = 0;
+  virtual void openFile(const std::string& filename, int64_t totalLength = 0) = 0;
 
   /**
    * Closes this output stream.
@@ -70,7 +72,7 @@ public:
    *
    * @param filename the file name to be opened.
    */
-  virtual void openExistingFile(const string& filename, int64_t totalLength = 0) = 0;
+  virtual void openExistingFile(const std::string& filename, int64_t totalLength = 0) = 0;
 
   virtual void truncate(int64_t length) = 0;
 
@@ -94,4 +96,6 @@ public:
 
 typedef SharedHandle<DiskWriter> DiskWriterHandle;
 
+} // namespace aria2
+
 #endif // _D_DISK_WRITER_H_
diff --git a/src/DiskWriterFactory.h b/src/DiskWriterFactory.h
index 07611bc0..ffedd667 100644
--- a/src/DiskWriterFactory.h
+++ b/src/DiskWriterFactory.h
@@ -36,15 +36,21 @@
 #define _D_DISK_WRITER_FACTORY_H_
 
 #include "common.h"
-#include "DiskWriter.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class DiskWriter;
 
 class DiskWriterFactory {
 public:
   virtual ~DiskWriterFactory() {}
 
-  virtual DiskWriterHandle newDiskWriter() = 0;
+  virtual SharedHandle<DiskWriter> newDiskWriter() = 0;
 };
 
 typedef SharedHandle<DiskWriterFactory> DiskWriterFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_DISK_WRITER_FACTORY_H_
diff --git a/src/DlAbortEx.h b/src/DlAbortEx.h
index 05f0ec59..3168ff77 100644
--- a/src/DlAbortEx.h
+++ b/src/DlAbortEx.h
@@ -36,6 +36,8 @@
 #define _D_DL_ABORT_EX_H_
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 class DlAbortEx : public RecoverableException {
 public:
   DlAbortEx(Exception* cause = 0):RecoverableException(cause) {}
@@ -43,16 +45,18 @@ public:
   DlAbortEx(const char* msg, ...) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 
   DlAbortEx(Exception* cause, const char* msg, ...):RecoverableException(cause) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DL_ABORT_EX_H_
diff --git a/src/DlRetryEx.h b/src/DlRetryEx.h
index b4d736bb..c896ae01 100644
--- a/src/DlRetryEx.h
+++ b/src/DlRetryEx.h
@@ -36,6 +36,8 @@
 #define _D_DL_RETRY_EX_H_
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 class DlRetryEx : public RecoverableException {
 public:
   DlRetryEx(Exception* cause = 0):RecoverableException(cause) {}
@@ -55,4 +57,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DL_RETRY_EX_H_
diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc
index 108d09dc..de8b4e34 100644
--- a/src/DownloadCommand.cc
+++ b/src/DownloadCommand.cc
@@ -33,31 +33,36 @@
  */
 /* copyright --> */
 #include "DownloadCommand.h"
-#include "SegmentMan.h"
+#include "Request.h"
+#include "RequestGroup.h"
+#include "DownloadEngine.h"
 #include "PeerStat.h"
 #include "TransferEncoding.h"
-#include "DownloadContext.h"
-#include "Util.h"
-#include "DlRetryEx.h"
 #include "DlAbortEx.h"
-#include "InitiateConnectionCommandFactory.h"
+#include "DlRetryEx.h"
+#include "SegmentMan.h"
+#include "Segment.h"
+#include "Logger.h"
+#include "ChecksumCheckIntegrityEntry.h"
+#include "PieceStorage.h"
+#include "CheckIntegrityCommand.h"
+#include "DiskAdaptor.h"
+#include "CUIDCounter.h"
+#include "DownloadContext.h"
+#include "Option.h"
+#include "Util.h"
+#include "Socket.h"
 #include "message.h"
 #include "prefs.h"
-#include "DiskAdaptor.h"
-#include "Segment.h"
-#include "PieceStorage.h"
-#include "Option.h"
-#include "HttpRequestCommand.h"
-#include "ChecksumCheckIntegrityEntry.h"
-#include "CheckIntegrityCommand.h"
-#include "CUIDCounter.h"
 #ifdef ENABLE_MESSAGE_DIGEST
 #include "MessageDigestHelper.h"
 #endif // ENABLE_MESSAGE_DIGEST
-#include <stdlib.h>
+#include <cassert>
+
+namespace aria2 {
 
 DownloadCommand::DownloadCommand(int cuid,
-				 const RequestHandle req,
+				 const RequestHandle& req,
 				 RequestGroup* requestGroup,
 				 DownloadEngine* e,
 				 const SocketHandle& s):
@@ -180,11 +185,11 @@ bool DownloadCommand::prepareForNextSegment() {
 void DownloadCommand::validatePieceHash(const SegmentHandle& segment)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
-  string expectedPieceHash =
+  std::string expectedPieceHash =
     _requestGroup->getDownloadContext()->getPieceHash(segment->getIndex());
   if(e->option->get(PREF_REALTIME_CHUNK_CHECKSUM) == V_TRUE &&
      !expectedPieceHash.empty()) {
-    string actualPieceHash =
+    std::string actualPieceHash =
       MessageDigestHelper::digest(_requestGroup->getDownloadContext()->getPieceHashAlgo(),
 				  _requestGroup->getPieceStorage()->getDiskAdaptor(),
 				  segment->getPosition(),
@@ -213,3 +218,5 @@ void DownloadCommand::setTransferDecoder(const TransferEncodingHandle& transferD
 {
   this->transferDecoder = transferDecoder;
 }
+
+} // namespace aria2
diff --git a/src/DownloadCommand.h b/src/DownloadCommand.h
index 24652351..0b7c436b 100644
--- a/src/DownloadCommand.h
+++ b/src/DownloadCommand.h
@@ -37,23 +37,23 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class TransferEncoding;
-typedef SharedHandle<TransferEncoding> TransferEncodingHandle;
 class PeerStat;
-typedef SharedHandle<PeerStat> PeerStatHandle;
 
 class DownloadCommand : public AbstractCommand {
 private:
   int32_t maxDownloadSpeedLimit;
   int32_t startupIdleTime;
   int32_t lowestDownloadSpeedLimit;
-  PeerStatHandle peerStat;
+  SharedHandle<PeerStat> peerStat;
 
-  void validatePieceHash(const SegmentHandle& segment);
+  void validatePieceHash(const SharedHandle<Segment>& segment);
 
   void checkLowestDownloadSpeed() const;
 protected:
-  TransferEncodingHandle transferDecoder;
+  SharedHandle<TransferEncoding> transferDecoder;
 
   virtual bool executeInternal();
 
@@ -61,13 +61,13 @@ protected:
 
 public:
   DownloadCommand(int cuid,
-		  const RequestHandle req,
+		  const SharedHandle<Request>& req,
 		  RequestGroup* requestGroup,
 		  DownloadEngine* e,
-		  const SocketHandle& s);
+		  const SharedHandle<SocketCore>& s);
   virtual ~DownloadCommand();
 
-  void setTransferDecoder(const TransferEncodingHandle& transferDecoder);
+  void setTransferDecoder(const SharedHandle<TransferEncoding>& transferDecoder);
 
   void setMaxDownloadSpeedLimit(int32_t maxDownloadSpeedLimit) {
     this->maxDownloadSpeedLimit = maxDownloadSpeedLimit;
@@ -82,4 +82,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_COMMAND_H_
diff --git a/src/DownloadContext.h b/src/DownloadContext.h
index 9d70af11..4fc8658d 100644
--- a/src/DownloadContext.h
+++ b/src/DownloadContext.h
@@ -36,12 +36,18 @@
 #define _D_DOWNLOAD_CONTEXT_H_
 
 #include "common.h"
-#include "FileEntry.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class FileEntry;
 
 class DownloadContext
 {
 protected:
-  string _dir;
+  std::string _dir;
 
 public:
   DownloadContext():_dir(".") {}
@@ -54,23 +60,23 @@ public:
     MULTI
   };
 
-  virtual string getPieceHash(int32_t index) const = 0;
+  virtual std::string getPieceHash(int32_t index) const = 0;
   
-  virtual const Strings& getPieceHashes() const = 0;
+  virtual const std::deque<std::string>& getPieceHashes() const = 0;
 
   virtual int64_t getTotalLength() const = 0;
 
   virtual FILE_MODE getFileMode() const = 0;
 
-  virtual FileEntries getFileEntries() const = 0;
+  virtual std::deque<SharedHandle<FileEntry> > getFileEntries() const = 0;
 
-  virtual string getName() const = 0;
+  virtual std::string getName() const = 0;
   
   virtual int32_t getPieceLength() const = 0;
 
   virtual int32_t getNumPieces() const = 0;
 
-  virtual string getPieceHashAlgo() const = 0;
+  virtual std::string getPieceHashAlgo() const = 0;
 
   /**
    * Returns an actual file path.
@@ -80,14 +86,14 @@ public:
    * /tmp/downloads/aria2.bin), then returns its base dir path,
    * for example, "/tmp/downloads"
    */
-  virtual string getActualBasePath() const = 0;
+  virtual std::string getActualBasePath() const = 0;
 
-  string getDir() const
+  std::string getDir() const
   {
     return _dir;
   }
 
-  void setDir(const string& dir)
+  void setDir(const std::string& dir)
   {
     _dir = dir;
   }
@@ -96,4 +102,6 @@ public:
 
 typedef SharedHandle<DownloadContext> DownloadContextHandle;
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_CONTEXT_H_
diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc
index 7fa680a7..da24c057 100644
--- a/src/DownloadEngine.cc
+++ b/src/DownloadEngine.cc
@@ -33,22 +33,24 @@
  */
 /* copyright --> */
 #include "DownloadEngine.h"
-#include "Socket.h"
 #include "NameResolver.h"
 #include "StatCalc.h"
-#include "DownloadResult.h"
 #include "RequestGroup.h"
 #include "RequestGroupMan.h"
 #include "FileAllocationMan.h"
 #include "CheckIntegrityMan.h"
-#include "Util.h"
+#include "DownloadResult.h"
+#include "StatCalc.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "TimeA2.h"
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include "a2time.h"
+#include "Socket.h"
 #include <signal.h>
+#include <cstring>
+#include <algorithm>
+
+namespace aria2 {
 
 // 0 ... running
 // 1 ... stop signal detected
@@ -94,8 +96,16 @@ DownloadEngine::~DownloadEngine() {
   cleanQueue();
 }
 
+class Deleter {
+public:
+  template<class T>
+  void operator()(T* ptr) {
+    delete ptr;
+  }
+};
+
 void DownloadEngine::cleanQueue() {
-  for_each(commands.begin(), commands.end(), Deleter());
+  std::for_each(commands.begin(), commands.end(), Deleter());
   commands.clear();
 }
 
@@ -220,7 +230,7 @@ void DownloadEngine::updateFdSet() {
 
 bool DownloadEngine::addSocket(const SocketEntry& entry) {
   SocketEntries::iterator itr =
-    find(socketEntries.begin(), socketEntries.end(), entry);
+    std::find(socketEntries.begin(), socketEntries.end(), entry);
   if(itr == socketEntries.end()) {
     socketEntries.push_back(entry);
     updateFdSet();
@@ -232,7 +242,7 @@ bool DownloadEngine::addSocket(const SocketEntry& entry) {
 
 bool DownloadEngine::deleteSocket(const SocketEntry& entry) {
   SocketEntries::iterator itr =
-    find(socketEntries.begin(), socketEntries.end(), entry);
+    std::find(socketEntries.begin(), socketEntries.end(), entry);
   if(itr == socketEntries.end()) {
     return false;
   } else {
@@ -312,9 +322,9 @@ void DownloadEngine::addCommand(const Commands& commands)
 bool DownloadEngine::addNameResolverCheck(const NameResolverHandle& resolver,
 					  Command* command) {
   NameResolverEntry entry(resolver, command);
-  NameResolverEntries::iterator itr = find(nameResolverEntries.begin(),
-					   nameResolverEntries.end(),
-					   entry);
+  NameResolverEntries::iterator itr = std::find(nameResolverEntries.begin(),
+						nameResolverEntries.end(),
+						entry);
   if(itr == nameResolverEntries.end()) {
     nameResolverEntries.push_back(entry);
     updateFdSet();
@@ -327,9 +337,9 @@ bool DownloadEngine::addNameResolverCheck(const NameResolverHandle& resolver,
 bool DownloadEngine::deleteNameResolverCheck(const NameResolverHandle& resolver,
 					     Command* command) {
   NameResolverEntry entry(resolver, command);
-  NameResolverEntries::iterator itr = find(nameResolverEntries.begin(),
-					   nameResolverEntries.end(),
-					   entry);
+  NameResolverEntries::iterator itr = std::find(nameResolverEntries.begin(),
+						nameResolverEntries.end(),
+						entry);
   if(itr == nameResolverEntries.end()) {
     return false;
   } else {
@@ -339,3 +349,5 @@ bool DownloadEngine::deleteNameResolverCheck(const NameResolverHandle& resolver,
   }
 }
 #endif // ENABLE_ASYNC_DNS
+
+} // namespace aria2
diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h
index 4b792292..b895a999 100644
--- a/src/DownloadEngine.h
+++ b/src/DownloadEngine.h
@@ -36,24 +36,21 @@
 #define _D_DOWNLOAD_ENGINE_H_
 
 #include "common.h"
-#include "a2netcompat.h"
+#include "SharedHandle.h"
 #include "Command.h"
+#include <deque>
+#include <sys/select.h>
+
+namespace aria2 {
 
-class SocketCore;
-typedef SharedHandle<SocketCore> SocketHandle;
-typedef deque<SocketHandle> Sockets;
 class Logger;
 class Option;
 class NameResolver;
-typedef SharedHandle<NameResolver> NameResolverHandle;
 class RequestGroupMan;
-typedef SharedHandle<RequestGroupMan> RequestGroupManHandle;
 class FileAllocationMan;
-typedef SharedHandle<FileAllocationMan> FileAllocationManHandle;
 class StatCalc;
-typedef SharedHandle<StatCalc> StatCalcHandle;
 class CheckIntegrityMan;
-typedef SharedHandle<CheckIntegrityMan> CheckIntegrityManHandle;
+class SocketCore;
 
 class SocketEntry {
 public:
@@ -62,35 +59,34 @@ public:
     TYPE_WR,
   };
 
-  SocketHandle socket;
+  SharedHandle<SocketCore> socket;
   Command* command;
   TYPE type;
 public:
-  SocketEntry(const SocketHandle& socket,
+  SocketEntry(const SharedHandle<SocketCore>& socket,
 	      Command* command,
 	      TYPE type);
 
   bool operator==(const SocketEntry& entry);
 };
 
-typedef deque<SocketEntry> SocketEntries;
+typedef std::deque<SocketEntry> SocketEntries;
 
 #ifdef ENABLE_ASYNC_DNS
 class NameResolverEntry {
 public:
-  NameResolverHandle nameResolver;
+  SharedHandle<NameResolver> nameResolver;
   Command* command;
 public:
-  NameResolverEntry(const NameResolverHandle& nameResolver,
+  NameResolverEntry(const SharedHandle<NameResolver>& nameResolver,
 		    Command* command);
 
   bool operator==(const NameResolverEntry& entry);
 };
 
-typedef deque<NameResolverEntry> NameResolverEntries;
+typedef std::deque<NameResolverEntry> NameResolverEntries;
 #endif // ENABLE_ASYNC_DNS
 
-
 class DownloadEngine {
 private:
   void waitData();
@@ -104,7 +100,7 @@ private:
 
   const Logger* logger;
   
-  StatCalcHandle _statCalc;
+  SharedHandle<StatCalc> _statCalc;
 
   bool _haltRequested;
 
@@ -124,13 +120,14 @@ private:
 
 public:
   bool noWait;
-  Commands commands;
-  RequestGroupManHandle _requestGroupMan;
-  FileAllocationManHandle _fileAllocationMan;
-  CheckIntegrityManHandle _checkIntegrityMan;
+  std::deque<Command*> commands;
+  SharedHandle<RequestGroupMan> _requestGroupMan;
+  SharedHandle<FileAllocationMan> _fileAllocationMan;
+  SharedHandle<CheckIntegrityMan> _checkIntegrityMan;
   const Option* option;
   
   DownloadEngine();
+
   virtual ~DownloadEngine();
 
   void run();
@@ -139,18 +136,18 @@ public:
 
   void updateFdSet();
 
-  bool addSocketForReadCheck(const SocketHandle& socket,
+  bool addSocketForReadCheck(const SharedHandle<SocketCore>& socket,
 			     Command* command);
-  bool deleteSocketForReadCheck(const SocketHandle& socket,
+  bool deleteSocketForReadCheck(const SharedHandle<SocketCore>& socket,
 				Command* command);
-  bool addSocketForWriteCheck(const SocketHandle& socket,
+  bool addSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
 			      Command* command);
-  bool deleteSocketForWriteCheck(const SocketHandle& socket,
+  bool deleteSocketForWriteCheck(const SharedHandle<SocketCore>& socket,
 				 Command* command);
 #ifdef ENABLE_ASYNC_DNS
-  bool addNameResolverCheck(const NameResolverHandle& resolver,
+  bool addNameResolverCheck(const SharedHandle<NameResolver>& resolver,
 			    Command* command);
-  bool deleteNameResolverCheck(const NameResolverHandle& resolver,
+  bool deleteNameResolverCheck(const SharedHandle<NameResolver>& resolver,
 			       Command* command);
 #endif // ENABLE_ASYNC_DNS
 
@@ -158,7 +155,7 @@ public:
 
   void fillCommand();
 
-  void setStatCalc(const StatCalcHandle& statCalc);
+  void setStatCalc(const SharedHandle<StatCalc>& statCalc);
 
   bool isHaltRequested() const
   {
@@ -168,5 +165,7 @@ public:
 
 typedef SharedHandle<DownloadEngine> DownloadEngineHandle;
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_ENGINE_H_
 
diff --git a/src/DownloadEngineFactory.cc b/src/DownloadEngineFactory.cc
index 72b1aff8..0d12da65 100644
--- a/src/DownloadEngineFactory.cc
+++ b/src/DownloadEngineFactory.cc
@@ -34,6 +34,7 @@
 /* copyright --> */
 #include "DownloadEngineFactory.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Option.h"
 #include "RequestGroup.h"
 #include "DownloadEngine.h"
@@ -43,7 +44,6 @@
 # include "CheckIntegrityMan.h"
 #endif // ENABLE_MESSAGE_DIGEST
 #include "prefs.h"
-#include "Util.h"
 #include "CUIDCounter.h"
 #include "FillRequestGroupCommand.h"
 #include "FileAllocationDispatcherCommand.h"
@@ -51,6 +51,8 @@
 #include "HaveEraseCommand.h"
 #include "DownloadResult.h"
 
+namespace aria2 {
+
 DownloadEngineFactory::DownloadEngineFactory():
   _logger(LogFactory::getInstance()) {}
 
@@ -86,3 +88,5 @@ DownloadEngineFactory::newDownloadEngine(Option* op,
 
   return e;
 }
+
+} // namespace aria2
diff --git a/src/DownloadEngineFactory.h b/src/DownloadEngineFactory.h
index 2c782618..662830a6 100644
--- a/src/DownloadEngineFactory.h
+++ b/src/DownloadEngineFactory.h
@@ -36,14 +36,15 @@
 #define _D_DOWNLOAD_ENGINE_FACTORY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class Logger;
 class Option;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class DownloadEngine;
-typedef SharedHandle<DownloadEngine> DownloadEngineHandle;
 
 class DownloadEngineFactory {
 private:
@@ -51,8 +52,11 @@ private:
 public:
   DownloadEngineFactory();
 
-  DownloadEngineHandle
-  newDownloadEngine(Option* op, const RequestGroups& requestGroups);
+  SharedHandle<DownloadEngine>
+  newDownloadEngine(Option* op,
+		    const std::deque<SharedHandle<RequestGroup> >& requestGroups);
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_ENGINE_FACTORY_H_
diff --git a/src/DownloadFailureException.h b/src/DownloadFailureException.h
index cbc859d2..7ddf11fd 100644
--- a/src/DownloadFailureException.h
+++ b/src/DownloadFailureException.h
@@ -36,6 +36,8 @@
 #define _D_DOWNLOAD_FAILURE_EXCEPTION_H_
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 /**
  * Throw this exception when a RequestGroup should aborted.
  * FYI, DlAbortEx is the exception to abort 1 Request.
@@ -47,16 +49,18 @@ public:
   DownloadFailureException(const char* msg, ...) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 
   DownloadFailureException(Exception* cause, const char* msg, ...):RecoverableException(cause) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_FAILURE_EXCEPTION_H_
diff --git a/src/DownloadHandler.cc b/src/DownloadHandler.cc
index 1518cf80..22048a71 100644
--- a/src/DownloadHandler.cc
+++ b/src/DownloadHandler.cc
@@ -34,9 +34,12 @@
 /* copyright --> */
 #include "DownloadHandler.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "RequestGroup.h"
 #include "RequestGroupCriteria.h"
 
+namespace aria2 {
+
 DownloadHandler::DownloadHandler():
   _criteria(0),
   _logger(LogFactory::getInstance()) {}
@@ -52,3 +55,5 @@ void DownloadHandler::setCriteria(const RequestGroupCriteriaHandle& criteria)
 {
   _criteria = criteria;
 }
+
+} // namespace aria2
diff --git a/src/DownloadHandler.h b/src/DownloadHandler.h
index e5e75e1d..c12a0a17 100644
--- a/src/DownloadHandler.h
+++ b/src/DownloadHandler.h
@@ -36,24 +36,22 @@
 #define _D_DOWNLOAD_HANDLER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class RequestGroup;
 class Logger;
 class RequestGroupCriteria;
-typedef SharedHandle<RequestGroupCriteria> RequestGroupCriteriaHandle;
 
 class DownloadHandler
 {
 protected:
-  RequestGroupCriteriaHandle _criteria;
+  SharedHandle<RequestGroupCriteria> _criteria;
 
   const Logger* _logger;
-
-private:
-  bool forwardMatch(const string& target, const Strings& candidates) const;
-
-  bool exactMatch(const string& target, const Strings& candidates) const;
-
 public:
   DownloadHandler();
 
@@ -61,7 +59,9 @@ public:
 
   bool canHandle(const RequestGroup* requestGroup) const;
 
-  void setCriteria(const RequestGroupCriteriaHandle& criteria);
+  void setCriteria(const SharedHandle<RequestGroupCriteria>& criteria);
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_HANDLER_H_
diff --git a/src/DownloadHandlerConstants.cc b/src/DownloadHandlerConstants.cc
index 6227df05..301a34c9 100644
--- a/src/DownloadHandlerConstants.cc
+++ b/src/DownloadHandlerConstants.cc
@@ -33,6 +33,9 @@
  */
 /* copyright --> */
 #include "DownloadHandlerConstants.h"
+#include "array_fun.h"
+
+namespace aria2 {
 
 const char* DownloadHandlerConstants::METALINK_EXTENSIONS[] = { ".metalink" };
 
@@ -46,26 +49,28 @@ const char* DownloadHandlerConstants::BT_CONTENT_TYPES[] = {
   "application/x-bittorrent"
 };
 
-Strings DownloadHandlerConstants::getMetalinkExtensions()
+std::deque<std::string> DownloadHandlerConstants::getMetalinkExtensions()
 {
-  return Strings(&METALINK_EXTENSIONS[0],
-		 &METALINK_EXTENSIONS[arrayLength(METALINK_EXTENSIONS)]);
+  return std::deque<std::string>(&METALINK_EXTENSIONS[0],
+				 &METALINK_EXTENSIONS[arrayLength(METALINK_EXTENSIONS)]);
 }
 
-Strings DownloadHandlerConstants::getMetalinkContentTypes()
+std::deque<std::string> DownloadHandlerConstants::getMetalinkContentTypes()
 {
-  return Strings(&METALINK_CONTENT_TYPES[0],
-		 &METALINK_CONTENT_TYPES[arrayLength(METALINK_CONTENT_TYPES)]);
+  return std::deque<std::string>(&METALINK_CONTENT_TYPES[0],
+				 &METALINK_CONTENT_TYPES[arrayLength(METALINK_CONTENT_TYPES)]);
 }
 
-Strings DownloadHandlerConstants::getBtExtensions()
+std::deque<std::string> DownloadHandlerConstants::getBtExtensions()
 {
-  return Strings(&BT_EXTENSIONS[0],
-		 &BT_EXTENSIONS[arrayLength(BT_EXTENSIONS)]);
+  return std::deque<std::string>(&BT_EXTENSIONS[0],
+				 &BT_EXTENSIONS[arrayLength(BT_EXTENSIONS)]);
 }
 
-Strings DownloadHandlerConstants::getBtContentTypes()
+std::deque<std::string> DownloadHandlerConstants::getBtContentTypes()
 {
-  return Strings(&BT_CONTENT_TYPES[0],
-		 &BT_CONTENT_TYPES[arrayLength(BT_CONTENT_TYPES)]);
+  return std::deque<std::string>(&BT_CONTENT_TYPES[0],
+				 &BT_CONTENT_TYPES[arrayLength(BT_CONTENT_TYPES)]);
 }
+
+} // namespace aria2
diff --git a/src/DownloadHandlerConstants.h b/src/DownloadHandlerConstants.h
index 246885b4..7e7f34ab 100644
--- a/src/DownloadHandlerConstants.h
+++ b/src/DownloadHandlerConstants.h
@@ -36,26 +36,31 @@
 #define _D_DOWNLOAD_HANDLER_CONSTANTS_H_
 
 #include "common.h"
-#include "a2functional.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class DownloadHandlerConstants
 {
 public:
   static const char* METALINK_EXTENSIONS[];
 
-  static Strings getMetalinkExtensions();
+  static std::deque<std::string> getMetalinkExtensions();
 
   static const char* METALINK_CONTENT_TYPES[];
 
-  static Strings getMetalinkContentTypes();
+  static std::deque<std::string> getMetalinkContentTypes();
 
   static const char* BT_EXTENSIONS[];
 
-  static Strings getBtExtensions();
+  static std::deque<std::string> getBtExtensions();
 
   static const char* BT_CONTENT_TYPES[];
 
-  static Strings getBtContentTypes();
+  static std::deque<std::string> getBtContentTypes();
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_HANDLER_CONSTANTS_H_
diff --git a/src/DownloadHandlerFactory.cc b/src/DownloadHandlerFactory.cc
index ad8c4ed3..c54af0b0 100644
--- a/src/DownloadHandlerFactory.cc
+++ b/src/DownloadHandlerFactory.cc
@@ -39,20 +39,32 @@
 #include "DownloadHandlerConstants.h"
 #include "ContentTypeRequestGroupCriteria.h"
 
-#ifdef ENABLE_METALINK
-MemoryBufferPreDownloadHandlerHandle DownloadHandlerFactory::_metalinkPreDownloadHandler = 0;
+namespace aria2 {
+
+#ifdef ENABLE_METALINK
+
+MemoryBufferPreDownloadHandlerHandle
+DownloadHandlerFactory::_metalinkPreDownloadHandler = 0;
+
+MetalinkPostDownloadHandlerHandle
+DownloadHandlerFactory::_metalinkPostDownloadHandler = 0;
 
-MetalinkPostDownloadHandlerHandle DownloadHandlerFactory::_metalinkPostDownloadHandler = 0;
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-MemoryBufferPreDownloadHandlerHandle DownloadHandlerFactory::_btPreDownloadHandler = 0;
 
-BtPostDownloadHandlerHandle DownloadHandlerFactory::_btPostDownloadHandler = 0;
+MemoryBufferPreDownloadHandlerHandle
+DownloadHandlerFactory::_btPreDownloadHandler = 0;
+
+BtPostDownloadHandlerHandle
+DownloadHandlerFactory::_btPostDownloadHandler = 0;
+
 #endif // ENABLE_BITTORRENT
 
 #ifdef ENABLE_METALINK
-MemoryBufferPreDownloadHandlerHandle DownloadHandlerFactory::getMetalinkPreDownloadHandler()
+
+MemoryBufferPreDownloadHandlerHandle
+DownloadHandlerFactory::getMetalinkPreDownloadHandler()
 {
   if(_metalinkPreDownloadHandler.isNull()) {
     _metalinkPreDownloadHandler = new MemoryBufferPreDownloadHandler();
@@ -65,17 +77,21 @@ MemoryBufferPreDownloadHandlerHandle DownloadHandlerFactory::getMetalinkPreDownl
   return _metalinkPreDownloadHandler;
 }
 
-MetalinkPostDownloadHandlerHandle DownloadHandlerFactory::getMetalinkPostDownloadHandler()
+MetalinkPostDownloadHandlerHandle
+DownloadHandlerFactory::getMetalinkPostDownloadHandler()
 {
   if(_metalinkPostDownloadHandler.isNull()) {
     _metalinkPostDownloadHandler = new MetalinkPostDownloadHandler();
   }
   return _metalinkPostDownloadHandler;
 }
+
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-MemoryBufferPreDownloadHandlerHandle DownloadHandlerFactory::getBtPreDownloadHandler()
+
+MemoryBufferPreDownloadHandlerHandle
+DownloadHandlerFactory::getBtPreDownloadHandler()
 {
   if(_btPreDownloadHandler.isNull()) {
     _btPreDownloadHandler = new MemoryBufferPreDownloadHandler();
@@ -95,4 +111,7 @@ BtPostDownloadHandlerHandle DownloadHandlerFactory::getBtPostDownloadHandler()
   }
   return _btPostDownloadHandler;
 }
+
 #endif // ENABLE_BITTORRENT
+
+} // namespace aria2
diff --git a/src/DownloadHandlerFactory.h b/src/DownloadHandlerFactory.h
index c8c695eb..dd3247c0 100644
--- a/src/DownloadHandlerFactory.h
+++ b/src/DownloadHandlerFactory.h
@@ -36,44 +36,46 @@
 #define _D_DOWNLOAD_HANDLER_FACTORY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class MemoryBufferPreDownloadHandler;
-typedef SharedHandle<MemoryBufferPreDownloadHandler> MemoryBufferPreDownloadHandlerHandle;
 #ifdef ENABLE_METALINK
 class MetalinkPostDownloadHandler;
-typedef SharedHandle<MetalinkPostDownloadHandler> MetalinkPostDownloadHandlerHandle;
 #endif // ENABLE_METALINK
 #ifdef ENABLE_BITTORRENT
 class BtPostDownloadHandler;
-typedef SharedHandle<BtPostDownloadHandler> BtPostDownloadHandlerHandle;
 #endif // ENABLE_BITTORRENT
 
 class DownloadHandlerFactory
 {
 private:
 #ifdef ENABLE_METALINK
-  static MemoryBufferPreDownloadHandlerHandle _metalinkPreDownloadHandler;
+  static SharedHandle<MemoryBufferPreDownloadHandler> _metalinkPreDownloadHandler;
 
-  static MetalinkPostDownloadHandlerHandle _metalinkPostDownloadHandler;
+  static SharedHandle<MetalinkPostDownloadHandler> _metalinkPostDownloadHandler;
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-  static MemoryBufferPreDownloadHandlerHandle _btPreDownloadHandler;
+  static SharedHandle<MemoryBufferPreDownloadHandler> _btPreDownloadHandler;
 
-  static BtPostDownloadHandlerHandle _btPostDownloadHandler;
+  static SharedHandle<BtPostDownloadHandler> _btPostDownloadHandler;
 #endif // ENABLE_BITTORRENT
 public:
 #ifdef ENABLE_METALINK
-  static MemoryBufferPreDownloadHandlerHandle getMetalinkPreDownloadHandler();
+  static SharedHandle<MemoryBufferPreDownloadHandler> getMetalinkPreDownloadHandler();
 
-  static MetalinkPostDownloadHandlerHandle getMetalinkPostDownloadHandler();
+  static SharedHandle<MetalinkPostDownloadHandler> getMetalinkPostDownloadHandler();
 #endif // ENABLE_METALINK
 
 #ifdef ENABLE_BITTORRENT
-  static MemoryBufferPreDownloadHandlerHandle getBtPreDownloadHandler();
+  static SharedHandle<MemoryBufferPreDownloadHandler> getBtPreDownloadHandler();
 
-  static BtPostDownloadHandlerHandle getBtPostDownloadHandler();
+  static SharedHandle<BtPostDownloadHandler> getBtPostDownloadHandler();
 #endif // ENABLE_BITTORRENT
 };
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_HANDLER_FACTORY_H_
diff --git a/src/DownloadResult.h b/src/DownloadResult.h
index 7350d3d9..340e69e7 100644
--- a/src/DownloadResult.h
+++ b/src/DownloadResult.h
@@ -36,6 +36,11 @@
 #define _D_DOWNLOAD_RESULT_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+#include <string>
+
+namespace aria2 {
 
 class DownloadResult
 {
@@ -47,20 +52,20 @@ public:
 
   int32_t gid;
  
-  string filePath;
+  std::string filePath;
 
   int64_t totalLength;
 
-  string uri;
+  std::string uri;
 
   int32_t numUri;
 
   RESULT result;
 
   DownloadResult(int32_t gid,
-		 const string& filePath,
+		 const std::string& filePath,
 		 int64_t totalLength,
-		 const string& uri,
+		 const std::string& uri,
 		 int32_t numUri,
 		 RESULT result):
     gid(gid),
@@ -73,4 +78,6 @@ public:
 
 typedef SharedHandle<DownloadResult> DownloadResultHandle;
 
+} // namespace aria2
+
 #endif // _D_DOWNLOAD_RESULT_H_
diff --git a/src/Exception.cc b/src/Exception.cc
index 45430495..47beb3f5 100644
--- a/src/Exception.cc
+++ b/src/Exception.cc
@@ -33,8 +33,11 @@
  */
 /* copyright --> */
 #include "Exception.h"
+#include <ostream>
 
-ostream& operator<<(ostream& o, const Exception& e)
+namespace aria2 {
+
+std::ostream& operator<<(std::ostream& o, const Exception& e)
 {
   o << e.getMsg() << "\n";
   for(Exception* cause = e.getCause(); cause; cause = cause->getCause()) {
@@ -42,3 +45,5 @@ ostream& operator<<(ostream& o, const Exception& e)
   }
   return o;
 }
+
+} // namespace aria2
diff --git a/src/Exception.h b/src/Exception.h
index 252f6d7f..c88353ad 100644
--- a/src/Exception.h
+++ b/src/Exception.h
@@ -37,18 +37,19 @@
 
 #include "common.h"
 #include <string>
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
+#include <iosfwd>
 
-using namespace std;
+namespace aria2 {
 
 class Exception {
 private:
-  string msg;
+  std::string msg;
 protected:
   Exception* cause;
 
-  void setMsg(const string& msgsrc, va_list ap) {
+  void setMsg(const std::string& msgsrc, va_list ap) {
     char buf[1024];
     vsnprintf(buf, sizeof(buf), msgsrc.c_str(), ap);
     msg = buf;
@@ -60,11 +61,13 @@ public:
     delete cause;
   }
 
-  const string& getMsg() const { return msg; }
+  const std::string& getMsg() const { return msg; }
 
   Exception* getCause() const { return cause; }
 
-  friend ostream& operator<<(ostream& o, const Exception& e);
+  friend std::ostream& operator<<(std::ostream& o, const Exception& e);
 };
 
+} // namespace aria2
+
 #endif // _D_EXCEPTION_H_
diff --git a/src/ExpatMetalinkProcessor.h b/src/ExpatMetalinkProcessor.h
index 88acf3c0..49930985 100644
--- a/src/ExpatMetalinkProcessor.h
+++ b/src/ExpatMetalinkProcessor.h
@@ -37,22 +37,26 @@
 
 #include "MetalinkProcessor.h"
 #include <expat.h>
+#include <string>
+
+namespace aria2 {
 
 class MetalinkParserStateMachine;
-typedef SharedHandle<MetalinkParserStateMachine> MetalinkParserStateMachineHandle;
 
 class ExpatMetalinkProcessor:public MetalinkProcessor {
 private:
-  MetalinkParserStateMachineHandle _stm;
+  SharedHandle<MetalinkParserStateMachine> _stm;
 
 public:
   ExpatMetalinkProcessor();
 
   virtual ~ExpatMetalinkProcessor() {}
 
-  virtual MetalinkerHandle parseFile(const string& filename);
+  virtual SharedHandle<Metalinker> parseFile(const std::string& filename);
 
-  virtual MetalinkerHandle parseFromBinaryStream(const BinaryStreamHandle& binaryStream);
+  virtual SharedHandle<Metalinker> parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream);
 };
 
+} // namespace aria2
+
 #endif // _D_EXPAT_METALINK_PROCESSOR_H_
diff --git a/src/ExtendedMessagingAware.h b/src/ExtendedMessagingAware.h
index 62273571..5177142b 100644
--- a/src/ExtendedMessagingAware.h
+++ b/src/ExtendedMessagingAware.h
@@ -37,6 +37,9 @@
 
 #include "common.h"
 #include "BtConstants.h"
+#include <string>
+
+namespace aria2 {
 
 class ExtendedMessagingAware {
 private:
@@ -54,7 +57,7 @@ public:
     return _extensions;
   }
 
-  uint8_t getExtensionMessageID(const string& name) const
+  uint8_t getExtensionMessageID(const std::string& name) const
   {
     Extensions::const_iterator itr = _extensions.find(name);
     if(itr == _extensions.end()) {
@@ -64,7 +67,7 @@ public:
     }
   }
 
-  string getExtensionName(uint8_t id) const
+  std::string getExtensionName(uint8_t id) const
   {
     for(Extensions::const_iterator itr = _extensions.begin();
       itr != _extensions.end(); ++itr) {
@@ -76,10 +79,12 @@ public:
     return "";
   }
 
-  void removeExtension(const string& name)
+  void removeExtension(const std::string& name)
   {
     _extensions.erase(name);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_EXTENDED_MESSAGING_AWARE_H_
diff --git a/src/ExtensionMessage.h b/src/ExtensionMessage.h
index cf47d97e..44902f0b 100644
--- a/src/ExtensionMessage.h
+++ b/src/ExtensionMessage.h
@@ -36,22 +36,27 @@
 #define _D_EXTENSION_MESSAGE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
 
+namespace aria2 {
 class ExtensionMessage {
 public:
   virtual ~ExtensionMessage() {}
 
-  virtual string getBencodedData() = 0;
+  virtual std::string getBencodedData() = 0;
 
   virtual uint8_t getExtensionMessageID() = 0;
   
-  virtual const string& getExtensionName() const = 0;
+  virtual const std::string& getExtensionName() const = 0;
 
-  virtual string toString() const = 0;
+  virtual std::string toString() const = 0;
 
   virtual void doReceivedAction() = 0;
 };
 
 typedef SharedHandle<ExtensionMessage> ExtensionMessageHandle;
 
+} // namespace aria2
+
 #endif // _D_EXTENSION_MESSAGE_H_
diff --git a/src/ExtensionMessageFactory.h b/src/ExtensionMessageFactory.h
index 8bbe1dce..c239eaaa 100644
--- a/src/ExtensionMessageFactory.h
+++ b/src/ExtensionMessageFactory.h
@@ -36,16 +36,22 @@
 #define _D_EXTENSION_MESSAGE_FACTORY_H_
 
 #include "ExtendedMessagingAware.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class ExtensionMessage;
-typedef SharedHandle<ExtensionMessage> ExtensionMessageHandle;
 
 class ExtensionMessageFactory:public ExtendedMessagingAware {
 public:
   virtual ~ExtensionMessageFactory() {}
 
-  virtual ExtensionMessageHandle createMessage(const char* data, size_t length) = 0;
+  virtual SharedHandle<ExtensionMessage>
+  createMessage(const char* data, size_t length) = 0;
 };
 
 typedef SharedHandle<ExtensionMessageFactory> ExtensionMessageFactoryHandle;
+
+} // namespace aria2
+
 #endif // _D_EXTENSION_MESSAGE_FACTORY_H_
diff --git a/src/FatalException.h b/src/FatalException.h
index 9d468adc..b7e36cba 100644
--- a/src/FatalException.h
+++ b/src/FatalException.h
@@ -36,6 +36,8 @@
 #define _D_FATAL_EXCEPTION_H_
 #include "Exception.h"
 
+namespace aria2 {
+
 class FatalException : public Exception {
 public:
   FatalException(Exception* cause = 0):Exception(cause) {}
@@ -43,16 +45,18 @@ public:
   FatalException(const char* msg, ...):Exception() {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 
   FatalException(Exception* cause, const char* msg, ...):Exception(cause) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_FATAL_EXCEPTION_EX_H_
diff --git a/src/FeatureConfig.cc b/src/FeatureConfig.cc
index 6bbc6a85..cb4e58fc 100644
--- a/src/FeatureConfig.cc
+++ b/src/FeatureConfig.cc
@@ -34,6 +34,8 @@
 /* copyright --> */
 #include "FeatureConfig.h"
 
+namespace aria2 {
+
 FeatureConfig* FeatureConfig::featureConfig = 0;
 
 #define FEATURE_HTTP "http"
@@ -102,3 +104,5 @@ FeatureConfig::FeatureConfig() {
     features.push_back(featureArray[i].first);
   }
 }
+
+} // namespace aria2
diff --git a/src/FeatureConfig.h b/src/FeatureConfig.h
index 788912b3..3d10433a 100644
--- a/src/FeatureConfig.h
+++ b/src/FeatureConfig.h
@@ -37,9 +37,13 @@
 
 #include "common.h"
 #include <map>
+#include <string>
+#include <deque>
 
-typedef map<string, int32_t> PortMap;
-typedef map<string, bool> FeatureMap;
+namespace aria2 {
+
+typedef std::map<std::string, int32_t> PortMap;
+typedef std::map<std::string, bool> FeatureMap;
 
 class FeatureConfig {
 private:
@@ -47,7 +51,7 @@ private:
 
   PortMap defaultPorts;
   FeatureMap supportedFeatures;
-  Strings features;
+  std::deque<std::string> features;
 
   FeatureConfig();
   ~FeatureConfig() {}
@@ -64,7 +68,7 @@ public:
     featureConfig = 0;
   }
 
-  int32_t getDefaultPort(const string& protocol) const {
+  int32_t getDefaultPort(const std::string& protocol) const {
     PortMap::const_iterator itr = defaultPorts.find(protocol);
     if(itr == defaultPorts.end()) {
       return 0;
@@ -73,7 +77,7 @@ public:
     }
   }
 
-  bool isSupported(const string& feature) const {
+  bool isSupported(const std::string& feature) const {
     FeatureMap::const_iterator itr = supportedFeatures.find(feature);
     if(itr == supportedFeatures.end()) {
       return false;
@@ -82,13 +86,13 @@ public:
     }
   }
 
-  const Strings& getFeatures() const {
+  const std::deque<std::string>& getFeatures() const {
     return features;
   }
 
-  string getConfigurationSummary() const {
-    string summary;
-    for(Strings::const_iterator itr = features.begin();
+  std::string getConfigurationSummary() const {
+    std::string summary;
+    for(std::deque<std::string>::const_iterator itr = features.begin();
 	itr != features.end(); itr++) {
       summary += *itr;
       if(isSupported(*itr)) {
@@ -102,4 +106,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_FEATURE_CONFIG_H_
diff --git a/src/File.cc b/src/File.cc
index 0796e1e0..7f8ef2e1 100644
--- a/src/File.cc
+++ b/src/File.cc
@@ -34,15 +34,20 @@
 /* copyright --> */
 #include "File.h"
 #include "Util.h"
-#include "a2io.h"
 #include <libgen.h>
+// use GNU version basename
+#undef basename
+#include <cstring>
+#include <deque>
+
+namespace aria2 {
 
 #ifdef __MINGW32__
 # define WIN32_LEAN_AND_MEAN
 # include <windows.h>
 #endif // __MINGW32__
 
-File::File(const string& name):name(name) {}
+File::File(const std::string& name):name(name) {}
 
 File::~File() {}
 
@@ -93,17 +98,17 @@ bool File::mkdirs() {
   if(isDir()) {
     return false;
   }
-  Strings dirs;
+  std::deque<std::string> dirs;
   Util::slice(dirs, name, '/');
   if(!dirs.size()) {
     return true;
   }
 
-  string accDir;
+  std::string accDir;
   if(Util::startsWith(name, "/")) {
     accDir = "/";
   }
-  for(Strings::const_iterator itr = dirs.begin(); itr != dirs.end();
+  for(std::deque<std::string>::const_iterator itr = dirs.begin(); itr != dirs.end();
       itr++, accDir += "/") {
     accDir += *itr;
     if(File(accDir).isDir()) {
@@ -125,28 +130,28 @@ mode_t File::mode()
   return fstat.st_mode;
 }
 
-string File::getBasename() const
+std::string File::getBasename() const
 {
   char* s = strdup(name.c_str());
-  string bname = basename(s);
+  std::string bname = basename(s);
   free(s);
   return bname;
 }
 
-string File::getDirname() const
+std::string File::getDirname() const
 {
   char* s = strdup(name.c_str());
-  string dname = dirname(s);
+  std::string dname = dirname(s);
   free(s);
   return dname;
 }
 
-bool File::isDir(const string& filename)
+bool File::isDir(const std::string& filename)
 {
   return File(filename).isDir();
 }
 
-bool File::renameTo(const string& dest)
+bool File::renameTo(const std::string& dest)
 {
 #ifdef __MINGW32__
   /* MinGW's rename() doesn't delete an existing destination */
@@ -163,3 +168,5 @@ bool File::renameTo(const string& dest)
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/File.h b/src/File.h
index cecf66d5..63da7044 100644
--- a/src/File.h
+++ b/src/File.h
@@ -36,25 +36,24 @@
 #define _D_FILE_H_
 
 #include "common.h"
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#include "a2io.h"
+#include <string>
 
-using namespace std;
+namespace aria2 {
 
 /**
  * Represents file and directory
  */
 class File {
 private:
-  string name;
+  std::string name;
   
   /**
    * Returns the return value of stat(...)
    */
   int32_t fillStat(struct stat& fstat);
 public:
-  File(const string& name);
+  File(const std::string& name);
   ~File();
 
   /**
@@ -91,18 +90,20 @@ public:
 
   mode_t mode();
 
-  string getBasename() const;
+  std::string getBasename() const;
 
-  string getDirname() const;
+  std::string getDirname() const;
 
-  const string& getPath() const
+  const std::string& getPath() const
   {
     return name;
   }
 
-  static bool isDir(const string& filename);
+  static bool isDir(const std::string& filename);
 
-  bool renameTo(const string& dest);
+  bool renameTo(const std::string& dest);
 };
 
+} // namespace aria2
+
 #endif // _D_FILE_H_
diff --git a/src/FileAllocationCommand.cc b/src/FileAllocationCommand.cc
index 16f3c697..dda7923a 100644
--- a/src/FileAllocationCommand.cc
+++ b/src/FileAllocationCommand.cc
@@ -35,11 +35,15 @@
 #include "FileAllocationCommand.h"
 #include "FileAllocationMan.h"
 #include "FileAllocationEntry.h"
+#include "DownloadEngine.h"
+#include "RequestGroup.h"
+#include "Logger.h"
 #include "message.h"
-#include "DownloadCommand.h"
 #include "prefs.h"
 #include "Util.h"
 
+namespace aria2 {
+
 FileAllocationCommand::FileAllocationCommand(int cuid, RequestGroup* requestGroup, DownloadEngine* e, const FileAllocationEntryHandle& fileAllocationEntry):
   RealtimeCommand(cuid, requestGroup, e),
   _fileAllocationEntry(fileAllocationEntry) {}
@@ -74,3 +78,5 @@ bool FileAllocationCommand::handleException(Exception* e)
   logger->error(MSG_DOWNLOAD_NOT_COMPLETE, cuid, _requestGroup->getFilePath().c_str());
   return true;
 }
+
+} // namespace aria2
diff --git a/src/FileAllocationCommand.h b/src/FileAllocationCommand.h
index 7870d8d1..601c923c 100644
--- a/src/FileAllocationCommand.h
+++ b/src/FileAllocationCommand.h
@@ -36,18 +36,21 @@
 #define _D_FILE_ALLOCATION_COMMAND_H_
 
 #include "RealtimeCommand.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class FileAllocationEntry;
-typedef SharedHandle<FileAllocationEntry> FileAllocationEntryHandle;
-class Exception;
 
 class FileAllocationCommand : public RealtimeCommand {
 private:
-  FileAllocationEntryHandle _fileAllocationEntry;
+  SharedHandle<FileAllocationEntry> _fileAllocationEntry;
   Time _timer;
 public:
-  FileAllocationCommand(int cuid, RequestGroup* requestGroup, DownloadEngine* e, const FileAllocationEntryHandle& fileAllocationEntry);
+  FileAllocationCommand(int cuid, RequestGroup* requestGroup,
+			DownloadEngine* e,
+			const SharedHandle<FileAllocationEntry>& fileAllocationEntry);
 
   virtual ~FileAllocationCommand();
 
@@ -56,4 +59,6 @@ public:
   virtual bool handleException(Exception* e);
 };
 
+} // namespace aria2
+
 #endif // _D_FILE_ALLOCATION_COMMAND_H_
diff --git a/src/FileAllocationDispatcherCommand.cc b/src/FileAllocationDispatcherCommand.cc
index 21235ce4..489d6b2a 100644
--- a/src/FileAllocationDispatcherCommand.cc
+++ b/src/FileAllocationDispatcherCommand.cc
@@ -40,6 +40,9 @@
 #include "FileAllocationCommand.h"
 #include "message.h"
 #include "CUIDCounter.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 FileAllocationDispatcherCommand::FileAllocationDispatcherCommand(int32_t cuid, DownloadEngine* e):
   Command(cuid), _e(e)
@@ -72,3 +75,5 @@ bool FileAllocationDispatcherCommand::execute()
 
   return false;
 }
+
+} // namespace aria2
diff --git a/src/FileAllocationDispatcherCommand.h b/src/FileAllocationDispatcherCommand.h
index 892daed2..f45cd2f5 100644
--- a/src/FileAllocationDispatcherCommand.h
+++ b/src/FileAllocationDispatcherCommand.h
@@ -37,6 +37,8 @@
 
 #include "Command.h"
 
+namespace aria2 {
+
 class DownloadEngine;
 
 class FileAllocationDispatcherCommand : public Command {
@@ -50,4 +52,6 @@ public:
   virtual bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_FILE_ALLOCATION_DISPATCHER_COMMAND_H_
diff --git a/src/FileAllocationEntry.cc b/src/FileAllocationEntry.cc
index df9cfcc0..a4e36e56 100644
--- a/src/FileAllocationEntry.cc
+++ b/src/FileAllocationEntry.cc
@@ -39,6 +39,8 @@
 #include "PieceStorage.h"
 #include "DiskAdaptor.h"
 
+namespace aria2 {
+
 FileAllocationEntry::FileAllocationEntry(RequestGroup* requestGroup, Command* nextCommand):
   RequestGroupEntry(requestGroup, nextCommand),
   _fileAllocationIterator(requestGroup->getPieceStorage()->getDiskAdaptor()->fileAllocationIterator())
@@ -70,3 +72,5 @@ void FileAllocationEntry::allocateChunk()
 {
   _fileAllocationIterator->allocateChunk();
 }
+
+} // namespace aria2
diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h
index c5be8968..84426795 100644
--- a/src/FileAllocationEntry.h
+++ b/src/FileAllocationEntry.h
@@ -36,16 +36,18 @@
 #define _D_FILE_ALLOCATION_ENTRY_H_
 
 #include "RequestGroupEntry.h"
+#include "ProgressAwareEntry.h"
+#include <deque>
+
+namespace aria2 {
 
 class FileAllocationIterator;
-typedef SharedHandle<FileAllocationIterator> FileAllocationIteratorHandle;
 class Command;
-typedef deque<Command*> Commands;
 class DownloadEngine;
 
 class FileAllocationEntry : public RequestGroupEntry, public ProgressAwareEntry {
 private:
-  FileAllocationIteratorHandle _fileAllocationIterator;
+  SharedHandle<FileAllocationIterator> _fileAllocationIterator;
 public:
   FileAllocationEntry(RequestGroup* requestGroup, Command* nextCommand = 0);
 
@@ -59,10 +61,12 @@ public:
 
   void allocateChunk();
 
-  virtual Commands prepareForNextAction(DownloadEngine* e) = 0;
+  virtual std::deque<Command*> prepareForNextAction(DownloadEngine* e) = 0;
 };
 
 typedef SharedHandle<FileAllocationEntry> FileAllocationEntryHandle;
-typedef deque<FileAllocationEntryHandle> FileAllocationEntries;
+typedef std::deque<FileAllocationEntryHandle> FileAllocationEntries;
+
+} // namespace aria2
 
 #endif // _D_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/FileAllocationIterator.h b/src/FileAllocationIterator.h
index 10685e76..6148b68c 100644
--- a/src/FileAllocationIterator.h
+++ b/src/FileAllocationIterator.h
@@ -36,6 +36,9 @@
 #define _D_FILE_ALLOCATION_ITERATOR_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class FileAllocationIterator
 {
@@ -53,4 +56,6 @@ public:
 
 typedef SharedHandle<FileAllocationIterator> FileAllocationIteratorHandle;
 
+} // namespace aria2
+
 #endif // _D_FILE_ALLOCATION_ITERATOR_H_
diff --git a/src/FileAllocationMan.cc b/src/FileAllocationMan.cc
index 205012ff..e95fb58c 100644
--- a/src/FileAllocationMan.cc
+++ b/src/FileAllocationMan.cc
@@ -35,6 +35,8 @@
 #include "FileAllocationMan.h"
 #include "FileAllocationEntry.h"
 
+namespace aria2 {
+
 FileAllocationMan::FileAllocationMan():_currentFileAllocationEntry(0) {}
 
 FileAllocationMan::~FileAllocationMan() {}
@@ -79,3 +81,5 @@ int32_t FileAllocationMan::countFileAllocationEntryInQueue() const
 {
   return _fileAllocationEntries.size();
 }
+
+} // namespace aria2
diff --git a/src/FileAllocationMan.h b/src/FileAllocationMan.h
index c911b41f..14841117 100644
--- a/src/FileAllocationMan.h
+++ b/src/FileAllocationMan.h
@@ -36,15 +36,17 @@
 #define _D_FILE_ALLOCATION_MAN_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class FileAllocationEntry;
-typedef SharedHandle<FileAllocationEntry> FileAllocationEntryHandle;
-typedef deque<FileAllocationEntryHandle> FileAllocationEntries;
 
 class FileAllocationMan {
 private:
-  FileAllocationEntries _fileAllocationEntries;
-  FileAllocationEntryHandle _currentFileAllocationEntry;
+  std::deque<SharedHandle<FileAllocationEntry> > _fileAllocationEntries;
+  SharedHandle<FileAllocationEntry> _currentFileAllocationEntry;
 public:
   FileAllocationMan();
 
@@ -52,19 +54,21 @@ public:
 
   bool isFileAllocationBeingExecuted() const;
 
-  FileAllocationEntryHandle getCurrentFileAllocationEntry();
+  SharedHandle<FileAllocationEntry> getCurrentFileAllocationEntry();
 
   void markCurrentFileAllocationEntryDone();
 
   bool nextFileAllocationEntryExists() const;
 
-  FileAllocationEntryHandle popNextFileAllocationEntry();
+  SharedHandle<FileAllocationEntry> popNextFileAllocationEntry();
 
-  void pushFileAllocationEntry(const FileAllocationEntryHandle& entry);
+  void pushFileAllocationEntry(const SharedHandle<FileAllocationEntry>& entry);
 
   int32_t countFileAllocationEntryInQueue() const;
 };
 
 typedef SharedHandle<FileAllocationMan> FileAllocationManHandle;
 
+} // namespace aria2
+
 #endif // _D_FILE_ALLOCATION_MAN_H_
diff --git a/src/FileEntry.cc b/src/FileEntry.cc
index c5b1108f..ef47b94f 100644
--- a/src/FileEntry.cc
+++ b/src/FileEntry.cc
@@ -35,18 +35,19 @@
 #include "FileEntry.h"
 #include "File.h"
 #include "Util.h"
-#include <libgen.h>
 
-FileEntry::FileEntry(const string& path,
+namespace aria2 {
+
+FileEntry::FileEntry(const std::string& path,
 		     int64_t length,
 		     int64_t offset,
-		     const Strings& uris):
+		     const std::deque<std::string>& uris):
   path(path), _uris(uris), length(length), offset(offset),
   extracted(false), requested(true) {}
 
 FileEntry::~FileEntry() {}
 
-void FileEntry::setupDir(const string& parentDir)
+void FileEntry::setupDir(const std::string& parentDir)
 {
   Util::mkdirs(File(parentDir+"/"+path).getDirname());
 }
@@ -67,3 +68,5 @@ bool FileEntry::operator<(const FileEntry& fileEntry) const
 {
   return offset < fileEntry.offset;
 }
+
+} // namespace aria2
diff --git a/src/FileEntry.h b/src/FileEntry.h
index 9c1d36dd..722db7e0 100644
--- a/src/FileEntry.h
+++ b/src/FileEntry.h
@@ -36,12 +36,17 @@
 #define _D_FILE_ENTRY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "File.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class FileEntry {
 private:
-  string path;
-  Strings _uris;
+  std::string path;
+  std::deque<std::string> _uris;
   int64_t length;
   int64_t offset;
   bool extracted;
@@ -49,25 +54,26 @@ private:
 public:
   FileEntry():length(0), offset(0), extracted(false), requested(false) {}
 
-  FileEntry(const string& path, int64_t length, int64_t offset, const Strings& uris = Strings());
+  FileEntry(const std::string& path, int64_t length, int64_t offset,
+	    const std::deque<std::string>& uris = std::deque<std::string>());
 
   ~FileEntry();
 
   FileEntry& operator=(const FileEntry& entry);
 
-  string getBasename() const
+  std::string getBasename() const
   {
     return File(path).getBasename();
   }
 
-  string getDirname() const
+  std::string getDirname() const
   {
     return File(path).getDirname();
   }
 
-  const string& getPath() const { return path; }
+  const std::string& getPath() const { return path; }
 
-  void setPath(const string& path) { this->path = path; }
+  void setPath(const std::string& path) { this->path = path; }
 
   int64_t getLength() const { return length; }
 
@@ -85,9 +91,9 @@ public:
 
   void setRequested(bool flag) { this->requested = flag; }
 
-  void setupDir(const string& parentDir);
+  void setupDir(const std::string& parentDir);
 
-  const Strings& getAssociatedUris() const
+  const std::deque<std::string>& getAssociatedUris() const
   {
     return _uris;
   }
@@ -96,6 +102,8 @@ public:
 };
 
 typedef SharedHandle<FileEntry> FileEntryHandle;
-typedef deque<FileEntryHandle> FileEntries;
+typedef std::deque<FileEntryHandle> FileEntries;
+
+}
 
 #endif // _D_FILE_ENTRY_H_
diff --git a/src/FileMetalinkParserState.cc b/src/FileMetalinkParserState.cc
index bf9f0258..f6284f6a 100644
--- a/src/FileMetalinkParserState.cc
+++ b/src/FileMetalinkParserState.cc
@@ -37,9 +37,11 @@
 #include "Util.h"
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 void FileMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					   const string& name,
-					   const map<string, string>& attrs)
+					   const std::string& name,
+					   const std::map<std::string, std::string>& attrs)
 {
   if(name == "size") {
     stm->setSizeState();
@@ -57,7 +59,7 @@ void FileMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
     stm->setResourcesState();
     int32_t maxConnections;
     {
-      map<string, string>::const_iterator itr = attrs.find("maxconnections");
+      std::map<std::string, std::string>::const_iterator itr = attrs.find("maxconnections");
       if(itr == attrs.end()) {
 	maxConnections = -1;
       } else {
@@ -76,9 +78,11 @@ void FileMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void FileMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					  const string& name,
-					  const string& characters)
+					 const std::string& name,
+					 const std::string& characters)
 {
   stm->commitEntryTransaction();
   stm->setFilesState();
 }
+
+} //  namespace aria2
diff --git a/src/FileMetalinkParserState.h b/src/FileMetalinkParserState.h
index 22653d58..76035eb9 100644
--- a/src/FileMetalinkParserState.h
+++ b/src/FileMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class FileMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_FILE_METALINK_PARSER_STATE_H_
diff --git a/src/FileUriListParser.h b/src/FileUriListParser.h
deleted file mode 100644
index a69c71cf..00000000
--- a/src/FileUriListParser.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_FILE_URI_LIST_PARSER_H_
-#define _D_FILE_URI_LIST_PARSER_H_
-
-#include "UriListParser.h"
-#include <fstream>
-
-class FileUriListParser : public UriListParser {
-private:
-  string _filename;
-  ifstream _ifs;
-
-protected:
-  virtual istream& getInputStream()
-  {
-    return _ifs;
-  }
-
-  virtual const istream& getInputStream() const
-  {
-    return _ifs;
-  }
-
-public:
-  FileUriListParser(const string& filename):_filename(filename), _ifs(filename.c_str()) {}
-
-  virtual ~FileUriListParser() {}
-};
-
-#endif // _D_FILE_URI_LIST_PARSER_H_
diff --git a/src/FilesMetalinkParserState.cc b/src/FilesMetalinkParserState.cc
index ccdbacb0..a9a69f22 100644
--- a/src/FilesMetalinkParserState.cc
+++ b/src/FilesMetalinkParserState.cc
@@ -35,13 +35,15 @@
 #include "FilesMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void FilesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					    const string& name,
-					    const map<string, string>& attrs)
+					    const std::string& name,
+					    const std::map<std::string, std::string>& attrs)
 {
   if(name == "file") {
     stm->setFileState();
-    map<string, string>::const_iterator itr = attrs.find("name");
+    std::map<std::string, std::string>::const_iterator itr = attrs.find("name");
     if(itr != attrs.end()) {
       stm->newEntryTransaction();
       stm->setFileNameOfEntry((*itr).second);
@@ -52,8 +54,10 @@ void FilesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void FilesMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					  const string& name,
-					  const string& characters)
+					  const std::string& name,
+					  const std::string& characters)
 {
   stm->setMetalinkState();
 }
+
+} // namespace aria2
diff --git a/src/FilesMetalinkParserState.h b/src/FilesMetalinkParserState.h
index 176a3b89..f0394bab 100644
--- a/src/FilesMetalinkParserState.h
+++ b/src/FilesMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class FilesMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_FILES_METALINK_PARSER_STATE_H_
diff --git a/src/FillRequestGroupCommand.cc b/src/FillRequestGroupCommand.cc
index f1398b00..4256b869 100644
--- a/src/FillRequestGroupCommand.cc
+++ b/src/FillRequestGroupCommand.cc
@@ -38,6 +38,9 @@
 #include "RequestGroup.h"
 #include "RecoverableException.h"
 #include "message.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 FillRequestGroupCommand::FillRequestGroupCommand(int32_t cuid,
 						 DownloadEngine* e,
@@ -65,3 +68,5 @@ bool FillRequestGroupCommand::execute()
   _e->commands.push_back(this);
   return false;
 }
+
+} // namespace aria2
diff --git a/src/FillRequestGroupCommand.h b/src/FillRequestGroupCommand.h
index 167818d1..be34f265 100644
--- a/src/FillRequestGroupCommand.h
+++ b/src/FillRequestGroupCommand.h
@@ -36,16 +36,18 @@
 #define _D_FILL_REQUEST_GROUP_COMMAND_H_
 
 #include "Command.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
+#include <deque>
+
+namespace aria2 {
 
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class DownloadEngine;
 
 class FillRequestGroupCommand : public Command {
 private:
-  RequestGroups _reservedRequestGroups;
+  std::deque<SharedHandle<RequestGroup> > _reservedRequestGroups;
   DownloadEngine* _e;
   int32_t _interval;
   Time _checkPoint;
@@ -62,4 +64,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_FILL_REQUEST_GROUP_COMMAND_H_
diff --git a/src/FinMetalinkParserState.cc b/src/FinMetalinkParserState.cc
index f7de1442..1273fd69 100644
--- a/src/FinMetalinkParserState.cc
+++ b/src/FinMetalinkParserState.cc
@@ -35,11 +35,15 @@
 #include "FinMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void FinMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					  const string& name,
-					  const map<string, string>& attrs)
+					  const std::string& name,
+					  const std::map<std::string, std::string>& attrs)
 {}
 
 void FinMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					const string& name, const string& characters)
+					const std::string& name, const std::string& characters)
 {}
+
+} // namespace aria2
diff --git a/src/FinMetalinkParserState.h b/src/FinMetalinkParserState.h
index 868ebbe0..6f0b827d 100644
--- a/src/FinMetalinkParserState.h
+++ b/src/FinMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class FinMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_FIN_METALINK_PARSER_STATE_H_
diff --git a/src/FixedWidthNumberDecorator.h b/src/FixedWidthNumberDecorator.h
index 6ee8160d..286d93e9 100644
--- a/src/FixedWidthNumberDecorator.h
+++ b/src/FixedWidthNumberDecorator.h
@@ -38,6 +38,8 @@
 #include "NumberDecorator.h"
 #include "Util.h"
 
+namespace aria2 {
+
 class FixedWidthNumberDecorator : public NumberDecorator
 {
 private:
@@ -47,9 +49,9 @@ public:
 
   virtual ~FixedWidthNumberDecorator() {}
 
-  virtual string decorate(int32_t number)
+  virtual std::string decorate(int32_t number)
   {
-    string s = Util::itos(number);
+    std::string s = Util::itos(number);
     while(s.size() < (size_t)_width) {
       s.insert(0, "0");
     }
@@ -57,4 +59,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_FIXED_WIDTH_NUMBER_DECORATOR_H_
diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc
index e1548aac..407e010a 100644
--- a/src/FtpConnection.cc
+++ b/src/FtpConnection.cc
@@ -33,67 +33,73 @@
  */
 /* copyright --> */
 #include "FtpConnection.h"
+#include "Request.h"
+#include "Segment.h"
+#include "Option.h"
 #include "Util.h"
 #include "message.h"
 #include "prefs.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "AuthConfigFactory.h"
 #include "AuthConfig.h"
 #include "DlRetryEx.h"
 #include "DlAbortEx.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 FtpConnection::FtpConnection(int32_t cuid, const SocketHandle& socket,
-			     const RequestHandle req, const Option* op)
-  :cuid(cuid), socket(socket), req(req), option(op) {
-  logger = LogFactory::getInstance();
-}
+			     const RequestHandle& req, const Option* op):
+  cuid(cuid), socket(socket), req(req), option(op),
+  logger(LogFactory::getInstance()) {}
 
 FtpConnection::~FtpConnection() {}
 
 void FtpConnection::sendUser() const
 {
-  string request = "USER "+AuthConfigFactorySingleton::instance()->createAuthConfig(req)->getUser()+"\r\n";
+  std::string request = "USER "+AuthConfigFactorySingleton::instance()->createAuthConfig(req)->getUser()+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
 void FtpConnection::sendPass() const
 {
-  string request = "PASS "+AuthConfigFactorySingleton::instance()->createAuthConfig(req)->getPassword()+"\r\n";
+  std::string request = "PASS "+AuthConfigFactorySingleton::instance()->createAuthConfig(req)->getPassword()+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, "PASS ********");
   socket->writeData(request);
 }
 
 void FtpConnection::sendType() const
 {
-  string type;
+  std::string type;
   if(option->get(PREF_FTP_TYPE) == V_ASCII) {
     type = "A";
   } else {
     type = "I";
   }
-  string request = "TYPE "+type+"\r\n";
+  std::string request = "TYPE "+type+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
 void FtpConnection::sendCwd() const
 {
-  string request = "CWD "+Util::urldecode(req->getDir())+"\r\n";
+  std::string request = "CWD "+Util::urldecode(req->getDir())+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
 void FtpConnection::sendSize() const
 {
-  string request = "SIZE "+Util::urldecode(req->getFile())+"\r\n";
+  std::string request = "SIZE "+Util::urldecode(req->getFile())+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
 void FtpConnection::sendPasv() const
 {
-  string request = "PASV\r\n";
+  std::string request = "PASV\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
@@ -104,13 +110,13 @@ SocketHandle FtpConnection::sendPort() const
   serverSocket->bind(0);
   serverSocket->beginListen();
   
-  pair<string, int32_t> addrinfo;
+  std::pair<std::string, int32_t> addrinfo;
   socket->getAddrInfo(addrinfo);
   int32_t ipaddr[4]; 
   sscanf(addrinfo.first.c_str(), "%d.%d.%d.%d",
 	 &ipaddr[0], &ipaddr[1], &ipaddr[2], &ipaddr[3]);
   serverSocket->getAddrInfo(addrinfo);
-  string request = "PORT "+
+  std::string request = "PORT "+
     Util::itos(ipaddr[0])+","+Util::itos(ipaddr[1])+","+
     Util::itos(ipaddr[2])+","+Util::itos(ipaddr[3])+","+
     Util::itos(addrinfo.second/256)+","+Util::itos(addrinfo.second%256)+"\r\n";
@@ -121,19 +127,19 @@ SocketHandle FtpConnection::sendPort() const
 
 void FtpConnection::sendRest(const SegmentHandle& segment) const
 {
-  string request = "REST "+Util::llitos(segment->getPositionToWrite())+"\r\n";
+  std::string request = "REST "+Util::llitos(segment->getPositionToWrite())+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
 void FtpConnection::sendRetr() const
 {
-  string request = "RETR "+Util::urldecode(req->getFile())+"\r\n";
+  std::string request = "RETR "+Util::urldecode(req->getFile())+"\r\n";
   logger->info(MSG_SENDING_REQUEST, cuid, request.c_str());
   socket->writeData(request);
 }
 
-int32_t FtpConnection::getStatus(const string& response) const
+int32_t FtpConnection::getStatus(const std::string& response) const
 {
   int32_t status;
   // When the response is not like "%d %*s",
@@ -149,7 +155,7 @@ int32_t FtpConnection::getStatus(const string& response) const
   }
 }
 
-bool FtpConnection::isEndOfResponse(int32_t status, const string& response) const
+bool FtpConnection::isEndOfResponse(int32_t status, const std::string& response) const
 {
   if(response.size() <= 4) {
     return false;
@@ -157,9 +163,9 @@ bool FtpConnection::isEndOfResponse(int32_t status, const string& response) cons
   // if 4th character of buf is '-', then multi line response is expected.
   if(response.at(3) == '-') {
     // multi line response
-    string::size_type p;
+    std::string::size_type p;
     p = response.find("\r\n"+Util::itos(status)+" ");
-    if(p == string::npos) {
+    if(p == std::string::npos) {
       return false;
     }
   }
@@ -170,7 +176,7 @@ bool FtpConnection::isEndOfResponse(int32_t status, const string& response) cons
   }
 }
 
-bool FtpConnection::bulkReceiveResponse(pair<int32_t, string>& response)
+bool FtpConnection::bulkReceiveResponse(std::pair<int32_t, std::string>& response)
 {
   char buf[1024];  
   while(socket->isReadable(0)) {
@@ -205,7 +211,7 @@ bool FtpConnection::bulkReceiveResponse(pair<int32_t, string>& response)
 
 int32_t FtpConnection::receiveResponse()
 {
-  pair<int32_t, string> response;
+  std::pair<int32_t, std::string> response;
   if(bulkReceiveResponse(response)) {
     return response.first;
   } else {
@@ -213,9 +219,21 @@ int32_t FtpConnection::receiveResponse()
   }
 }
 
+#ifdef __MINGW32__
+# define LONGLONG_PRINTF "%I64d"
+# define ULONGLONG_PRINTF "%I64u"
+# define LONGLONG_SCANF "%I64d"
+# define ULONGLONG_SCANF "%I64u"
+#else
+# define LONGLONG_PRINTF "%lld"
+# define ULONGLONG_PRINTF "%llu"
+# define LONGLONG_SCANF "%Ld"
+# define ULONGLONG_SCANF "%Lu"
+#endif // __MINGW32__
+
 int32_t FtpConnection::receiveSizeResponse(int64_t& size)
 {
-  pair<int32_t, string> response;
+  std::pair<int32_t, std::string> response;
   if(bulkReceiveResponse(response)) {
     if(response.first == 213) {
       sscanf(response.second.c_str(), "%*d " LONGLONG_SCANF, &size);
@@ -226,14 +244,14 @@ int32_t FtpConnection::receiveSizeResponse(int64_t& size)
   }
 }
 
-int32_t FtpConnection::receivePasvResponse(pair<string, int32_t>& dest)
+int32_t FtpConnection::receivePasvResponse(std::pair<std::string, int32_t>& dest)
 {
-  pair<int32_t, string> response;
+  std::pair<int32_t, std::string> response;
   if(bulkReceiveResponse(response)) {
     if(response.first == 227) {
       // we assume the format of response is "227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)."
       int32_t h1, h2, h3, h4, p1, p2;
-      string::size_type p = response.second.find("(");
+      std::string::size_type p = response.second.find("(");
       if(p >= 4) {
 	sscanf(response.second.substr(response.second.find("(")).c_str(),
 	       "(%d,%d,%d,%d,%d,%d).",
@@ -251,3 +269,5 @@ int32_t FtpConnection::receivePasvResponse(pair<string, int32_t>& dest)
     return 0;
   }
 }
+
+} // namespace aria2
diff --git a/src/FtpConnection.h b/src/FtpConnection.h
index 81fc7449..edc3b676 100644
--- a/src/FtpConnection.h
+++ b/src/FtpConnection.h
@@ -36,29 +36,34 @@
 #define _D_FTP_CONNECTION_H_
 
 #include "common.h"
-#include "Socket.h"
-#include "Option.h"
-#include "Logger.h"
-#include "Segment.h"
-#include "Request.h"
+#include "SharedHandle.h"
 #include <utility>
+#include <string>
+
+namespace aria2 {
+
+class Option;
+class Logger;
+class Segment;
+class Request;
+class SocketCore;
 
 class FtpConnection {
 private:
   int32_t cuid;
-  SocketHandle socket;
-  RequestHandle req;
+  SharedHandle<SocketCore> socket;
+  SharedHandle<Request> req;
   const Option* option;
   const Logger* logger;
 
-  string strbuf;
+  std::string strbuf;
 
-  int32_t getStatus(const string& response) const;
-  bool isEndOfResponse(int32_t status, const string& response) const;
-  bool bulkReceiveResponse(pair<int32_t, string>& response);
+  int32_t getStatus(const std::string& response) const;
+  bool isEndOfResponse(int32_t status, const std::string& response) const;
+  bool bulkReceiveResponse(std::pair<int32_t, std::string>& response);
 public:
-  FtpConnection(int32_t cuid, const SocketHandle& socket,
-		const RequestHandle req, const Option* op);
+  FtpConnection(int32_t cuid, const SharedHandle<SocketCore>& socket,
+		const SharedHandle<Request>& req, const Option* op);
   ~FtpConnection();
   void sendUser() const;
   void sendPass() const;
@@ -66,13 +71,15 @@ public:
   void sendCwd() const;
   void sendSize() const;
   void sendPasv() const;
-  SocketHandle sendPort() const;
-  void sendRest(const SegmentHandle& segment) const;
+  SharedHandle<SocketCore> sendPort() const;
+  void sendRest(const SharedHandle<Segment>& segment) const;
   void sendRetr() const;
 
   int32_t receiveResponse();
   int32_t receiveSizeResponse(int64_t& size);
-  int32_t receivePasvResponse(pair<string, int32_t>& dest);
+  int32_t receivePasvResponse(std::pair<std::string, int32_t>& dest);
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_CONNECTION_H_
diff --git a/src/FtpDownloadCommand.cc b/src/FtpDownloadCommand.cc
index c2bb39a5..392cdc46 100644
--- a/src/FtpDownloadCommand.cc
+++ b/src/FtpDownloadCommand.cc
@@ -34,6 +34,9 @@
 /* copyright --> */
 #include "FtpDownloadCommand.h"
 #include "Request.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 FtpDownloadCommand::FtpDownloadCommand(int cuid,
 				       const RequestHandle req,
@@ -45,3 +48,5 @@ FtpDownloadCommand::FtpDownloadCommand(int cuid,
    ctrlSocket(ctrlSocket) {}
 
 FtpDownloadCommand::~FtpDownloadCommand() {}
+
+} // namespace aria2
diff --git a/src/FtpDownloadCommand.h b/src/FtpDownloadCommand.h
index 1b799d46..db3e3314 100644
--- a/src/FtpDownloadCommand.h
+++ b/src/FtpDownloadCommand.h
@@ -37,17 +37,23 @@
 
 #include "DownloadCommand.h"
 
+namespace aria2 {
+
+class SocketCore;
+
 class FtpDownloadCommand : public DownloadCommand {
 private:
-  SocketHandle ctrlSocket;
+  SharedHandle<SocketCore> ctrlSocket;
 public:
   FtpDownloadCommand(int cuid,
-		     const RequestHandle req,
+		     const SharedHandle<Request> req,
 		     RequestGroup* requestGroup,
 		     DownloadEngine* e,
-		     const SocketHandle& dataSocket,
-		     const SocketHandle& ctrlSocket);
+		     const SharedHandle<SocketCore>& dataSocket,
+		     const SharedHandle<SocketCore>& ctrlSocket);
   virtual ~FtpDownloadCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_DOWNLOAD_COMMAND_H_
diff --git a/src/FtpInitiateConnectionCommand.cc b/src/FtpInitiateConnectionCommand.cc
index eb91a4de..1695a81b 100644
--- a/src/FtpInitiateConnectionCommand.cc
+++ b/src/FtpInitiateConnectionCommand.cc
@@ -39,13 +39,19 @@
 #include "Option.h"
 #include "Request.h"
 #include "FtpNegotiationCommand.h"
+#include "HttpRequest.h"
+#include "Segment.h"
 #include "HttpRequestCommand.h"
 #include "FtpTunnelRequestCommand.h"
 #include "DlAbortEx.h"
+#include "Logger.h"
 #include "message.h"
 #include "prefs.h"
 #include "Util.h"
 #include "HttpConnection.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 FtpInitiateConnectionCommand::FtpInitiateConnectionCommand(int cuid,
 							   const RequestHandle& req,
@@ -66,7 +72,7 @@ FtpInitiateConnectionCommand::~FtpInitiateConnectionCommand() {
 }
 
 bool FtpInitiateConnectionCommand::executeInternal() {
-  string hostname;
+  std::string hostname;
   if(useHttpProxy()) {
     hostname = e->option->get(PREF_HTTP_PROXY_HOST);
   } else {
@@ -124,3 +130,5 @@ bool FtpInitiateConnectionCommand::nameResolveFinished() const {
     nameResolver->getStatus() == NameResolver::STATUS_ERROR;
 }
 #endif // ENABLE_ASYNC_DNS
+
+} // namespace aria2
diff --git a/src/FtpInitiateConnectionCommand.h b/src/FtpInitiateConnectionCommand.h
index 9bcdd55a..9d6e29ab 100644
--- a/src/FtpInitiateConnectionCommand.h
+++ b/src/FtpInitiateConnectionCommand.h
@@ -37,9 +37,11 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class FtpInitiateConnectionCommand : public AbstractCommand {
 private:
-  NameResolverHandle nameResolver;
+  SharedHandle<NameResolver> nameResolver;
   bool useHttpProxy() const;
   bool useHttpProxyGet() const;
   bool useHttpProxyConnect() const;
@@ -49,8 +51,12 @@ private:
 protected:
   virtual bool executeInternal();
 public:
-  FtpInitiateConnectionCommand(int cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e);
+  FtpInitiateConnectionCommand(int cuid, const SharedHandle<Request>& req,
+			       RequestGroup* requestGroup, DownloadEngine* e);
+
   virtual ~FtpInitiateConnectionCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_INITIATE_CONNECTION_COMMAND_H_
diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc
index 04d77292..31da8250 100644
--- a/src/FtpNegotiationCommand.cc
+++ b/src/FtpNegotiationCommand.cc
@@ -33,20 +33,31 @@
  */
 /* copyright --> */
 #include "FtpNegotiationCommand.h"
+#include "Request.h"
 #include "DownloadEngine.h"
 #include "FtpConnection.h"
 #include "RequestGroup.h"
 #include "PieceStorage.h"
 #include "FtpDownloadCommand.h"
+#include "FileEntry.h"
 #include "DlAbortEx.h"
 #include "message.h"
 #include "prefs.h"
 #include "Util.h"
+#include "Option.h"
+#include "Logger.h"
+#include "Segment.h"
 #include "SingleFileDownloadContext.h"
 #include "DefaultBtProgressInfoFile.h"
 #include "RequestGroupMan.h"
 #include "DownloadFailureException.h"
 #include "ServerHost.h"
+#include "Socket.h"
+#include <stdint.h>
+#include <cassert>
+#include <utility>
+
+namespace aria2 {
 
 FtpNegotiationCommand::FtpNegotiationCommand(int32_t cuid,
 					     const RequestHandle& req,
@@ -275,7 +286,7 @@ bool FtpNegotiationCommand::sendPasv() {
 }
 
 bool FtpNegotiationCommand::recvPasv() {
-  pair<string, int32_t> dest;
+  std::pair<std::string, int32_t> dest;
   int32_t status = ftp->receivePasvResponse(dest);
   if(status == 0) {
     return false;
@@ -393,3 +404,5 @@ bool FtpNegotiationCommand::processSequence(const SegmentHandle& segment) {
   }
   return doNextSequence;
 }
+
+} // namespace aria2
diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h
index 3f158983..da22cdce 100644
--- a/src/FtpNegotiationCommand.h
+++ b/src/FtpNegotiationCommand.h
@@ -37,7 +37,10 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class FtpConnection;
+class SocketCore;
 
 class FtpNegotiationCommand : public AbstractCommand {
 private:
@@ -83,26 +86,28 @@ private:
   bool recvPort();
   bool sendPasv();
   bool recvPasv();
-  bool sendRest(const SegmentHandle& segment);
-  bool sendRestPasv(const SegmentHandle& segment);
+  bool sendRest(const SharedHandle<Segment>& segment);
+  bool sendRestPasv(const SharedHandle<Segment>& segment);
   bool recvRest();
   bool sendRetr();
   bool recvRetr();
-  bool processSequence(const SegmentHandle& segment);
+  bool processSequence(const SharedHandle<Segment>& segment);
 
-  SocketHandle dataSocket;
-  SocketHandle serverSocket;
+  SharedHandle<SocketCore> dataSocket;
+  SharedHandle<SocketCore> serverSocket;
   int32_t sequence;
   FtpConnection* ftp;
 protected:
   virtual bool executeInternal();
 public:
   FtpNegotiationCommand(int32_t cuid,
-			const RequestHandle& req,
+			const SharedHandle<Request>& req,
 			RequestGroup* requestGroup,
 			DownloadEngine* e,
-			const SocketHandle& s);
+			const SharedHandle<SocketCore>& s);
   virtual ~FtpNegotiationCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_NEGOTIATION_COMMAND_H_
diff --git a/src/FtpTunnelRequestCommand.cc b/src/FtpTunnelRequestCommand.cc
index b1ee1d3d..403d4e88 100644
--- a/src/FtpTunnelRequestCommand.cc
+++ b/src/FtpTunnelRequestCommand.cc
@@ -34,6 +34,10 @@
 /* copyright --> */
 #include "FtpTunnelRequestCommand.h"
 #include "FtpTunnelResponseCommand.h"
+#include "Request.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 FtpTunnelRequestCommand::FtpTunnelRequestCommand(int cuid,
 						 const RequestHandle& req,
@@ -48,3 +52,5 @@ Command* FtpTunnelRequestCommand::getNextCommand()
 {
   return new FtpTunnelResponseCommand(cuid, req, _requestGroup, httpConnection, e, socket);
 }
+
+} // namespace aria2
diff --git a/src/FtpTunnelRequestCommand.h b/src/FtpTunnelRequestCommand.h
index 3ce63e2f..535d650b 100644
--- a/src/FtpTunnelRequestCommand.h
+++ b/src/FtpTunnelRequestCommand.h
@@ -37,16 +37,22 @@
 
 #include "AbstractProxyRequestCommand.h"
 
+namespace aria2 {
+
+class SocketCore;
+
 class FtpTunnelRequestCommand : public AbstractProxyRequestCommand {
 public:
   FtpTunnelRequestCommand(int cuid,
-			  const RequestHandle& req,
+			  const SharedHandle<Request>& req,
 			  RequestGroup* requestGroup,
 			  DownloadEngine* e,
-			  const SocketHandle& s);
+			  const SharedHandle<SocketCore>& s);
   virtual ~FtpTunnelRequestCommand();
 
   virtual Command* getNextCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_TUNNEL_REQUEST_COMMAND_H_
diff --git a/src/FtpTunnelResponseCommand.cc b/src/FtpTunnelResponseCommand.cc
index 9167e6d6..121bd24a 100644
--- a/src/FtpTunnelResponseCommand.cc
+++ b/src/FtpTunnelResponseCommand.cc
@@ -34,6 +34,13 @@
 /* copyright --> */
 #include "FtpTunnelResponseCommand.h"
 #include "FtpNegotiationCommand.h"
+#include "Request.h"
+#include "HttpConnection.h"
+#include "HttpRequest.h"
+#include "Segment.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 FtpTunnelResponseCommand::FtpTunnelResponseCommand(int cuid,
 						   const RequestHandle& req,
@@ -49,3 +56,5 @@ Command* FtpTunnelResponseCommand::getNextCommand()
 {
   return new FtpNegotiationCommand(cuid, req, _requestGroup, e, socket);
 }
+
+} // namespace aria2
diff --git a/src/FtpTunnelResponseCommand.h b/src/FtpTunnelResponseCommand.h
index 79b2ec1a..1b5c8a8c 100644
--- a/src/FtpTunnelResponseCommand.h
+++ b/src/FtpTunnelResponseCommand.h
@@ -37,18 +37,24 @@
 
 #include "AbstractProxyResponseCommand.h"
 
+namespace aria2 {
+
+class SocketCore;
+
 class FtpTunnelResponseCommand : public AbstractProxyResponseCommand {
 public:
   FtpTunnelResponseCommand(int cuid,
-			   const RequestHandle& req,
+			   const SharedHandle<Request>& req,
 			   RequestGroup* requestGroup,
-			   const HttpConnectionHandle& httpConnection,
+			   const SharedHandle<HttpConnection>& httpConnection,
 			   DownloadEngine* e,
-			   const SocketHandle& s);
+			   const SharedHandle<SocketCore>& s);
   virtual ~FtpTunnelResponseCommand();
 
   virtual Command* getNextCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_FTP_TUNNEL_RESPONSE_COMMAND_H_
 
diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc
index 59cf547b..abeb55bb 100644
--- a/src/GrowSegment.cc
+++ b/src/GrowSegment.cc
@@ -35,6 +35,8 @@
 #include "GrowSegment.h"
 #include "Piece.h"
 
+namespace aria2 {
+
 GrowSegment::GrowSegment(const PieceHandle& piece):
   _piece(piece), _writtenLength(0) {}
 
@@ -57,3 +59,5 @@ PieceHandle GrowSegment::getPiece() const
 {
   return _piece;
 }
+
+} // namespace aria2
diff --git a/src/GrowSegment.h b/src/GrowSegment.h
index 7bb9a62c..8c01ccf6 100644
--- a/src/GrowSegment.h
+++ b/src/GrowSegment.h
@@ -37,12 +37,14 @@
 
 #include "Segment.h"
 
+namespace aria2 {
+
 class GrowSegment:public Segment {
 private:
-  PieceHandle _piece;
+  SharedHandle<Piece> _piece;
   int32_t _writtenLength;
 public:
-  GrowSegment(const PieceHandle& piece);
+  GrowSegment(const SharedHandle<Piece>& piece);
 
   virtual ~GrowSegment();
 
@@ -90,10 +92,12 @@ public:
 
   virtual void clear();
 
-  virtual PieceHandle getPiece() const;
+  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 de8fca38..c0747347 100644
--- a/src/HandleRegistry.h
+++ b/src/HandleRegistry.h
@@ -35,14 +35,15 @@
 #ifndef _D_HANDLE_REGISTRY_H_
 #define _D_HANDLE_REGISTRY_H_
 
+#include "common.h"
 #include "SharedHandle.h"
 #include <map>
 
-using namespace std;
+namespace aria2 {
 
 template<typename K, typename T>
 class HandleRegistry {
-  typedef map<K, SharedHandle<T> > HandleMap;
+  typedef std::map<K, SharedHandle<T> > HandleMap;
 private:
   HandleMap handleMap;
 public:
@@ -70,4 +71,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_HANDLE_REGISTRY_H_
diff --git a/src/HandshakeExtensionMessage.cc b/src/HandshakeExtensionMessage.cc
index e58a70e3..fe1b5c97 100644
--- a/src/HandshakeExtensionMessage.cc
+++ b/src/HandshakeExtensionMessage.cc
@@ -42,9 +42,12 @@
 #include "MetaFileUtil.h"
 #include "DlAbortEx.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "message.h"
 
-const string HandshakeExtensionMessage::EXTENSION_NAME = "handshake";
+namespace aria2 {
+
+const std::string HandshakeExtensionMessage::EXTENSION_NAME = "handshake";
 
 HandshakeExtensionMessage::HandshakeExtensionMessage():_tcpPort(0),
 						       _btContext(0),
@@ -54,7 +57,7 @@ HandshakeExtensionMessage::HandshakeExtensionMessage():_tcpPort(0),
 
 HandshakeExtensionMessage::~HandshakeExtensionMessage() {}
 
-string HandshakeExtensionMessage::getBencodedData()
+std::string HandshakeExtensionMessage::getBencodedData()
 {
   SharedHandle<Dictionary> dic = new Dictionary();
   if(!_clientVersion.empty()) {
@@ -62,16 +65,16 @@ string HandshakeExtensionMessage::getBencodedData()
     dic->put("v", v);
   }
   if(_tcpPort > 0) {
-    string portStr = Util::itos(_tcpPort);
+    std::string portStr = Util::itos(_tcpPort);
     Data* p = new Data(portStr, true);
     dic->put("p", p);
   }
   Dictionary* exts = new Dictionary();
   dic->put("m", exts);
-  for(map<string, uint8_t>::const_iterator itr = _extensions.begin();
+  for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin();
       itr != _extensions.end(); ++itr) {
-    const map<string, uint8_t>::value_type& vt = *itr;
-    string idStr = Util::uitos((uint32_t)vt.second);
+    const std::map<std::string, uint8_t>::value_type& vt = *itr;
+    std::string idStr = Util::uitos((uint32_t)vt.second);
     exts->put(vt.first, new Data(idStr, true));
   }
   BencodeVisitor v;
@@ -79,18 +82,18 @@ string HandshakeExtensionMessage::getBencodedData()
   return v.getBencodedData();
 }
 
-string HandshakeExtensionMessage::toString() const
+std::string HandshakeExtensionMessage::toString() const
 {
-  string s = getExtensionName();
+  std::string s = getExtensionName();
   if(!_clientVersion.empty()) {
     s += " client="+Util::urlencode(_clientVersion);
   }
   if(_tcpPort > 0) {
     s += ", tcpPort="+Util::itos(_tcpPort);
   }
-  for(map<string, uint8_t>::const_iterator itr = _extensions.begin();
+  for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin();
       itr != _extensions.end(); ++itr) {
-    const map<string, uint8_t>::value_type& vt = *itr;
+    const std::map<std::string, uint8_t>::value_type& vt = *itr;
     s += ", "+vt.first+"="+Util::uitos((uint32_t)vt.second);
   }
   return s;
@@ -101,9 +104,9 @@ void HandshakeExtensionMessage::doReceivedAction()
   if(_tcpPort > 0) {
     _peer->port = _tcpPort;
   }
-  for(map<string, uint8_t>::const_iterator itr = _extensions.begin();
+  for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin();
       itr != _extensions.end(); ++itr) {
-    const map<string, uint8_t>::value_type& vt = *itr;
+    const std::map<std::string, uint8_t>::value_type& vt = *itr;
     _peer->setExtension(vt.first, vt.second);
   }
 }
@@ -118,9 +121,9 @@ void HandshakeExtensionMessage::setBtContext(const BtContextHandle& btContext)
   _btContext = btContext;
 }
 
-uint8_t HandshakeExtensionMessage::getExtensionMessageID(const string& name) const
+uint8_t HandshakeExtensionMessage::getExtensionMessageID(const std::string& name) const
 {
-  map<string, uint8_t>::const_iterator i = _extensions.find(name);
+  std::map<std::string, uint8_t>::const_iterator i = _extensions.find(name);
   if(i == _extensions.end()) {
     return 0;
   } else {
@@ -153,8 +156,8 @@ HandshakeExtensionMessage::create(const char* data, size_t length)
   }
   const Dictionary* m = dynamic_cast<const Dictionary*>(d->get("m"));
   if(m) {
-    const Order& order = m->getOrder();
-    for(Order::const_iterator i = order.begin(); i != order.end(); ++i) {
+    const std::deque<std::string>& order = m->getOrder();
+    for(std::deque<std::string>::const_iterator i = order.begin(); i != order.end(); ++i) {
       const Data* e = dynamic_cast<const Data*>(m->get(*i));
       if(e) {
 	msg->_extensions[*i] = e->toInt();
@@ -163,3 +166,5 @@ HandshakeExtensionMessage::create(const char* data, size_t length)
   }
   return msg;
 }
+
+} // namespace aria2
diff --git a/src/HandshakeExtensionMessage.h b/src/HandshakeExtensionMessage.h
index be929248..aea6563e 100644
--- a/src/HandshakeExtensionMessage.h
+++ b/src/HandshakeExtensionMessage.h
@@ -37,26 +37,27 @@
 
 #include "ExtensionMessage.h"
 #include "BtConstants.h"
+#include <map>
+
+namespace aria2 {
 
 class BtContext;
-typedef SharedHandle<BtContext> BtContextHandle;
 class Peer;
-typedef SharedHandle<Peer> PeerHandle;
+class Logger;
 class HandshakeExtensionMessage;
 typedef SharedHandle<HandshakeExtensionMessage> HandshakeExtensionMessageHandle;
-class Logger;
 
 class HandshakeExtensionMessage:public ExtensionMessage {
 private:
-  string _clientVersion;
+  std::string _clientVersion;
 
   uint16_t _tcpPort;
 
-  map<string, uint8_t> _extensions;
+  std::map<std::string, uint8_t> _extensions;
 
-  BtContextHandle _btContext;
+  SharedHandle<BtContext> _btContext;
 
-  PeerHandle _peer;
+  SharedHandle<Peer> _peer;
 
   const Logger* _logger;
 
@@ -65,30 +66,30 @@ public:
 
   virtual ~HandshakeExtensionMessage();
 
-  virtual string getBencodedData();
+  virtual std::string getBencodedData();
 
   virtual uint8_t getExtensionMessageID()
   {
     return 0;
   }
   
-  virtual const string& getExtensionName() const
+  virtual const std::string& getExtensionName() const
   {
     return EXTENSION_NAME;
   }
 
-  static const string EXTENSION_NAME;
+  static const std::string EXTENSION_NAME;
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual void doReceivedAction();
 
-  void setClientVersion(const string& version)
+  void setClientVersion(const std::string& version)
   {
     _clientVersion = version;
   }
 
-  const string& getClientVersion() const
+  const std::string& getClientVersion() const
   {
     return _clientVersion;
   }
@@ -103,7 +104,7 @@ public:
     return _tcpPort;
   }
 
-  void setExtension(const string& name, uint8_t id)
+  void setExtension(const std::string& name, uint8_t id)
   {
     _extensions[name] = id;
   }
@@ -113,11 +114,11 @@ public:
     _extensions = extensions;
   }
 
-  uint8_t getExtensionMessageID(const string& name) const;
+  uint8_t getExtensionMessageID(const std::string& name) const;
 
-  void setPeer(const PeerHandle& peer);
+  void setPeer(const SharedHandle<Peer>& peer);
 
-  void setBtContext(const BtContextHandle& btContext);
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
   static HandshakeExtensionMessageHandle create(const char* data,
 						size_t dataLength);
@@ -125,4 +126,7 @@ public:
 };
 
 typedef SharedHandle<HandshakeExtensionMessage> HandshakeExtensionMessageHandle;
+
+} // namespace aria2
+
 #endif // _D_HANDSHAKE_EXTENSION_MESSAGE_H_
diff --git a/src/HashMetalinkParserState.cc b/src/HashMetalinkParserState.cc
index 501cc5f8..39a1a8e9 100644
--- a/src/HashMetalinkParserState.cc
+++ b/src/HashMetalinkParserState.cc
@@ -35,18 +35,22 @@
 #include "HashMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void HashMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					   const string& name,
-					   const map<string, string>& attrs)
+					   const std::string& name,
+					   const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void HashMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					 const string& name,
-					 const string& characters)
+					 const std::string& name,
+					 const std::string& characters)
 {
   stm->setHashOfChecksum(characters);
   stm->commitChecksumTransaction();
   stm->setVerificationState();
 }
+
+} // namespace aria2
diff --git a/src/HashMetalinkParserState.h b/src/HashMetalinkParserState.h
index 0d23b0f0..2c187871 100644
--- a/src/HashMetalinkParserState.h
+++ b/src/HashMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class HashMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_HASH_METALINK_PARSER_STATE_H_
diff --git a/src/HaveEraseCommand.cc b/src/HaveEraseCommand.cc
index c901829f..42ba55bb 100644
--- a/src/HaveEraseCommand.cc
+++ b/src/HaveEraseCommand.cc
@@ -38,6 +38,8 @@
 #include "PieceStorage.h"
 #include "RequestGroup.h"
 
+namespace aria2 {
+
 HaveEraseCommand::HaveEraseCommand(int32_t cuid, DownloadEngine* e, int32_t interval)
   :TimeBasedCommand(cuid, e, interval) {}
 
@@ -59,3 +61,5 @@ void HaveEraseCommand::process()
     }
   }
 }
+
+} // namespace aria2
diff --git a/src/HaveEraseCommand.h b/src/HaveEraseCommand.h
index ff713583..8d43dfa6 100644
--- a/src/HaveEraseCommand.h
+++ b/src/HaveEraseCommand.h
@@ -37,6 +37,8 @@
 
 #include "TimeBasedCommand.h"
 
+namespace aria2 {
+
 class HaveEraseCommand : public TimeBasedCommand
 {
 public:
@@ -49,4 +51,6 @@ public:
   virtual void process();
 };
 
+} // namespace aria2
+
 #endif // _D_HAVE_ERASE_COMMAND_H_
diff --git a/src/HelpItem.cc b/src/HelpItem.cc
index 36d6199d..b32c5f09 100644
--- a/src/HelpItem.cc
+++ b/src/HelpItem.cc
@@ -33,12 +33,15 @@
  */
 /* copyright --> */
 #include "HelpItem.h"
+#include <ostream>
+
+namespace aria2 {
 
 #define DEFAULT_MSG   _("                              Default: ")
 #define    TAGS_MSG   _("                              Tags: ")
 #define AVAILABLE_MSG _("                              Available Values: ")
 
-ostream& operator<<(ostream& o, const HelpItem& helpItem)
+std::ostream& operator<<(std::ostream& o, const HelpItem& helpItem)
 {
   o << helpItem._usageText << "\n";
   if(!helpItem._availableValues.empty()) {
@@ -51,8 +54,10 @@ ostream& operator<<(ostream& o, const HelpItem& helpItem)
   return o;
 }
 
-ostream& operator<<(ostream& o, const HelpItemHandle& helpItem)
+std::ostream& operator<<(std::ostream& o, const HelpItemHandle& helpItem)
 {
   o << *helpItem.get();
   return o;
 }
+
+} // namespace aria2
diff --git a/src/HelpItem.h b/src/HelpItem.h
index c2f224b7..79d4c4b9 100644
--- a/src/HelpItem.h
+++ b/src/HelpItem.h
@@ -37,38 +37,43 @@
 
 #include "TaggedItem.h"
 
-class HelpItem;
-typedef SharedHandle<HelpItem> HelpItemHandle;
+namespace aria2 {
 
 class HelpItem:public TaggedItem {
 private:
-  string _usageText;
+  std::string _usageText;
 
-  string _availableValues;
+  std::string _availableValues;
 
-  string _defaultValue;
+  std::string _defaultValue;
 
 public:
-  HelpItem(const string& name, const string& usageText, const string& defaultValue = ""):
+  HelpItem(const std::string& name, const std::string& usageText, const std::string& defaultValue = ""):
     TaggedItem(name),
     _usageText(usageText),
     _defaultValue(defaultValue) {}
 
   virtual ~HelpItem() {}
 
-  void setAvailableValues(const string& availableValues)
+  void setAvailableValues(const std::string& availableValues)
   {
     _availableValues = availableValues;
   }
 
-  const string& getAvailableValues() const
+  const std::string& getAvailableValues() const
   {
     return _availableValues;
   }
 
-  friend ostream& operator<<(ostream& o, const HelpItem& helpItem);
+  friend std::ostream&
+  operator<<(std::ostream& o, const HelpItem& helpItem);
 
-  friend ostream& operator<<(ostream& o, const HelpItemHandle& helpItem);
+  friend std::ostream&
+  operator<<(std::ostream& o, const SharedHandle<HelpItem>& helpItem);
 };
 
+typedef SharedHandle<HelpItem> HelpItemHandle;
+
+} // namespace aria2
+
 #endif // _D_HELP_ITEM_H_
diff --git a/src/HelpItemFactory.cc b/src/HelpItemFactory.cc
index 4c491088..476c3b27 100644
--- a/src/HelpItemFactory.cc
+++ b/src/HelpItemFactory.cc
@@ -40,6 +40,8 @@
 #include "a2io.h"
 #include "help_tags.h"
 
+namespace aria2 {
+
 HelpItemFactory::HelpItemFactory() {}
 
 TagContainerHandle HelpItemFactory::createHelpItems()
@@ -423,3 +425,5 @@ TagContainerHandle HelpItemFactory::createHelpItems()
   }
   return tc;
 }
+
+} // namespace aria2
diff --git a/src/HelpItemFactory.h b/src/HelpItemFactory.h
index 7c2c06a1..5ec53a4a 100644
--- a/src/HelpItemFactory.h
+++ b/src/HelpItemFactory.h
@@ -36,15 +36,19 @@
 #define _D_HELP_ITEM_FACTORY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class TagContainer;
-typedef SharedHandle<TagContainer> TagContainerHandle;
 
 class HelpItemFactory {
 private:
   HelpItemFactory();
 public:
-  static TagContainerHandle createHelpItems();
+  static SharedHandle<TagContainer> createHelpItems();
 };
 
+} // namespace aria2
+
 #endif // _D_HELP_ITEM_FACTORY_H_
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index 072e9f34..5938c915 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -39,19 +39,46 @@
 #include "LogFactory.h"
 #include "DlRetryEx.h"
 #include "DlAbortEx.h"
+#include "Request.h"
+#include "Segment.h"
+#include "HttpRequest.h"
+#include "HttpResponse.h"
+#include "HttpHeaderProcessor.h"
+#include "HttpHeader.h"
+#include "Logger.h"
+#include "Socket.h"
 #include <sstream>
 
+namespace aria2 {
+
+HttpRequestEntry::HttpRequestEntry(const HttpRequestHandle& httpRequest,
+				   const HttpHeaderProcessorHandle& proc):
+  _httpRequest(httpRequest),
+  _proc(proc) {}
+
+HttpRequestEntry::~HttpRequestEntry() {}
+
+HttpRequestHandle HttpRequestEntry::getHttpRequest() const
+{
+  return _httpRequest;
+}
+
+HttpHeaderProcessorHandle HttpRequestEntry::getHttpHeaderProcessor() const
+{
+  return _proc;
+}
+
 HttpConnection::HttpConnection(int32_t cuid,
 			       const SocketHandle& socket,
 			       const Option* op):
   cuid(cuid), socket(socket), option(op), logger(LogFactory::getInstance())
 {}
 
-string HttpConnection::eraseConfidentialInfo(const string& request)
+std::string HttpConnection::eraseConfidentialInfo(const std::string& request)
 {
-  istringstream istr(request);
-  ostringstream ostr;
-  string line;
+  std::istringstream istr(request);
+  std::ostringstream ostr;
+  std::string line;
   while(getline(istr, line)) {
     if(Util::startsWith(line, "Authorization: Basic")) {
       ostr << "Authorization: Basic ********\n";
@@ -66,7 +93,7 @@ string HttpConnection::eraseConfidentialInfo(const string& request)
 
 void HttpConnection::sendRequest(const HttpRequestHandle& httpRequest)
 {
-  string request = httpRequest->createRequest();
+  std::string request = httpRequest->createRequest();
   logger->info(MSG_SENDING_REQUEST, cuid, eraseConfidentialInfo(request).c_str());
   socket->writeData(request.c_str(), request.size());
   outstandingHttpRequests.push_back(new HttpRequestEntry(httpRequest,
@@ -75,7 +102,7 @@ void HttpConnection::sendRequest(const HttpRequestHandle& httpRequest)
 
 void HttpConnection::sendProxyRequest(const HttpRequestHandle& httpRequest)
 {
-  string request = httpRequest->createProxyRequest();
+  std::string request = httpRequest->createProxyRequest();
   logger->info(MSG_SENDING_REQUEST, cuid, eraseConfidentialInfo(request).c_str());
   socket->writeData(request.c_str(), request.size());
   outstandingHttpRequests.push_back(new HttpRequestEntry(httpRequest,
@@ -108,8 +135,8 @@ HttpResponseHandle HttpConnection::receiveResponse()
   // OK, we got all headers.
   logger->info(MSG_RECEIVE_RESPONSE, cuid, proc->getHeaderString().c_str());
 
-  pair<string, HttpHeaderHandle> httpStatusHeader = proc->getHttpStatusHeader();
-  if(Util::toLower(httpStatusHeader.second->getFirst("Connection")).find("close") != string::npos) {
+  std::pair<std::string, HttpHeaderHandle> httpStatusHeader = proc->getHttpStatusHeader();
+  if(Util::toLower(httpStatusHeader.second->getFirst("Connection")).find("close") != std::string::npos) {
     entry->getHttpRequest()->getRequest()->setKeepAlive(false);
   }
 
@@ -135,3 +162,5 @@ bool HttpConnection::isIssued(const SegmentHandle& segment) const
   }
   return false;
 }
+
+} // namespace aria2
diff --git a/src/HttpConnection.h b/src/HttpConnection.h
index edc84070..89e0d18a 100644
--- a/src/HttpConnection.h
+++ b/src/HttpConnection.h
@@ -35,55 +35,52 @@
 #ifndef _D_HTTP_CONNECTION_H_
 #define _D_HTTP_CONNECTION_H_
 
-#include "Segment.h"
-#include "Socket.h"
-#include "Request.h"
-#include "Option.h"
-#include "Logger.h"
 #include "common.h"
-#include "Logger.h"
-#include "HttpResponse.h"
-#include "HttpHeaderProcessor.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class HttpRequest;
+class HttpResponse;
+class HttpHeaderProcessor;
+class Option;
+class Logger;
+class Segment;
+class SocketCore;
 
 class HttpRequestEntry {
 private:
-  HttpRequestHandle _httpRequest;
-  HttpHeaderProcessorHandle _proc;
+  SharedHandle<HttpRequest> _httpRequest;
+  SharedHandle<HttpHeaderProcessor> _proc;
 public:
-  HttpRequestEntry(const HttpRequestHandle& httpRequest,
-		   const HttpHeaderProcessorHandle& proc):
-    _httpRequest(httpRequest),
-    _proc(proc) {}
+  HttpRequestEntry(const SharedHandle<HttpRequest>& httpRequest,
+		   const SharedHandle<HttpHeaderProcessor>& proc);
 
-  ~HttpRequestEntry() {}
+  ~HttpRequestEntry();
 
-  HttpRequestHandle getHttpRequest() const
-  {
-    return _httpRequest;
-  }
+  SharedHandle<HttpRequest> getHttpRequest() const;
 
-  HttpHeaderProcessorHandle getHttpHeaderProcessor() const
-  {
-    return _proc;
-  }
+  SharedHandle<HttpHeaderProcessor> getHttpHeaderProcessor() const;
 };
 
 typedef SharedHandle<HttpRequestEntry> HttpRequestEntryHandle;
-typedef deque<HttpRequestEntryHandle> HttpRequestEntries;
+typedef std::deque<HttpRequestEntryHandle> HttpRequestEntries;
 
 class HttpConnection {
 private:
   int32_t cuid;
-  SocketHandle socket;
+  SharedHandle<SocketCore> socket;
   const Option* option;
   const Logger* logger;
 
   HttpRequestEntries outstandingHttpRequests;
 
-  string eraseConfidentialInfo(const string& request);
+  std::string eraseConfidentialInfo(const std::string& request);
 public:
   HttpConnection(int32_t cuid,
-		 const SocketHandle& socket,
+		 const SharedHandle<SocketCore>& socket,
 		 const Option* op);
 
   /**
@@ -93,12 +90,12 @@ public:
    * HTTP proxy(GET method).
    * @param segment indicates starting postion of the file for downloading
    */
-  void sendRequest(const HttpRequestHandle& httpRequest);
+  void sendRequest(const SharedHandle<HttpRequest>& httpRequest);
 
   /**
    * Sends Http proxy request using CONNECT method.
    */
-  void sendProxyRequest(const HttpRequestHandle& httpRequest);
+  void sendProxyRequest(const SharedHandle<HttpRequest>& httpRequest);
 
   /**
    * Receives HTTP response from the server and returns HttpResponseHandle
@@ -111,9 +108,9 @@ public:
    * 
    * @return HttpResponse or 0 if whole response header is not received
    */
-  HttpResponseHandle receiveResponse();
+  SharedHandle<HttpResponse> receiveResponse();
 
-  HttpRequestHandle getFirstHttpRequest() const
+  SharedHandle<HttpRequest> getFirstHttpRequest() const
   {
     if(outstandingHttpRequests.size() > 0) {
       return outstandingHttpRequests.front()->getHttpRequest();
@@ -122,9 +119,11 @@ public:
     }
   }
 
-  bool isIssued(const SegmentHandle& segment) const;
+  bool isIssued(const SharedHandle<Segment>& segment) const;
 };
 
 typedef SharedHandle<HttpConnection> HttpConnectionHandle;
 
+} // namespace aria2
+
 #endif // _D_HTTP_CONNECTION_H_
diff --git a/src/HttpDownloadCommand.cc b/src/HttpDownloadCommand.cc
index a0635f13..23379ca1 100644
--- a/src/HttpDownloadCommand.cc
+++ b/src/HttpDownloadCommand.cc
@@ -37,9 +37,12 @@
 #include "DownloadEngine.h"
 #include "Request.h"
 #include "HttpRequestCommand.h"
-#include "Util.h"
-#include "message.h"
 #include "HttpConnection.h"
+#include "HttpRequest.h"
+#include "Segment.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 HttpDownloadCommand::HttpDownloadCommand(int cuid,
 					 const RequestHandle req,
@@ -61,3 +64,5 @@ bool HttpDownloadCommand::prepareForNextSegment() {
     return DownloadCommand::prepareForNextSegment();
   }
 }
+
+} // namespace aria2
diff --git a/src/HttpDownloadCommand.h b/src/HttpDownloadCommand.h
index 7a784ee3..2e722f70 100644
--- a/src/HttpDownloadCommand.h
+++ b/src/HttpDownloadCommand.h
@@ -37,24 +37,26 @@
 
 #include "DownloadCommand.h"
 
+namespace aria2 {
+
 class HttpConnection;
-typedef SharedHandle<HttpConnection> HttpConnectionHandle;
+class SocketCore;
 
 class HttpDownloadCommand : public DownloadCommand {
 private:
-  HttpConnectionHandle _httpConnection;
+  SharedHandle<HttpConnection> _httpConnection;
 protected:
   virtual bool prepareForNextSegment();
 public:
   HttpDownloadCommand(int cuid,
-		      const RequestHandle req,
+		      const SharedHandle<Request> req,
 		      RequestGroup* requestGroup,
-		      const HttpConnectionHandle& httpConnection,
+		      const SharedHandle<HttpConnection>& httpConnection,
 		      DownloadEngine* e,
-		      const SocketHandle& s);
+		      const SharedHandle<SocketCore>& s);
   virtual ~HttpDownloadCommand();
 };
 
-#endif // _D_HTTP_DOWNLOAD_COMMAND_H_
+} // namespace aria2
 
-  
+#endif // _D_HTTP_DOWNLOAD_COMMAND_H_
diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc
index 630fcec1..571b399b 100644
--- a/src/HttpHeader.cc
+++ b/src/HttpHeader.cc
@@ -33,19 +33,22 @@
  */
 /* copyright --> */
 #include "HttpHeader.h"
+#include "Range.h"
 #include "Util.h"
 
-void HttpHeader::put(const string& name, const string& value) {
-  multimap<string, string>::value_type vt(Util::toLower(name), value);
+namespace aria2 {
+
+void HttpHeader::put(const std::string& name, const std::string& value) {
+  std::multimap<std::string, std::string>::value_type vt(Util::toLower(name), value);
   table.insert(vt);
 }
 
-bool HttpHeader::defined(const string& name) const {
+bool HttpHeader::defined(const std::string& name) const {
   return table.count(Util::toLower(name)) >= 1;
 }
 
-string HttpHeader::getFirst(const string& name) const {
-  multimap<string, string>::const_iterator itr = table.find(Util::toLower(name));
+std::string HttpHeader::getFirst(const std::string& name) const {
+  std::multimap<std::string, std::string>::const_iterator itr = table.find(Util::toLower(name));
   if(itr == table.end()) {
     return "";
   } else {
@@ -53,20 +56,20 @@ string HttpHeader::getFirst(const string& name) const {
   }
 }
 
-Strings HttpHeader::get(const string& name) const {
-  Strings v;
-  for(multimap<string, string>::const_iterator itr = table.find(Util::toLower(name)); itr != table.end(); itr++) {
+std::deque<std::string> HttpHeader::get(const std::string& name) const {
+  std::deque<std::string> v;
+  for(std::multimap<std::string, std::string>::const_iterator itr = table.find(Util::toLower(name)); itr != table.end(); itr++) {
     v.push_back((*itr).second);
   }
   return v;
 }
 
-int32_t HttpHeader::getFirstAsInt(const string& name) const {
+int32_t HttpHeader::getFirstAsInt(const std::string& name) const {
   return getFirstAsLLInt(name);
 }
 
-int64_t HttpHeader::getFirstAsLLInt(const string& name) const {
-  string value = getFirst(name);
+int64_t HttpHeader::getFirstAsLLInt(const std::string& name) const {
+  std::string value = getFirst(name);
   if(value == "") {
     return 0;
   } else {
@@ -76,9 +79,9 @@ int64_t HttpHeader::getFirstAsLLInt(const string& name) const {
 
 RangeHandle HttpHeader::getRange() const
 {
-  string rangeStr = getFirst("Content-Range");
+  std::string rangeStr = getFirst("Content-Range");
   if(rangeStr == "") {
-    string contentLengthStr = getFirst("Content-Length");
+    std::string contentLengthStr = getFirst("Content-Length");
     if(contentLengthStr == "") {
       return new Range(0, 0, 0);
     } else {
@@ -86,13 +89,13 @@ RangeHandle HttpHeader::getRange() const
       return new Range(0, contentLength-1, contentLength);
     }
   }
-  string::size_type rangeSpecIndex = rangeStr.find("bytes ");
-  if(rangeSpecIndex == string::npos) {
+  std::string::size_type rangeSpecIndex = rangeStr.find("bytes ");
+  if(rangeSpecIndex == std::string::npos) {
     return new Range(0, 0, 0);
   }
-  pair<string, string> rangePair;
+  std::pair<std::string, std::string> rangePair;
   Util::split(rangePair, rangeStr.substr(rangeSpecIndex+6), '/');
-  pair<string, string> startEndBytePair;
+  std::pair<std::string, std::string> startEndBytePair;
   Util::split(startEndBytePair, rangePair.first, '-');
 
   int64_t startByte = STRTOLL(startEndBytePair.first.c_str());
@@ -101,3 +104,5 @@ RangeHandle HttpHeader::getRange() const
 
   return new Range(startByte, endByte, entityLength);
 }
+
+} // namespace aria2
diff --git a/src/HttpHeader.h b/src/HttpHeader.h
index 8b90f985..b2353072 100644
--- a/src/HttpHeader.h
+++ b/src/HttpHeader.h
@@ -36,28 +36,34 @@
 #define _D_HTTP_HEADER_H_
 
 #include "common.h"
-#include "Range.h"
+#include "SharedHandle.h"
 #include <map>
 #include <deque>
 #include <string>
 
+namespace aria2 {
+
+class Range;
+
 class HttpHeader {
 private:
-  multimap<string, string> table;
+  std::multimap<std::string, std::string> table;
 public:
   HttpHeader() {}
   ~HttpHeader() {}
 
-  void put(const string& name, const string& value);
-  bool defined(const string& name) const;
-  string getFirst(const string& name) const;
-  Strings get(const string& name) const;
-  int32_t getFirstAsInt(const string& name) const;
-  int64_t getFirstAsLLInt(const string& name) const;
+  void put(const std::string& name, const std::string& value);
+  bool defined(const std::string& name) const;
+  std::string getFirst(const std::string& name) const;
+  std::deque<std::string> get(const std::string& name) const;
+  int32_t getFirstAsInt(const std::string& name) const;
+  int64_t getFirstAsLLInt(const std::string& name) const;
 
-  RangeHandle getRange() const;
+  SharedHandle<Range> getRange() const;
 };
 
 typedef SharedHandle<HttpHeader> HttpHeaderHandle;
 
+} // namespace std;
+
 #endif // _D_HTTP_HEADER_H_
diff --git a/src/HttpHeaderProcessor.cc b/src/HttpHeaderProcessor.cc
index 8268f45b..0bd540eb 100644
--- a/src/HttpHeaderProcessor.cc
+++ b/src/HttpHeaderProcessor.cc
@@ -33,18 +33,25 @@
  */
 /* copyright --> */
 #include "HttpHeaderProcessor.h"
+#include "HttpHeader.h"
 #include "message.h"
 #include "Util.h"
 #include "DlRetryEx.h"
 #include "DlAbortEx.h"
 
+namespace aria2 {
+
+HttpHeaderProcessor::HttpHeaderProcessor():_limit(4096) {}
+
+HttpHeaderProcessor::~HttpHeaderProcessor() {}
+
 void HttpHeaderProcessor::update(const char* data, int32_t length)
 {
   checkHeaderLimit(length);
   strm.write(data, length);
 }
 
-void HttpHeaderProcessor::update(const string& data)
+void HttpHeaderProcessor::update(const std::string& data)
 {
   checkHeaderLimit(data.size());
   strm << data;
@@ -52,7 +59,7 @@ void HttpHeaderProcessor::update(const string& data)
 
 void HttpHeaderProcessor::checkHeaderLimit(int32_t incomingLength)
 {
-  strm.seekg(0, ios::end);
+  strm.seekg(0, std::ios::end);
   if((int32_t)strm.tellg()+incomingLength > _limit) {
     throw new DlAbortEx("Too large http header");
   }
@@ -60,8 +67,8 @@ void HttpHeaderProcessor::checkHeaderLimit(int32_t incomingLength)
 
 bool HttpHeaderProcessor::eoh() const
 {
-  string str = strm.str();
-  if(str.find("\r\n\r\n") == string::npos && str.find("\n\n") == string::npos) {
+  std::string str = strm.str();
+  if(str.find("\r\n\r\n") == std::string::npos && str.find("\n\n") == std::string::npos) {
     return false;
   } else {
     return true;
@@ -70,11 +77,11 @@ bool HttpHeaderProcessor::eoh() const
 
 int32_t HttpHeaderProcessor::getPutBackDataLength() const
 {
-  string str = strm.str();
-  string::size_type delimpos = string::npos;
-  if((delimpos = str.find("\r\n\r\n")) != string::npos) {
+  std::string str = strm.str();
+  std::string::size_type delimpos = std::string::npos;
+  if((delimpos = str.find("\r\n\r\n")) != std::string::npos) {
     return str.size()-(delimpos+4);
-  } else if((delimpos = str.find("\n\n")) != string::npos) {
+  } else if((delimpos = str.find("\n\n")) != std::string::npos) {
     return str.size()-(delimpos+2);
   } else {
     return 0;
@@ -86,39 +93,40 @@ void HttpHeaderProcessor::clear()
   strm.str("");
 }
 
-pair<string, HttpHeaderHandle> HttpHeaderProcessor::getHttpStatusHeader()
+std::pair<std::string, HttpHeaderHandle> HttpHeaderProcessor::getHttpStatusHeader()
 {
-  strm.seekg(0, ios::beg);
-  string line;
+  strm.seekg(0, std::ios::beg);
+  std::string line;
   getline(strm, line);  
   // check HTTP status value
   if(line.size() <= 12) {
     throw new DlRetryEx(EX_NO_STATUS_HEADER);
   }
-  string status = line.substr(9, 3);
+  std::string status = line.substr(9, 3);
   HttpHeaderHandle httpHeader = new HttpHeader();
   while(getline(strm, line)) {
     line = Util::trim(line);
     if(line.empty()) {
       break;
     }
-    pair<string, string> hp;
+    std::pair<std::string, std::string> hp;
     Util::split(hp, line, ':');
     httpHeader->put(hp.first, hp.second);
   }
   
-  return pair<string, HttpHeaderHandle>(status, httpHeader);
+  return std::pair<std::string, HttpHeaderHandle>(status, httpHeader);
 }
 
-string HttpHeaderProcessor::getHeaderString() const
+std::string HttpHeaderProcessor::getHeaderString() const
 {
-  string str = strm.str();
-  string::size_type delimpos = string::npos;
-  if((delimpos = str.find("\r\n\r\n")) != string::npos ||
-     (delimpos = str.find("\n\n")) != string::npos) {
+  std::string str = strm.str();
+  std::string::size_type delimpos = std::string::npos;
+  if((delimpos = str.find("\r\n\r\n")) != std::string::npos ||
+     (delimpos = str.find("\n\n")) != std::string::npos) {
     return str.substr(0, delimpos);
   } else {
     return str;
   }
 }
 
+} // namespace aria2
diff --git a/src/HttpHeaderProcessor.h b/src/HttpHeaderProcessor.h
index 51491602..e0a5dda7 100644
--- a/src/HttpHeaderProcessor.h
+++ b/src/HttpHeaderProcessor.h
@@ -36,25 +36,29 @@
 #define _D_HTTP_HEADER_PROCESSOR_H_
 
 #include "common.h"
-#include "HttpHeader.h"
+#include "SharedHandle.h"
 #include <utility>
 #include <sstream>
 
+namespace aria2 {
+
+class HttpHeader;
+
 class HttpHeaderProcessor {
 private:
-  stringstream strm;
+  std::stringstream strm;
   int32_t _limit;
 
   void checkHeaderLimit(int32_t incomingLength);
 
 public:
-  HttpHeaderProcessor():_limit(4096) {}
+  HttpHeaderProcessor();
 
-  ~HttpHeaderProcessor() {}
+  ~HttpHeaderProcessor();
 
   void update(const char* data, int32_t length);
 
-  void update(const string& data);
+  void update(const std::string& data);
 
   /**
    * Returns true if end of header is reached.
@@ -66,9 +70,9 @@ public:
    */
   int32_t getPutBackDataLength() const;
 
-  pair<string, HttpHeaderHandle> getHttpStatusHeader();
+  std::pair<std::string, SharedHandle<HttpHeader> > getHttpStatusHeader();
 
-  string getHeaderString() const;
+  std::string getHeaderString() const;
 
   void clear();
 
@@ -80,4 +84,6 @@ public:
 
 typedef SharedHandle<HttpHeaderProcessor> HttpHeaderProcessorHandle;
 
+} // namespace aria2
+
 #endif // _D_HTTP_HEADER_PROCESSOR_H_
diff --git a/src/HttpInitiateConnectionCommand.cc b/src/HttpInitiateConnectionCommand.cc
index ece0b01f..9bf92132 100644
--- a/src/HttpInitiateConnectionCommand.cc
+++ b/src/HttpInitiateConnectionCommand.cc
@@ -34,17 +34,22 @@
 /* copyright --> */
 #include "HttpInitiateConnectionCommand.h"
 #include "NameResolver.h"
-#include "DownloadEngine.h"
-#include "Option.h"
 #include "Request.h"
+#include "DownloadEngine.h"
+#include "HttpConnection.h"
+#include "HttpRequest.h"
+#include "Segment.h"
 #include "HttpRequestCommand.h"
 #include "HttpProxyRequestCommand.h"
-#include "Util.h"
 #include "DlAbortEx.h"
-#include "DlRetryEx.h"
+#include "Option.h"
+#include "Util.h"
+#include "Logger.h"
+#include "Socket.h"
 #include "message.h"
 #include "prefs.h"
-#include "HttpConnection.h"
+
+namespace aria2 {
 
 HttpInitiateConnectionCommand::HttpInitiateConnectionCommand(int cuid,
 							     const RequestHandle& req,
@@ -65,7 +70,7 @@ HttpInitiateConnectionCommand::~HttpInitiateConnectionCommand() {
 }
 
 bool HttpInitiateConnectionCommand::executeInternal() {
-  string hostname;
+  std::string hostname;
   if(useProxy()) {
     hostname = e->option->get(PREF_HTTP_PROXY_HOST);
   } else {
@@ -122,3 +127,5 @@ bool HttpInitiateConnectionCommand::nameResolveFinished() const {
     nameResolver->getStatus() == NameResolver::STATUS_ERROR;
 }
 #endif // ENABLE_ASYNC_DNS
+
+} // namespace aria2
diff --git a/src/HttpInitiateConnectionCommand.h b/src/HttpInitiateConnectionCommand.h
index fa0fa596..b9579c38 100644
--- a/src/HttpInitiateConnectionCommand.h
+++ b/src/HttpInitiateConnectionCommand.h
@@ -37,9 +37,11 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class HttpInitiateConnectionCommand : public AbstractCommand {
 private:
-  NameResolverHandle nameResolver;
+  SharedHandle<NameResolver> nameResolver;
   bool useProxy();
   bool useProxyGet();
   bool useProxyTunnel();
@@ -57,10 +59,15 @@ protected:
   virtual bool nameResolveFinished() const;
 #endif // ENABLE_ASYNC_DNS
 public:
-  HttpInitiateConnectionCommand(int cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e);
+  HttpInitiateConnectionCommand(int cuid, const SharedHandle<Request>& req,
+				RequestGroup* requestGroup,
+				DownloadEngine* e);
+
   virtual ~HttpInitiateConnectionCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_HTTP_INITIATE_CONNECTION_COMMAND_H_
 
 
diff --git a/src/HttpProxyRequestCommand.cc b/src/HttpProxyRequestCommand.cc
index 65a68bf7..bf6621c1 100644
--- a/src/HttpProxyRequestCommand.cc
+++ b/src/HttpProxyRequestCommand.cc
@@ -34,6 +34,10 @@
 /* copyright --> */
 #include "HttpProxyRequestCommand.h"
 #include "HttpProxyResponseCommand.h"
+#include "Request.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 HttpProxyRequestCommand::HttpProxyRequestCommand(int cuid,
 						 const RequestHandle& req,
@@ -48,3 +52,5 @@ Command* HttpProxyRequestCommand::getNextCommand()
 {
   return new HttpProxyResponseCommand(cuid, req, _requestGroup, httpConnection, e, socket);
 }
+
+} // namespace aria2
diff --git a/src/HttpProxyRequestCommand.h b/src/HttpProxyRequestCommand.h
index 975e2574..efade521 100644
--- a/src/HttpProxyRequestCommand.h
+++ b/src/HttpProxyRequestCommand.h
@@ -37,16 +37,22 @@
 
 #include "AbstractProxyRequestCommand.h"
 
+namespace aria2 {
+
+class SocketCore;
+
 class HttpProxyRequestCommand : public AbstractProxyRequestCommand {
 public:
   HttpProxyRequestCommand(int cuid,
-			  const RequestHandle& req,
+			  const SharedHandle<Request>& req,
 			  RequestGroup* requestGroup,
 			  DownloadEngine* e,
-			  const SocketHandle& s);
+			  const SharedHandle<SocketCore>& s);
   virtual ~HttpProxyRequestCommand();
 
   virtual Command* getNextCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_HTTP_PROXY_REQUEST_COMMAND_H_
diff --git a/src/HttpProxyResponseCommand.cc b/src/HttpProxyResponseCommand.cc
index 0c2b438a..65bdff2d 100644
--- a/src/HttpProxyResponseCommand.cc
+++ b/src/HttpProxyResponseCommand.cc
@@ -34,6 +34,13 @@
 /* copyright --> */
 #include "HttpProxyResponseCommand.h"
 #include "HttpRequestCommand.h"
+#include "Request.h"
+#include "HttpConnection.h"
+#include "HttpRequest.h"
+#include "Segment.h"
+#include "Socket.h"
+
+namespace aria2 {
 
 HttpProxyResponseCommand::HttpProxyResponseCommand(int cuid,
 						   const RequestHandle& req,
@@ -49,3 +56,5 @@ Command* HttpProxyResponseCommand::getNextCommand()
 {
   return new HttpRequestCommand(cuid, req, _requestGroup, httpConnection, e, socket);
 }
+
+} // namespace aria2
diff --git a/src/HttpProxyResponseCommand.h b/src/HttpProxyResponseCommand.h
index 3cdd5fa3..2d9a081f 100644
--- a/src/HttpProxyResponseCommand.h
+++ b/src/HttpProxyResponseCommand.h
@@ -37,17 +37,23 @@
 
 #include "AbstractProxyResponseCommand.h"
 
+namespace aria2 {
+
+class SocketCore;
+
 class HttpProxyResponseCommand : public AbstractProxyResponseCommand {
 public:
   HttpProxyResponseCommand(int cuid,
-			   const RequestHandle& req,
+			   const SharedHandle<Request>& req,
 			   RequestGroup* requestGroup,
-			   const HttpConnectionHandle& httpConnection,
+			   const SharedHandle<HttpConnection>& httpConnection,
 			   DownloadEngine* e,
-			   const SocketHandle& s);
+			   const SharedHandle<SocketCore>& s);
   virtual ~HttpProxyResponseCommand();
 
   virtual Command* getNextCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_HTTP_PROXY_RESPONSE_COMMAND_H_
diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc
index 7bd647a5..27e154c3 100644
--- a/src/HttpRequest.cc
+++ b/src/HttpRequest.cc
@@ -33,12 +33,73 @@
  */
 /* copyright --> */
 #include "HttpRequest.h"
+#include "Request.h"
+#include "Segment.h"
+#include "Range.h"
+#include "Cookie.h"
+#include "CookieBox.h"
+#include "Option.h"
 #include "Util.h"
 #include "Base64.h"
 #include "prefs.h"
 #include "AuthConfigFactory.h"
 #include "AuthConfig.h"
 
+namespace aria2 {
+
+std::string HttpRequest::USER_AGENT = "aria2";
+
+HttpRequest::HttpRequest():request(0),
+			   segment(0),
+			   entityLength(0),
+			   authEnabled(false),
+			   proxyEnabled(false),
+			   proxyAuthEnabled(false),
+			   userAgent(USER_AGENT)
+{}
+
+SharedHandle<Segment> HttpRequest::getSegment() const
+{
+  return segment;
+}
+
+void HttpRequest::setSegment(const SharedHandle<Segment>& segment)
+{
+  this->segment = segment;
+}
+
+void HttpRequest::setRequest(const SharedHandle<Request>& request)
+{
+  this->request = request;
+}
+
+SharedHandle<Request> HttpRequest::getRequest() const
+{
+  return request;
+}
+
+int64_t HttpRequest::getStartByte() const
+{
+  if(segment.isNull()) {
+    return 0;
+  } else {
+    return segment->getPositionToWrite();
+  }
+}
+
+int64_t HttpRequest::getEndByte() const
+{
+  if(segment.isNull() || request.isNull()) {
+    return 0;
+  } else {
+    if(request->isKeepAlive()) {
+      return segment->getPosition()+segment->getLength()-1;
+    } else {
+      return 0;
+    }
+  }
+}
+
 RangeHandle HttpRequest::getRange() const
 {
   // content-length is always 0
@@ -65,14 +126,14 @@ bool HttpRequest::isRangeSatisfied(const RangeHandle& range) const
   }  
 }
 
-string HttpRequest::getHostText(const string& host, int32_t port) const
+std::string HttpRequest::getHostText(const std::string& host, int32_t port) const
 {
   return  host+(port == 80 || port == 443 ? "" : ":"+Util::llitos(port));
 }
 
-string HttpRequest::createRequest() const
+std::string HttpRequest::createRequest() const
 {
-  string requestLine = "GET ";
+  std::string requestLine = "GET ";
   if(getProtocol() == "ftp" || proxyEnabled) {
     requestLine += getCurrentURI();
   } else {
@@ -84,7 +145,7 @@ string HttpRequest::createRequest() const
     requestLine += getFile();
   }
   requestLine +=
-    string(" HTTP/1.1\r\n")+
+    std::string(" HTTP/1.1\r\n")+
     "User-Agent: "+userAgent+"\r\n"+
     "Accept: */*\r\n"+        /* */
     "Host: "+getHostText(getHost(), getPort())+"\r\n"+
@@ -119,7 +180,7 @@ string HttpRequest::createRequest() const
   if(getPreviousURI().size()) {
     requestLine += "Referer: "+getPreviousURI()+"\r\n";
   }
-  string cookiesValue;
+  std::string cookiesValue;
   Cookies cookies = request->cookieBox->criteriaFind(getHost(),
 						     getDir(),
 						     time(0),
@@ -129,17 +190,17 @@ string HttpRequest::createRequest() const
     cookiesValue += (*itr).toString()+";";
   }
   if(cookiesValue.size()) {
-    requestLine += string("Cookie: ")+cookiesValue+"\r\n";
+    requestLine += std::string("Cookie: ")+cookiesValue+"\r\n";
   }
   requestLine += "\r\n";
   return requestLine;
 }
 
-string HttpRequest::createProxyRequest() const
+std::string HttpRequest::createProxyRequest() const
 {
-  string requestLine =
-    string("CONNECT ")+getHost()+":"+Util::itos(getPort())+
-    string(" HTTP/1.1\r\n")+
+  std::string requestLine =
+    std::string("CONNECT ")+getHost()+":"+Util::itos(getPort())+
+    std::string(" HTTP/1.1\r\n")+
     "User-Agent: "+userAgent+"\r\n"+
     "Host: "+getHost()+":"+Util::itos(getPort())+"\r\n";
   if(request->isKeepAlive()) {
@@ -154,7 +215,7 @@ string HttpRequest::createProxyRequest() const
   return requestLine;
 }
 
-string HttpRequest::getProxyAuthString() const {
+std::string HttpRequest::getProxyAuthString() const {
   return "Proxy-Authorization: Basic "+
     Base64::encode(AuthConfigFactorySingleton::instance()->createAuthConfigForHttpProxy(request)->getAuthText())+"\r\n";
 }
@@ -167,3 +228,45 @@ void HttpRequest::configure(const Option* option)
     option->get(PREF_HTTP_PROXY_METHOD) == V_GET;
   proxyAuthEnabled = option->get(PREF_HTTP_PROXY_AUTH_ENABLED) == V_TRUE;
 }
+
+std::string HttpRequest::getPreviousURI() const
+{
+  return request->getPreviousUrl();
+}
+
+std::string HttpRequest::getHost() const
+{
+  return request->getHost();
+}
+
+int32_t HttpRequest::getPort() const
+{
+  return request->getPort();
+}
+
+std::string HttpRequest::getMethod() const
+{
+  return request->getMethod();
+}
+
+std::string HttpRequest::getProtocol() const
+{
+  return request->getProtocol();
+}
+
+std::string HttpRequest::getCurrentURI() const
+{
+  return request->getCurrentUrl();
+}
+  
+std::string HttpRequest::getDir() const
+{
+  return request->getDir();
+}
+
+std::string HttpRequest::getFile() const
+{
+  return request->getFile();
+}
+
+} // namespace aria2
diff --git a/src/HttpRequest.h b/src/HttpRequest.h
index 488bacd3..20f4915a 100644
--- a/src/HttpRequest.h
+++ b/src/HttpRequest.h
@@ -36,17 +36,25 @@
 #define _D_HTTP_REQUEST_H_
 
 #include "common.h"
-#include "Segment.h"
-#include "Range.h"
-#include "Request.h"
-#include "Option.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class Request;
+class Segment;
+class Range;
+class Option;
 
 class HttpRequest {
 private:
+  
+  static std::string USER_AGENT;
 
-  RequestHandle request;
+  SharedHandle<Request> request;
 
-  SegmentHandle segment;
+  SharedHandle<Segment> segment;
 
   int64_t entityLength;
 
@@ -56,36 +64,20 @@ private:
 
   bool proxyAuthEnabled;
 
-  string userAgent;
+  std::string userAgent;
 
-  string getHostText(const string& host, int32_t port) const;
+  std::string getHostText(const std::string& host, int32_t port) const;
 
-  string getProxyAuthString() const;
+  std::string getProxyAuthString() const;
 
 public:
-  HttpRequest():request(0),
-		segment(0),
-		entityLength(0),
-		authEnabled(false),
-		proxyEnabled(false),
-		proxyAuthEnabled(false),
-		userAgent(USER_AGENT)
-  {}
+  HttpRequest();
 
-  SegmentHandle getSegment() const
-  {
-    return segment;
-  }
+  SharedHandle<Segment> getSegment() const;
 
-  void setSegment(const SegmentHandle& segment)
-  {
-    this->segment = segment;
-  }
+  void setSegment(const SharedHandle<Segment>& segment);
 
-  void setRequest(const RequestHandle& request)
-  {
-    this->request = request;
-  }
+  void setRequest(const SharedHandle<Request>& request);
 
   /**
    * entityLength is used in isRangeSatisfied() method.
@@ -100,92 +92,47 @@ public:
     return entityLength;
   }
 
-  string getHost() const
-  {
-    return request->getHost();
-  }
+  std::string getHost() const;
 
-  int32_t getPort() const
-  {
-    return request->getPort();
-  }
+  int32_t getPort() const;
 
-  string getMethod() const
-  {
-    return request->getMethod();
-  }
+  std::string getMethod() const;
 
-  string getProtocol() const
-  {
-    return request->getProtocol();
-  }
+  std::string getProtocol() const;
 
-  string getCurrentURI() const
-  {
-    return request->getCurrentUrl();
-  }
+  std::string getCurrentURI() const;
   
-  string getDir() const
-  {
-    return request->getDir();
-  }
+  std::string getDir() const;
 
-  string getFile() const
-  {
-    return request->getFile();
-  }
+  std::string getFile() const;
 
-  string getPreviousURI() const
-  {
-    return request->getPreviousUrl();
-  }
+  std::string getPreviousURI() const;
 
-  RangeHandle getRange() const;
+  SharedHandle<Range> getRange() const;
 
   /**
    * Inspects whether the specified response range is satisfiable
    * with request range.
    */
-  bool isRangeSatisfied(const RangeHandle& range) const;
+  bool isRangeSatisfied(const SharedHandle<Range>& range) const;
 
-  RequestHandle getRequest() const
-  {
-    return request;
-  }
+  SharedHandle<Request> getRequest() const;
 
-  int64_t getStartByte() const
-  {
-    if(segment.isNull()) {
-      return 0;
-    } else {
-      return segment->getPositionToWrite();
-    }
-  }
+  int64_t getStartByte() const;
 
-  int64_t getEndByte() const
-  {
-    if(segment.isNull() || request.isNull()) {
-      return 0;
-    } else {
-      if(request->isKeepAlive()) {
-	return segment->getPosition()+segment->getLength()-1;
-      } else {
-	return 0;
-      }
-    }
-  }
+  int64_t getEndByte() const;
 
   /**
    * Returns string representation of http request.
    * It usually starts with "GET ..." and ends with "\r\n".
    */
-  string createRequest() const;
+  std::string createRequest() const;
 
   /**
    * Returns string representation of http tunnel request.
    * It usually starts with "CONNECT ..." and ends with "\r\n".
    */
-  string createProxyRequest() const;
+  std::string createProxyRequest() const;
 
   /**
    * Configures this object with option.
@@ -213,13 +160,15 @@ public:
     this->authEnabled = authEnabled;
   }
 
-  void setUserAgent(const string& userAgent)
+  void setUserAgent(const std::string& userAgent)
   {
     this->userAgent = userAgent;
   }
 };
 
 typedef SharedHandle<HttpRequest> HttpRequestHandle;
-typedef deque<HttpRequestHandle> HttpRequests;
+typedef std::deque<HttpRequestHandle> HttpRequests;
+
+} // namespace aria2
 
 #endif // _D_HTTP_REQUEST_H_
diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc
index f61ca2a5..3e845e41 100644
--- a/src/HttpRequestCommand.cc
+++ b/src/HttpRequestCommand.cc
@@ -33,12 +33,19 @@
  */
 /* copyright --> */
 #include "HttpRequestCommand.h"
+#include "Request.h"
 #include "DownloadEngine.h"
 #include "RequestGroup.h"
 #include "HttpResponseCommand.h"
 #include "HttpConnection.h"
-#include "prefs.h"
+#include "HttpRequest.h"
 #include "SegmentMan.h"
+#include "Segment.h"
+#include "Option.h"
+#include "Socket.h"
+#include "prefs.h"
+
+namespace aria2 {
 
 HttpRequestCommand::HttpRequestCommand(int cuid,
 				       const RequestHandle& req,
@@ -100,3 +107,5 @@ bool HttpRequestCommand::executeInternal() {
   e->commands.push_back(command);
   return true;
 }
+
+} // namespace aria2
diff --git a/src/HttpRequestCommand.h b/src/HttpRequestCommand.h
index c318dddb..f406ce34 100644
--- a/src/HttpRequestCommand.h
+++ b/src/HttpRequestCommand.h
@@ -37,22 +37,26 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class HttpConnection;
-typedef SharedHandle<HttpConnection> HttpConnectionHandle;
+class SocketCore;
 
 class HttpRequestCommand:public AbstractCommand {
 private:
-  HttpConnectionHandle _httpConnection;
+  SharedHandle<HttpConnection> _httpConnection;
 protected:
   virtual bool executeInternal();
 public:
   HttpRequestCommand(int cuid,
-		     const RequestHandle& req,
+		     const SharedHandle<Request>& req,
 		     RequestGroup* requestGroup,
-		     const HttpConnectionHandle& httpConnection,
+		     const SharedHandle<HttpConnection>& httpConnection,
 		     DownloadEngine* e,
-		     const SocketHandle& s);
+		     const SharedHandle<SocketCore>& s);
   virtual ~HttpRequestCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_HTTP_REQUEST_COMMAND_H_
diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc
index a5e95d4a..99322b5b 100644
--- a/src/HttpResponse.cc
+++ b/src/HttpResponse.cc
@@ -33,10 +33,30 @@
  */
 /* copyright --> */
 #include "HttpResponse.h"
+#include "Request.h"
+#include "Segment.h"
+#include "CookieBox.h"
+#include "HttpRequest.h"
+#include "HttpHeader.h"
+#include "Range.h"
+#include "LogFactory.h"
+#include "Logger.h"
 #include "ChunkedEncoding.h"
 #include "Util.h"
 #include "message.h"
 #include "DlAbortEx.h"
+#include <deque>
+
+namespace aria2 {
+
+HttpResponse::HttpResponse():cuid(0),
+			     status(0),
+			     httpRequest(0),
+			     httpHeader(0),
+			     logger(LogFactory::getInstance())
+{}
+
+HttpResponse::~HttpResponse() {}
 
 void HttpResponse::validateResponse() const
 {
@@ -71,12 +91,12 @@ void HttpResponse::validateResponse() const
   }
 }
 
-string HttpResponse::determinFilename() const
+std::string HttpResponse::determinFilename() const
 {
-  string contentDisposition =
+  std::string contentDisposition =
     Util::getContentDispositionFilename(httpHeader->getFirst("Content-Disposition"));
   if(contentDisposition.empty()) {
-    return Util::urldecode(httpRequest->getRequest()->getFile());
+    return Util::urldecode(httpRequest->getFile());
   } else {
     logger->info(MSG_CONTENT_DISPOSITION_DETECTED,
 		 cuid, contentDisposition.c_str());
@@ -86,10 +106,10 @@ string HttpResponse::determinFilename() const
 
 void HttpResponse::retrieveCookie()
 {
-  Strings v = httpHeader->get("Set-Cookie");
-  for(Strings::const_iterator itr = v.begin(); itr != v.end(); itr++) {
-    string domain = httpRequest->getRequest()->getHost();
-    string path = httpRequest->getDir();
+  std::deque<std::string> v = httpHeader->get("Set-Cookie");
+  for(std::deque<std::string>::const_iterator itr = v.begin(); itr != v.end(); itr++) {
+    std::string domain = httpRequest->getHost();
+    std::string path = httpRequest->getDir();
     httpRequest->getRequest()->cookieBox->add(*itr, domain, path);
   }
 }
@@ -105,7 +125,7 @@ void HttpResponse::processRedirect()
 
 }
 
-string HttpResponse::getRedirectURI() const
+std::string HttpResponse::getRedirectURI() const
 {
   return httpHeader->getFirst("Location");
 }
@@ -115,7 +135,7 @@ bool HttpResponse::isTransferEncodingSpecified() const
   return httpHeader->defined("Transfer-Encoding");
 }
 
-string HttpResponse::getTransferEncoding() const
+std::string HttpResponse::getTransferEncoding() const
 {
   return httpHeader->getFirst("Transfer-Encoding");
 }
@@ -148,7 +168,7 @@ int64_t HttpResponse::getEntityLength() const
   }
 }
 
-string HttpResponse::getContentType() const
+std::string HttpResponse::getContentType() const
 {
   if(httpHeader.isNull()) {
     return "";
@@ -156,3 +176,25 @@ string HttpResponse::getContentType() const
     return httpHeader->getFirst("Content-Type");
   }
 }
+
+void HttpResponse::setHttpHeader(const SharedHandle<HttpHeader>& httpHeader)
+{
+  this->httpHeader = httpHeader;
+}
+
+SharedHandle<HttpHeader> HttpResponse::getHttpHeader() const
+{
+  return httpHeader;
+}
+
+void HttpResponse::setHttpRequest(const SharedHandle<HttpRequest>& httpRequest)
+{
+  this->httpRequest = httpRequest;
+}
+
+SharedHandle<HttpRequest> HttpResponse::getHttpRequest() const
+{
+  return httpRequest;
+}
+
+} // namespace aria2
diff --git a/src/HttpResponse.h b/src/HttpResponse.h
index 91ae7e16..cc467b8d 100644
--- a/src/HttpResponse.h
+++ b/src/HttpResponse.h
@@ -36,27 +36,27 @@
 #define _D_HTTP_RESPONSE_H_
 
 #include "common.h"
-#include "HttpRequest.h"
-#include "HttpHeader.h"
-#include "TransferEncoding.h"
-#include "LogFactory.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+
+namespace aria2 {
+
+class HttpRequest;
+class HttpHeader;
+class TransferEncoding;
+class Logger;
 
 class HttpResponse {
 private:
   int32_t cuid;
   int32_t status;
-  HttpRequestHandle httpRequest;
-  HttpHeaderHandle httpHeader;
+  SharedHandle<HttpRequest> httpRequest;
+  SharedHandle<HttpHeader> httpHeader;
   const Logger* logger;
 public:
-  HttpResponse():cuid(0),
-		 status(0),
-		 httpRequest(0),
-		 httpHeader(0),
-		 logger(LogFactory::getInstance())
-  {}
+  HttpResponse();
   
-  ~HttpResponse() {}
+  ~HttpResponse();
 
   void validateResponse() const;
 
@@ -66,7 +66,7 @@ public:
    * this function returns the filename from it.
    * If it is not there, returns the part of filename from the request URL.
    */
-  string determinFilename() const;
+  std::string determinFilename() const;
 
   void retrieveCookie();
 
@@ -77,29 +77,23 @@ public:
 
   void processRedirect();
 
-  string getRedirectURI() const;
+  std::string getRedirectURI() const;
 
   bool isTransferEncodingSpecified() const;
 
-  string getTransferEncoding() const;
+  std::string getTransferEncoding() const;
 
-  TransferEncodingHandle getTransferDecoder() const;
+  SharedHandle<TransferEncoding> getTransferDecoder() const;
 
   int64_t getContentLength() const;
 
   int64_t getEntityLength() const;
 
-  string getContentType() const;
+  std::string getContentType() const;
 
-  void setHttpHeader(const HttpHeaderHandle& httpHeader)
-  {
-    this->httpHeader = httpHeader;
-  }
+  void setHttpHeader(const SharedHandle<HttpHeader>& httpHeader);
 
-  HttpHeaderHandle getHttpHeader() const
-  {
-    return httpHeader;
-  }
+  SharedHandle<HttpHeader> getHttpHeader() const;
 
   void setStatus(int32_t status)
   {
@@ -111,15 +105,9 @@ public:
     return status;
   }
 
-  void setHttpRequest(const HttpRequestHandle& httpRequest)
-  {
-    this->httpRequest = httpRequest;
-  }
+  void setHttpRequest(const SharedHandle<HttpRequest>& httpRequest);
 
-  HttpRequestHandle getHttpRequest() const
-  {
-    return httpRequest;
-  }
+  SharedHandle<HttpRequest> getHttpRequest() const;
 
   void setCuid(int32_t cuid)
   {
@@ -129,4 +117,6 @@ public:
 
 typedef SharedHandle<HttpResponse> HttpResponseHandle;
 
+} // namespace aria2
+
 #endif // _D_HTTP_RESPONSE_H_
diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc
index e70e6c54..bcacbf24 100644
--- a/src/HttpResponseCommand.cc
+++ b/src/HttpResponseCommand.cc
@@ -34,25 +34,33 @@
 /* copyright --> */
 #include "HttpResponseCommand.h"
 #include "DownloadEngine.h"
+#include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
+#include "RequestGroup.h"
+#include "ServerHost.h"
+#include "RequestGroupMan.h"
+#include "Request.h"
+#include "HttpRequest.h"
 #include "HttpResponse.h"
 #include "HttpConnection.h"
+#include "TransferEncoding.h"
 #include "SegmentMan.h"
-#include "DlAbortEx.h"
+#include "Segment.h"
 #include "HttpDownloadCommand.h"
-#include "message.h"
-#include "Util.h"
-#include "prefs.h"
-#include "File.h"
-#include "InitiateConnectionCommandFactory.h"
-#include "SingleFileDownloadContext.h"
 #include "DiskAdaptor.h"
 #include "PieceStorage.h"
 #include "DefaultBtProgressInfoFile.h"
-#include "RequestGroupMan.h"
 #include "DownloadFailureException.h"
-#include "ServerHost.h"
-#include <sys/types.h>
-#include <unistd.h>
+#include "DlAbortEx.h"
+#include "Util.h"
+#include "File.h"
+#include "Option.h"
+#include "Logger.h"
+#include "Socket.h"
+#include "message.h"
+#include "prefs.h"
+
+namespace aria2 {
 
 HttpResponseCommand::HttpResponseCommand(int32_t cuid,
 					 const RequestHandle& req,
@@ -186,3 +194,5 @@ HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand(const HttpRe
 
   return command;
 }
+
+} // namespace aria2
diff --git a/src/HttpResponseCommand.h b/src/HttpResponseCommand.h
index ce474e44..25d2cd80 100644
--- a/src/HttpResponseCommand.h
+++ b/src/HttpResponseCommand.h
@@ -37,29 +37,32 @@
 
 #include "AbstractCommand.h"
 
+namespace aria2 {
+
 class HttpConnection;
-typedef SharedHandle<HttpConnection> HttpConnectionHandle;
 class HttpDownloadCommand;
 class HttpResponse;
-typedef SharedHandle<HttpResponse> HttpResponseHandle;
+class SocketCore;
 
 class HttpResponseCommand : public AbstractCommand {
 private:
-  HttpConnectionHandle httpConnection;
+  SharedHandle<HttpConnection> httpConnection;
 
-  bool handleDefaultEncoding(const HttpResponseHandle& httpResponse);
-  bool handleOtherEncoding(const HttpResponseHandle& httpResponse);
-  HttpDownloadCommand* createHttpDownloadCommand(const HttpResponseHandle& httpResponse);
+  bool handleDefaultEncoding(const SharedHandle<HttpResponse>& httpResponse);
+  bool handleOtherEncoding(const SharedHandle<HttpResponse>& httpResponse);
+  HttpDownloadCommand* createHttpDownloadCommand(const SharedHandle<HttpResponse>& httpResponse);
 protected:
   bool executeInternal();
 public:
   HttpResponseCommand(int32_t cuid,
-		      const RequestHandle& req,
+		      const SharedHandle<Request>& req,
 		      RequestGroup* requestGroup,
-		      const HttpConnectionHandle& httpConnection,
+		      const SharedHandle<HttpConnection>& httpConnection,
 		      DownloadEngine* e,
-		      const SocketHandle& s);
+		      const SharedHandle<SocketCore>& s);
   ~HttpResponseCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_HTTP_RESPONSE_COMMAND_H_
diff --git a/src/InitialMetalinkParserState.cc b/src/InitialMetalinkParserState.cc
index 213c25c8..247476a9 100644
--- a/src/InitialMetalinkParserState.cc
+++ b/src/InitialMetalinkParserState.cc
@@ -35,9 +35,11 @@
 #include "InitialMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void InitialMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					      const string& name,
-					      const map<string, string>& attrs)
+					      const std::string& name,
+					      const std::map<std::string, std::string>& attrs)
 {
   if(name == "metalink") {
     stm->setMetalinkState();
@@ -47,5 +49,7 @@ void InitialMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void InitialMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					    const string& name, const string& characters)
+					    const std::string& name, const std::string& characters)
 {}
+
+} // namespace aria2
diff --git a/src/InitialMetalinkParserState.h b/src/InitialMetalinkParserState.h
index 4864188e..12c5050c 100644
--- a/src/InitialMetalinkParserState.h
+++ b/src/InitialMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class InitialMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_INITIAL_METALINK_PARSER_STATE_H_
diff --git a/src/InitiateConnectionCommandFactory.cc b/src/InitiateConnectionCommandFactory.cc
index 2ae70386..e38baf70 100644
--- a/src/InitiateConnectionCommandFactory.cc
+++ b/src/InitiateConnectionCommandFactory.cc
@@ -35,9 +35,15 @@
 #include "InitiateConnectionCommandFactory.h"
 #include "HttpInitiateConnectionCommand.h"
 #include "FtpInitiateConnectionCommand.h"
+#include "Request.h"
+#include "RequestGroup.h"
+#include "DownloadEngine.h"
 #include "DlAbortEx.h"
 
-Command* InitiateConnectionCommandFactory::createInitiateConnectionCommand(int cuid, const RequestHandle req, RequestGroup* requestGroup, DownloadEngine* e) {
+namespace aria2 {
+
+Command*
+InitiateConnectionCommandFactory::createInitiateConnectionCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e) {
   if(req->getProtocol() == "http"
 #ifdef ENABLE_SSL
      // for SSL
@@ -52,3 +58,5 @@ Command* InitiateConnectionCommandFactory::createInitiateConnectionCommand(int c
     throw new DlAbortEx("%s is not supported yet.", req->getProtocol().c_str());
   }
 }
+
+} // namespace aria2
diff --git a/src/InitiateConnectionCommandFactory.h b/src/InitiateConnectionCommandFactory.h
index afe5c8c3..01368001 100644
--- a/src/InitiateConnectionCommandFactory.h
+++ b/src/InitiateConnectionCommandFactory.h
@@ -36,16 +36,24 @@
 #define _D_INITIATE_CONNECTION_COMMAND_FACTORY_H_
 
 #include "common.h"
-#include "Request.h"
-#include "RequestGroup.h"
-#include "DownloadEngine.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class Request;
+class RequestGroup;
+class DownloadEngine;
+class Command;
 
 class InitiateConnectionCommandFactory {
 public:
-  static Command* createInitiateConnectionCommand(int cuid,
-						  const RequestHandle req,
-						  RequestGroup* requestGroup,
-						  DownloadEngine* e);
+  static Command*
+  createInitiateConnectionCommand(int32_t cuid,
+				  const SharedHandle<Request>& req,
+				  RequestGroup* requestGroup,
+				  DownloadEngine* e);
 };
 
+} // namespace aria2
+
 #endif // _D_INITIATE_CONNECTION_COMMAND_FACTORY_H_
diff --git a/src/IntSequence.h b/src/IntSequence.h
index c285b60d..89aca51c 100644
--- a/src/IntSequence.h
+++ b/src/IntSequence.h
@@ -37,6 +37,10 @@
 
 #include "Sequence.h"
 
+namespace aria2 {
+
 typedef Sequence<int32_t> IntSequence;
 
+} // namespace aria2
+
 #endif // _D_INT_SEQUENCE_H_
diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc
index c1e3ae68..4d57c63d 100644
--- a/src/IteratableChecksumValidator.cc
+++ b/src/IteratableChecksumValidator.cc
@@ -41,8 +41,11 @@
 #include "LogFactory.h"
 #include "Logger.h"
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include "BitfieldMan.h"
 
+namespace aria2 {
+
 #define BUFSIZE (256*1024)
 #define ALIGNMENT 512
 
@@ -69,7 +72,7 @@ void IteratableChecksumValidator::validateChunk()
     _ctx->digestUpdate(_buffer, length);
     _currentOffset += length;
     if(finished()) {
-      string actualChecksum = Util::toHex((const unsigned char*)_ctx->digestFinal().c_str(), _ctx->digestLength());
+      std::string actualChecksum = Util::toHex((const unsigned char*)_ctx->digestFinal().c_str(), _ctx->digestLength());
       if(_dctx->getChecksum() == actualChecksum) {
 	_pieceStorage->markAllPiecesDone();
       } else {
@@ -108,3 +111,5 @@ void IteratableChecksumValidator::init()
   _ctx->trySetAlgo(_dctx->getChecksumHashAlgo());
   _ctx->digestInit();
 }
+
+} // namespace aria2
diff --git a/src/IteratableChecksumValidator.h b/src/IteratableChecksumValidator.h
index 0ef098a8..7c056d2d 100644
--- a/src/IteratableChecksumValidator.h
+++ b/src/IteratableChecksumValidator.h
@@ -37,32 +37,31 @@
 
 #include "IteratableValidator.h"
 
+namespace aria2 {
+
 class SingleFileDownloadContext;
-typedef SharedHandle<SingleFileDownloadContext> SingleFileDownloadContextHandle;
 class PieceStorage;
-typedef SharedHandle<PieceStorage> PieceStorageHandle;
 class Logger;
 class MessageDigestContext;
-typedef SharedHandle<MessageDigestContext> MessageDigestContextHandle;
 
 class IteratableChecksumValidator:public IteratableValidator
 {
 private:
-  SingleFileDownloadContextHandle _dctx;
+  SharedHandle<SingleFileDownloadContext> _dctx;
 
-  PieceStorageHandle _pieceStorage;
+  SharedHandle<PieceStorage> _pieceStorage;
 
   int64_t _currentOffset;
 
-  MessageDigestContextHandle _ctx;
+  SharedHandle<MessageDigestContext> _ctx;
 
   const Logger* _logger;
 
   unsigned char* _buffer;
 
 public:
-  IteratableChecksumValidator(const SingleFileDownloadContextHandle& dctx,
-			      const PieceStorageHandle& pieceStorage);
+  IteratableChecksumValidator(const SharedHandle<SingleFileDownloadContext>& dctx,
+			      const SharedHandle<PieceStorage>& pieceStorage);
 
   virtual ~IteratableChecksumValidator();
 
@@ -82,4 +81,6 @@ public:
 
 typedef SharedHandle<IteratableChecksumValidator> IteratableChecksumValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_ITERATABLE_CHECKSUM_VALIDATOR_H_
diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc
index 515b9ebb..f80cda74 100644
--- a/src/IteratableChunkChecksumValidator.cc
+++ b/src/IteratableChunkChecksumValidator.cc
@@ -37,6 +37,7 @@
 #include "message.h"
 #include "MessageDigestHelper.h"
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include "RecoverableException.h"
 #include "DownloadContext.h"
 #include "PieceStorage.h"
@@ -46,6 +47,8 @@
 #include "messageDigest.h"
 #include <cerrno>
 
+namespace aria2 {
+
 #define BUFSIZE (256*1024)
 #define ALIGNMENT 512
 
@@ -69,7 +72,7 @@ IteratableChunkChecksumValidator::~IteratableChunkChecksumValidator()
 void IteratableChunkChecksumValidator::validateChunk()
 {
   if(!finished()) {
-    string actualChecksum;
+    std::string actualChecksum;
     try {
       actualChecksum = calculateActualChecksum();
     } catch(RecoverableException* ex) {
@@ -96,7 +99,7 @@ void IteratableChunkChecksumValidator::validateChunk()
   }
 }
 
-string IteratableChunkChecksumValidator::calculateActualChecksum()
+std::string IteratableChunkChecksumValidator::calculateActualChecksum()
 {
   int64_t offset = getCurrentOffset();
   int32_t length;
@@ -126,7 +129,7 @@ void IteratableChunkChecksumValidator::init()
   _currentIndex = 0;
 }
 
-string IteratableChunkChecksumValidator::digest(int64_t offset, int32_t length)
+std::string IteratableChunkChecksumValidator::digest(int64_t offset, int32_t length)
 {
   _ctx->digestReset();
   int64_t curoffset = offset/ALIGNMENT*ALIGNMENT;
@@ -177,3 +180,5 @@ int64_t IteratableChunkChecksumValidator::getTotalLength() const
 {
   return _dctx->getTotalLength();
 }
+
+} // namespace aria2
diff --git a/src/IteratableChunkChecksumValidator.h b/src/IteratableChunkChecksumValidator.h
index 0ec824c5..68fa6fbb 100644
--- a/src/IteratableChunkChecksumValidator.h
+++ b/src/IteratableChunkChecksumValidator.h
@@ -37,33 +37,32 @@
 
 #include "IteratableValidator.h"
 
+namespace aria2 {
+
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class PieceStorage;
-typedef SharedHandle<PieceStorage> PieceStorageHandle;
 class BitfieldMan;
 class Logger;
 class MessageDigestContext;
-typedef SharedHandle<MessageDigestContext> MessageDigestContextHandle;
 
 class IteratableChunkChecksumValidator:public IteratableValidator
 {
 private:
-  DownloadContextHandle _dctx;
-  PieceStorageHandle _pieceStorage;
+  SharedHandle<DownloadContext> _dctx;
+  SharedHandle<PieceStorage> _pieceStorage;
   BitfieldMan* _bitfield;
   uint32_t _currentIndex;
   const Logger* _logger;
-  MessageDigestContextHandle _ctx;
+  SharedHandle<MessageDigestContext> _ctx;
   unsigned char* _buffer;
 
-  string calculateActualChecksum();
+  std::string calculateActualChecksum();
 
-  string digest(int64_t offset, int32_t length);
+  std::string digest(int64_t offset, int32_t length);
 
 public:
-  IteratableChunkChecksumValidator(const DownloadContextHandle& dctx,
-				   const PieceStorageHandle& pieceStorage);
+  IteratableChunkChecksumValidator(const SharedHandle<DownloadContext>& dctx,
+				   const SharedHandle<PieceStorage>& pieceStorage);
 
   virtual ~IteratableChunkChecksumValidator();
 
@@ -80,4 +79,6 @@ public:
 
 typedef SharedHandle<IteratableChunkChecksumValidator> IteratableChunkChecksumValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_ITERATABLE_CHUNK_CHECKSUM_VALIDATOR_H_
diff --git a/src/IteratableValidator.h b/src/IteratableValidator.h
index b0747e50..23fa3c65 100644
--- a/src/IteratableValidator.h
+++ b/src/IteratableValidator.h
@@ -36,6 +36,9 @@
 #define _D_ITERATABLE_VALIDATOR_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 /**
  * This class provides the interface to validate files.
@@ -63,4 +66,6 @@ public:
 
 typedef SharedHandle<IteratableValidator> IteratableValidatorHandle;
 
+} // namespace aria2
+
 #endif // _D_ITERATABLE_VALIDATOR_H_
diff --git a/src/LanguageMetalinkParserState.cc b/src/LanguageMetalinkParserState.cc
index a2aafcbd..ee618a68 100644
--- a/src/LanguageMetalinkParserState.cc
+++ b/src/LanguageMetalinkParserState.cc
@@ -35,17 +35,21 @@
 #include "LanguageMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void LanguageMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					       const string& name,
-					       const map<string, string>& attrs)
+					       const std::string& name,
+					       const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void LanguageMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					     const string& name,
-					     const string& characters)
+					     const std::string& name,
+					     const std::string& characters)
 {
   stm->setLanguageOfEntry(characters);
   stm->setFileState();
 }
+
+} // namespace aria2
diff --git a/src/LanguageMetalinkParserState.h b/src/LanguageMetalinkParserState.h
index dda2a39e..2961b8d2 100644
--- a/src/LanguageMetalinkParserState.h
+++ b/src/LanguageMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class LanguageMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_LANGUAGE_METALINK_PARSER_STATE_H_
diff --git a/src/List.cc b/src/List.cc
index cca4a51a..25838fa1 100644
--- a/src/List.cc
+++ b/src/List.cc
@@ -35,6 +35,8 @@
 #include "List.h"
 #include "MetaEntryVisitor.h"
 
+namespace aria2 {
+
 List::List() {}
 
 List::~List() {
@@ -42,7 +44,7 @@ List::~List() {
 }
 
 void List::clearList() {
-  for(MetaList::iterator itr = mlist.begin(); itr != mlist.end(); itr++) {
+  for(std::deque<MetaEntry*>::iterator itr = mlist.begin(); itr != mlist.end(); itr++) {
     delete *itr;
   }
 }
@@ -51,10 +53,12 @@ void List::add(MetaEntry* entry) {
   mlist.push_back(entry);
 }
 
-const MetaList& List::getList() const {
+const std::deque<MetaEntry*>& List::getList() const {
   return mlist;
 }
 
 void List::accept(MetaEntryVisitor* v) const {
   v->visit(this);
 }
+
+} // namespace aria2
diff --git a/src/List.h b/src/List.h
index 738f56e0..b3388fdb 100644
--- a/src/List.h
+++ b/src/List.h
@@ -38,13 +38,11 @@
 #include "MetaEntry.h"
 #include <deque>
 
-using namespace std;
-
-typedef deque<MetaEntry*> MetaList;
+namespace aria2 {
 
 class List : public MetaEntry {
 private:
-  MetaList mlist;
+  std::deque<MetaEntry*> mlist;
 
   void clearList();
 public:
@@ -53,9 +51,11 @@ public:
 
   void add(MetaEntry* entry);
 
-  const MetaList& getList() const;
+  const std::deque<MetaEntry*>& getList() const;
 
   void accept(MetaEntryVisitor* v) const;
 };
 
+} // namespace aria2
+
 #endif // _D_LIST_H_
diff --git a/src/LogFactory.cc b/src/LogFactory.cc
index fbb82c83..a17c5be3 100644
--- a/src/LogFactory.cc
+++ b/src/LogFactory.cc
@@ -36,8 +36,10 @@
 #include "SimpleLogger.h"
 #include "a2io.h"
 
-string LogFactory::filename = DEV_NULL;
-Logger* LogFactory::logger = NULL;
+namespace aria2 {
+
+std::string LogFactory::filename = DEV_NULL;
+Logger* LogFactory::logger = 0;
 
 Logger* LogFactory::getInstance() {
   if(logger == NULL) {
@@ -53,5 +55,7 @@ Logger* LogFactory::getInstance() {
 
 void LogFactory::release() {
   delete logger;
-  logger = NULL;
+  logger = 0;
 }
+
+} // namespace aria2
diff --git a/src/LogFactory.h b/src/LogFactory.h
index b942a96f..6ec4197c 100644
--- a/src/LogFactory.h
+++ b/src/LogFactory.h
@@ -36,11 +36,15 @@
 #define _D_LOG_FACTORY_H_
 
 #include "common.h"
-#include "Logger.h"
+#include <string>
+
+namespace aria2 {
+
+class Logger;
 
 class LogFactory {
 private:
-  static string filename;
+  static std::string filename;
   static Logger* logger;
 public:
   /**
@@ -52,7 +56,7 @@ public:
   /**
    * Set a filename to write log.
    */
-  static void setLogFile(const string& name) {
+  static void setLogFile(const std::string& name) {
     filename = name;
   }
 
@@ -62,4 +66,6 @@ public:
   static void release();
 };
 
+} // namespace aria2
+
 #endif // _D_LOG_FACTORY_H_
diff --git a/src/Logger.h b/src/Logger.h
index c4562111..319ad84f 100644
--- a/src/Logger.h
+++ b/src/Logger.h
@@ -35,11 +35,11 @@
 #ifndef _D_LOGGER_H_
 #define _D_LOGGER_H_
 
-#include <string>
-#include "Exception.h"
 #include "common.h"
 
-using namespace std;
+namespace aria2 {
+
+class Exception;
 
 class Logger {
 public:
@@ -64,4 +64,6 @@ public:
   };
 };
 
+} // namespace aria2
+
 #endif // _D_LOGGER_H_
diff --git a/src/Makefile.am b/src/Makefile.am
index e1690af3..f549a8b0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -44,6 +44,7 @@ SRCS =  Socket.h\
 	DiskWriter.h\
 	AbstractDiskWriter.cc AbstractDiskWriter.h\
 	DefaultDiskWriter.cc DefaultDiskWriter.h\
+	DefaultDiskWriterFactory.cc\
 	File.cc File.h\
 	Option.cc Option.h\
 	Base64.cc\
@@ -71,7 +72,7 @@ SRCS =  Socket.h\
 	Netrc.cc Netrc.h\
 	AuthConfig.cc AuthConfig.h\
 	AuthResolver.h\
-	AbstractAuthResolver.h\
+	AbstractAuthResolver.cc\
 	DefaultAuthResolver.cc DefaultAuthResolver.h\
 	NetrcAuthResolver.cc NetrcAuthResolver.h\
 	AuthConfigFactory.cc AuthConfigFactory.h\
@@ -147,11 +148,13 @@ SRCS =  Socket.h\
 	MultiFileAllocationIterator.cc MultiFileAllocationIterator.h\
 	PeerConnection.cc PeerConnection.h\
 	ByteArrayDiskWriter.cc ByteArrayDiskWriter.h\
+	ByteArrayDiskWriterFactory.cc\
 	ServerHost.cc\
 	HelpItem.cc\
 	TaggedItem.cc\
 	TagContainer.cc\
-	HelpItemFactory.cc
+	HelpItemFactory.cc\
+	SingleFileDownloadContext.cc
 #	debug_new.cpp
 
 if ENABLE_MESSAGE_DIGEST
@@ -170,7 +173,6 @@ SRCS += MetaEntry.h\
 	List.cc List.h\
 	MetaFileUtil.cc MetaFileUtil.h\
 	MetaEntryVisitor.h\
-	ShaVisitor.cc ShaVisitor.h\
 	BencodeVisitor.cc\
 	PeerMessageUtil.cc PeerMessageUtil.h\
 	PeerAbstractCommand.cc PeerAbstractCommand.h\
@@ -179,7 +181,6 @@ SRCS += MetaEntry.h\
 	Peer.cc Peer.h\
 	PeerListenCommand.cc PeerListenCommand.h\
 	RequestSlot.cc RequestSlot.h\
-	Directory.cc Directory.h\
 	TrackerWatcherCommand.cc TrackerWatcherCommand.h\
 	PeerChokeCommand.cc PeerChokeCommand.h\
 	SeedCriteria.h\
@@ -201,7 +202,7 @@ SRCS += MetaEntry.h\
 	BtRuntime.h\
 	BtContextAwareCommand.cc BtContextAwareCommand.h\
 	BtMessage.h\
-	AbstractBtMessage.h\
+	AbstractBtMessage.cc\
 	SimpleBtMessage.cc SimpleBtMessage.h\
 	BtAllowedFastMessage.cc BtAllowedFastMessage.h\
 	BtBitfieldMessage.cc BtBitfieldMessage.h\
diff --git a/src/Makefile.in b/src/Makefile.in
index 98205efe..33b0e6cc 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -53,7 +53,6 @@ bin_PROGRAMS = aria2c$(EXEEXT)
 @ENABLE_BITTORRENT_TRUE@	List.cc List.h\
 @ENABLE_BITTORRENT_TRUE@	MetaFileUtil.cc MetaFileUtil.h\
 @ENABLE_BITTORRENT_TRUE@	MetaEntryVisitor.h\
-@ENABLE_BITTORRENT_TRUE@	ShaVisitor.cc ShaVisitor.h\
 @ENABLE_BITTORRENT_TRUE@	BencodeVisitor.cc\
 @ENABLE_BITTORRENT_TRUE@	PeerMessageUtil.cc PeerMessageUtil.h\
 @ENABLE_BITTORRENT_TRUE@	PeerAbstractCommand.cc PeerAbstractCommand.h\
@@ -62,7 +61,6 @@ bin_PROGRAMS = aria2c$(EXEEXT)
 @ENABLE_BITTORRENT_TRUE@	Peer.cc Peer.h\
 @ENABLE_BITTORRENT_TRUE@	PeerListenCommand.cc PeerListenCommand.h\
 @ENABLE_BITTORRENT_TRUE@	RequestSlot.cc RequestSlot.h\
-@ENABLE_BITTORRENT_TRUE@	Directory.cc Directory.h\
 @ENABLE_BITTORRENT_TRUE@	TrackerWatcherCommand.cc TrackerWatcherCommand.h\
 @ENABLE_BITTORRENT_TRUE@	PeerChokeCommand.cc PeerChokeCommand.h\
 @ENABLE_BITTORRENT_TRUE@	SeedCriteria.h\
@@ -84,7 +82,7 @@ bin_PROGRAMS = aria2c$(EXEEXT)
 @ENABLE_BITTORRENT_TRUE@	BtRuntime.h\
 @ENABLE_BITTORRENT_TRUE@	BtContextAwareCommand.cc BtContextAwareCommand.h\
 @ENABLE_BITTORRENT_TRUE@	BtMessage.h\
-@ENABLE_BITTORRENT_TRUE@	AbstractBtMessage.h\
+@ENABLE_BITTORRENT_TRUE@	AbstractBtMessage.cc\
 @ENABLE_BITTORRENT_TRUE@	SimpleBtMessage.cc SimpleBtMessage.h\
 @ENABLE_BITTORRENT_TRUE@	BtAllowedFastMessage.cc BtAllowedFastMessage.h\
 @ENABLE_BITTORRENT_TRUE@	BtBitfieldMessage.cc BtBitfieldMessage.h\
@@ -287,24 +285,25 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 	SimpleLogger.cc SimpleLogger.h TransferEncoding.h \
 	ChunkedEncoding.cc ChunkedEncoding.h DiskWriter.h \
 	AbstractDiskWriter.cc AbstractDiskWriter.h \
-	DefaultDiskWriter.cc DefaultDiskWriter.h File.cc File.h \
-	Option.cc Option.h Base64.cc CookieBox.cc CookieBox.h \
-	LogFactory.cc LogFactory.h NullLogger.h TimeA2.cc TimeA2.h \
-	SharedHandle.h HandleRegistry.h FeatureConfig.cc \
-	FeatureConfig.h DownloadEngineFactory.cc \
-	DownloadEngineFactory.h RequestInfo.h SpeedCalc.cc SpeedCalc.h \
-	PeerStat.h BitfieldMan.cc BitfieldMan.h BitfieldManFactory.cc \
-	BitfieldManFactory.h Randomizer.h SimpleRandomizer.cc \
-	SimpleRandomizer.h FileAllocator.h HttpResponse.cc \
-	HttpResponse.h HttpRequest.cc HttpRequest.h Range.h \
-	AbstractProxyRequestCommand.cc AbstractProxyRequestCommand.h \
-	AbstractProxyResponseCommand.cc AbstractProxyResponseCommand.h \
-	Netrc.cc Netrc.h AuthConfig.cc AuthConfig.h AuthResolver.h \
-	AbstractAuthResolver.h DefaultAuthResolver.cc \
-	DefaultAuthResolver.h NetrcAuthResolver.cc NetrcAuthResolver.h \
-	AuthConfigFactory.cc AuthConfigFactory.h OptionParser.cc \
-	OptionParser.h OptionHandlerFactory.cc OptionHandlerFactory.h \
-	NameResolver.cc NameResolver.h RequestGroup.cc RequestGroup.h \
+	DefaultDiskWriter.cc DefaultDiskWriter.h \
+	DefaultDiskWriterFactory.cc File.cc File.h Option.cc Option.h \
+	Base64.cc CookieBox.cc CookieBox.h LogFactory.cc LogFactory.h \
+	NullLogger.h TimeA2.cc TimeA2.h SharedHandle.h \
+	HandleRegistry.h FeatureConfig.cc FeatureConfig.h \
+	DownloadEngineFactory.cc DownloadEngineFactory.h RequestInfo.h \
+	SpeedCalc.cc SpeedCalc.h PeerStat.h BitfieldMan.cc \
+	BitfieldMan.h BitfieldManFactory.cc BitfieldManFactory.h \
+	Randomizer.h SimpleRandomizer.cc SimpleRandomizer.h \
+	FileAllocator.h HttpResponse.cc HttpResponse.h HttpRequest.cc \
+	HttpRequest.h Range.h AbstractProxyRequestCommand.cc \
+	AbstractProxyRequestCommand.h AbstractProxyResponseCommand.cc \
+	AbstractProxyResponseCommand.h Netrc.cc Netrc.h AuthConfig.cc \
+	AuthConfig.h AuthResolver.h AbstractAuthResolver.cc \
+	DefaultAuthResolver.cc DefaultAuthResolver.h \
+	NetrcAuthResolver.cc NetrcAuthResolver.h AuthConfigFactory.cc \
+	AuthConfigFactory.h OptionParser.cc OptionParser.h \
+	OptionHandlerFactory.cc OptionHandlerFactory.h NameResolver.cc \
+	NameResolver.h RequestGroup.cc RequestGroup.h \
 	RequestGroupAware.cc RequestGroupAware.h RequestGroupMan.cc \
 	RequestGroupMan.h FileAllocationMan.cc FileAllocationMan.h \
 	FileAllocationCommand.cc FileAllocationCommand.h \
@@ -354,8 +353,10 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 	BtRegistry.cc BtRegistry.h MultiFileAllocationIterator.cc \
 	MultiFileAllocationIterator.h PeerConnection.cc \
 	PeerConnection.h ByteArrayDiskWriter.cc ByteArrayDiskWriter.h \
-	ServerHost.cc HelpItem.cc TaggedItem.cc TagContainer.cc \
-	HelpItemFactory.cc IteratableChunkChecksumValidator.cc \
+	ByteArrayDiskWriterFactory.cc ServerHost.cc HelpItem.cc \
+	TaggedItem.cc TagContainer.cc HelpItemFactory.cc \
+	SingleFileDownloadContext.cc \
+	IteratableChunkChecksumValidator.cc \
 	IteratableChunkChecksumValidator.h \
 	IteratableChecksumValidator.cc IteratableChecksumValidator.h \
 	CheckIntegrityCommand.cc CheckIntegrityCommand.h \
@@ -363,14 +364,13 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 	messageDigest.cc messageDigest.h MessageDigestHelper.cc \
 	MessageDigestHelper.h MetaEntry.h Data.cc Data.h Dictionary.cc \
 	Dictionary.h List.cc List.h MetaFileUtil.cc MetaFileUtil.h \
-	MetaEntryVisitor.h ShaVisitor.cc ShaVisitor.h \
-	BencodeVisitor.cc PeerMessageUtil.cc PeerMessageUtil.h \
-	PeerAbstractCommand.cc PeerAbstractCommand.h \
+	MetaEntryVisitor.h BencodeVisitor.cc PeerMessageUtil.cc \
+	PeerMessageUtil.h PeerAbstractCommand.cc PeerAbstractCommand.h \
 	PeerInitiateConnectionCommand.cc \
 	PeerInitiateConnectionCommand.h PeerInteractionCommand.cc \
 	PeerInteractionCommand.h PeerListenCommand.cc \
-	PeerListenCommand.h RequestSlot.cc RequestSlot.h Directory.cc \
-	Directory.h TrackerWatcherCommand.cc TrackerWatcherCommand.h \
+	PeerListenCommand.h RequestSlot.cc RequestSlot.h \
+	TrackerWatcherCommand.cc TrackerWatcherCommand.h \
 	PeerChokeCommand.cc PeerChokeCommand.h SeedCriteria.h \
 	TimeSeedCriteria.h ShareRatioSeedCriteria.h \
 	UnionSeedCriteria.h SeedCheckCommand.cc SeedCheckCommand.h \
@@ -382,7 +382,7 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 	DefaultBtContext.h DefaultPeerStorage.cc DefaultPeerStorage.h \
 	BtAnnounce.h DefaultBtAnnounce.cc DefaultBtAnnounce.h \
 	BtRuntime.h BtContextAwareCommand.cc BtContextAwareCommand.h \
-	BtMessage.h AbstractBtMessage.h SimpleBtMessage.cc \
+	BtMessage.h AbstractBtMessage.cc SimpleBtMessage.cc \
 	SimpleBtMessage.h BtAllowedFastMessage.cc \
 	BtAllowedFastMessage.h BtBitfieldMessage.cc \
 	BtBitfieldMessage.h BtCancelMessage.cc BtCancelMessage.h \
@@ -469,7 +469,6 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 @ENABLE_BITTORRENT_TRUE@am__objects_2 = Data.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	Dictionary.$(OBJEXT) List.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	MetaFileUtil.$(OBJEXT) \
-@ENABLE_BITTORRENT_TRUE@	ShaVisitor.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	BencodeVisitor.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	PeerMessageUtil.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	PeerAbstractCommand.$(OBJEXT) \
@@ -478,7 +477,6 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 @ENABLE_BITTORRENT_TRUE@	Peer.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	PeerListenCommand.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	RequestSlot.$(OBJEXT) \
-@ENABLE_BITTORRENT_TRUE@	Directory.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	TrackerWatcherCommand.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	PeerChokeCommand.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	SeedCheckCommand.$(OBJEXT) \
@@ -490,6 +488,7 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \
 @ENABLE_BITTORRENT_TRUE@	DefaultPeerStorage.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultBtAnnounce.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	BtContextAwareCommand.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	AbstractBtMessage.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	SimpleBtMessage.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	BtAllowedFastMessage.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	BtBitfieldMessage.$(OBJEXT) \
@@ -629,20 +628,22 @@ am__objects_14 = SocketCore.$(OBJEXT) Command.$(OBJEXT) \
 	PiecedSegment.$(OBJEXT) SegmentMan.$(OBJEXT) Util.$(OBJEXT) \
 	Request.$(OBJEXT) Exception.$(OBJEXT) SimpleLogger.$(OBJEXT) \
 	ChunkedEncoding.$(OBJEXT) AbstractDiskWriter.$(OBJEXT) \
-	DefaultDiskWriter.$(OBJEXT) File.$(OBJEXT) Option.$(OBJEXT) \
-	Base64.$(OBJEXT) CookieBox.$(OBJEXT) LogFactory.$(OBJEXT) \
-	TimeA2.$(OBJEXT) FeatureConfig.$(OBJEXT) \
-	DownloadEngineFactory.$(OBJEXT) SpeedCalc.$(OBJEXT) \
-	BitfieldMan.$(OBJEXT) BitfieldManFactory.$(OBJEXT) \
-	SimpleRandomizer.$(OBJEXT) HttpResponse.$(OBJEXT) \
-	HttpRequest.$(OBJEXT) AbstractProxyRequestCommand.$(OBJEXT) \
+	DefaultDiskWriter.$(OBJEXT) DefaultDiskWriterFactory.$(OBJEXT) \
+	File.$(OBJEXT) Option.$(OBJEXT) Base64.$(OBJEXT) \
+	CookieBox.$(OBJEXT) LogFactory.$(OBJEXT) TimeA2.$(OBJEXT) \
+	FeatureConfig.$(OBJEXT) DownloadEngineFactory.$(OBJEXT) \
+	SpeedCalc.$(OBJEXT) BitfieldMan.$(OBJEXT) \
+	BitfieldManFactory.$(OBJEXT) SimpleRandomizer.$(OBJEXT) \
+	HttpResponse.$(OBJEXT) HttpRequest.$(OBJEXT) \
+	AbstractProxyRequestCommand.$(OBJEXT) \
 	AbstractProxyResponseCommand.$(OBJEXT) Netrc.$(OBJEXT) \
-	AuthConfig.$(OBJEXT) DefaultAuthResolver.$(OBJEXT) \
-	NetrcAuthResolver.$(OBJEXT) AuthConfigFactory.$(OBJEXT) \
-	OptionParser.$(OBJEXT) OptionHandlerFactory.$(OBJEXT) \
-	NameResolver.$(OBJEXT) RequestGroup.$(OBJEXT) \
-	RequestGroupAware.$(OBJEXT) RequestGroupMan.$(OBJEXT) \
-	FileAllocationMan.$(OBJEXT) FileAllocationCommand.$(OBJEXT) \
+	AuthConfig.$(OBJEXT) AbstractAuthResolver.$(OBJEXT) \
+	DefaultAuthResolver.$(OBJEXT) NetrcAuthResolver.$(OBJEXT) \
+	AuthConfigFactory.$(OBJEXT) OptionParser.$(OBJEXT) \
+	OptionHandlerFactory.$(OBJEXT) NameResolver.$(OBJEXT) \
+	RequestGroup.$(OBJEXT) RequestGroupAware.$(OBJEXT) \
+	RequestGroupMan.$(OBJEXT) FileAllocationMan.$(OBJEXT) \
+	FileAllocationCommand.$(OBJEXT) \
 	FillRequestGroupCommand.$(OBJEXT) \
 	FileAllocationDispatcherCommand.$(OBJEXT) \
 	FileAllocationEntry.$(OBJEXT) \
@@ -671,13 +672,15 @@ am__objects_14 = SocketCore.$(OBJEXT) Command.$(OBJEXT) \
 	DirectDiskAdaptor.$(OBJEXT) MultiDiskAdaptor.$(OBJEXT) \
 	Peer.$(OBJEXT) BtRegistry.$(OBJEXT) \
 	MultiFileAllocationIterator.$(OBJEXT) PeerConnection.$(OBJEXT) \
-	ByteArrayDiskWriter.$(OBJEXT) ServerHost.$(OBJEXT) \
+	ByteArrayDiskWriter.$(OBJEXT) \
+	ByteArrayDiskWriterFactory.$(OBJEXT) ServerHost.$(OBJEXT) \
 	HelpItem.$(OBJEXT) TaggedItem.$(OBJEXT) TagContainer.$(OBJEXT) \
-	HelpItemFactory.$(OBJEXT) $(am__objects_1) $(am__objects_2) \
-	$(am__objects_3) $(am__objects_4) $(am__objects_5) \
-	$(am__objects_6) $(am__objects_7) $(am__objects_8) \
-	$(am__objects_9) $(am__objects_10) $(am__objects_11) \
-	$(am__objects_12) $(am__objects_13)
+	HelpItemFactory.$(OBJEXT) SingleFileDownloadContext.$(OBJEXT) \
+	$(am__objects_1) $(am__objects_2) $(am__objects_3) \
+	$(am__objects_4) $(am__objects_5) $(am__objects_6) \
+	$(am__objects_7) $(am__objects_8) $(am__objects_9) \
+	$(am__objects_10) $(am__objects_11) $(am__objects_12) \
+	$(am__objects_13)
 am_libaria2c_a_OBJECTS = $(am__objects_14)
 libaria2c_a_OBJECTS = $(am_libaria2c_a_OBJECTS)
 am__installdirs = "$(DESTDIR)$(bindir)"
@@ -929,24 +932,25 @@ SRCS = Socket.h SocketCore.cc SocketCore.h Command.cc Command.h \
 	SimpleLogger.cc SimpleLogger.h TransferEncoding.h \
 	ChunkedEncoding.cc ChunkedEncoding.h DiskWriter.h \
 	AbstractDiskWriter.cc AbstractDiskWriter.h \
-	DefaultDiskWriter.cc DefaultDiskWriter.h File.cc File.h \
-	Option.cc Option.h Base64.cc CookieBox.cc CookieBox.h \
-	LogFactory.cc LogFactory.h NullLogger.h TimeA2.cc TimeA2.h \
-	SharedHandle.h HandleRegistry.h FeatureConfig.cc \
-	FeatureConfig.h DownloadEngineFactory.cc \
-	DownloadEngineFactory.h RequestInfo.h SpeedCalc.cc SpeedCalc.h \
-	PeerStat.h BitfieldMan.cc BitfieldMan.h BitfieldManFactory.cc \
-	BitfieldManFactory.h Randomizer.h SimpleRandomizer.cc \
-	SimpleRandomizer.h FileAllocator.h HttpResponse.cc \
-	HttpResponse.h HttpRequest.cc HttpRequest.h Range.h \
-	AbstractProxyRequestCommand.cc AbstractProxyRequestCommand.h \
-	AbstractProxyResponseCommand.cc AbstractProxyResponseCommand.h \
-	Netrc.cc Netrc.h AuthConfig.cc AuthConfig.h AuthResolver.h \
-	AbstractAuthResolver.h DefaultAuthResolver.cc \
-	DefaultAuthResolver.h NetrcAuthResolver.cc NetrcAuthResolver.h \
-	AuthConfigFactory.cc AuthConfigFactory.h OptionParser.cc \
-	OptionParser.h OptionHandlerFactory.cc OptionHandlerFactory.h \
-	NameResolver.cc NameResolver.h RequestGroup.cc RequestGroup.h \
+	DefaultDiskWriter.cc DefaultDiskWriter.h \
+	DefaultDiskWriterFactory.cc File.cc File.h Option.cc Option.h \
+	Base64.cc CookieBox.cc CookieBox.h LogFactory.cc LogFactory.h \
+	NullLogger.h TimeA2.cc TimeA2.h SharedHandle.h \
+	HandleRegistry.h FeatureConfig.cc FeatureConfig.h \
+	DownloadEngineFactory.cc DownloadEngineFactory.h RequestInfo.h \
+	SpeedCalc.cc SpeedCalc.h PeerStat.h BitfieldMan.cc \
+	BitfieldMan.h BitfieldManFactory.cc BitfieldManFactory.h \
+	Randomizer.h SimpleRandomizer.cc SimpleRandomizer.h \
+	FileAllocator.h HttpResponse.cc HttpResponse.h HttpRequest.cc \
+	HttpRequest.h Range.h AbstractProxyRequestCommand.cc \
+	AbstractProxyRequestCommand.h AbstractProxyResponseCommand.cc \
+	AbstractProxyResponseCommand.h Netrc.cc Netrc.h AuthConfig.cc \
+	AuthConfig.h AuthResolver.h AbstractAuthResolver.cc \
+	DefaultAuthResolver.cc DefaultAuthResolver.h \
+	NetrcAuthResolver.cc NetrcAuthResolver.h AuthConfigFactory.cc \
+	AuthConfigFactory.h OptionParser.cc OptionParser.h \
+	OptionHandlerFactory.cc OptionHandlerFactory.h NameResolver.cc \
+	NameResolver.h RequestGroup.cc RequestGroup.h \
 	RequestGroupAware.cc RequestGroupAware.h RequestGroupMan.cc \
 	RequestGroupMan.h FileAllocationMan.cc FileAllocationMan.h \
 	FileAllocationCommand.cc FileAllocationCommand.h \
@@ -996,8 +1000,9 @@ SRCS = Socket.h SocketCore.cc SocketCore.h Command.cc Command.h \
 	BtRegistry.cc BtRegistry.h MultiFileAllocationIterator.cc \
 	MultiFileAllocationIterator.h PeerConnection.cc \
 	PeerConnection.h ByteArrayDiskWriter.cc ByteArrayDiskWriter.h \
-	ServerHost.cc HelpItem.cc TaggedItem.cc TagContainer.cc \
-	HelpItemFactory.cc $(am__append_1) $(am__append_2) \
+	ByteArrayDiskWriterFactory.cc ServerHost.cc HelpItem.cc \
+	TaggedItem.cc TagContainer.cc HelpItemFactory.cc \
+	SingleFileDownloadContext.cc $(am__append_1) $(am__append_2) \
 	$(am__append_3) $(am__append_4) $(am__append_5) \
 	$(am__append_6) $(am__append_7) $(am__append_8) \
 	$(am__append_9) $(am__append_10) $(am__append_11) \
@@ -1089,6 +1094,8 @@ distclean-compile:
 	-rm -f *.tab.c
 
 @AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/alloca.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AbstractAuthResolver.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AbstractBtMessage.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AbstractCommand.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AbstractDiskWriter.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AbstractProxyRequestCommand.Po@am__quote@
@@ -1130,6 +1137,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BtSuggestPieceMessage.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BtUnchokeMessage.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ByteArrayDiskWriter.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ByteArrayDiskWriterFactory.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CheckIntegrityCommand.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CheckIntegrityEntry.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CheckIntegrityMan.Po@am__quote@
@@ -1204,6 +1212,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultBtProgressInfoFile.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultBtRequestFactory.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultDiskWriter.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultDiskWriterFactory.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultExtensionMessageFactory.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultPeerListProcessor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultPeerStorage.Po@am__quote@
@@ -1212,7 +1221,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelegatingPeerListProcessor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Dictionary.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DirectDiskAdaptor.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Directory.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DiskAdaptor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DownloadCommand.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DownloadEngine.Po@am__quote@
@@ -1315,11 +1323,11 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SeedCheckCommand.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SegmentMan.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ServerHost.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ShaVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SimpleBtMessage.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SimpleLogger.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SimpleRandomizer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingleFileAllocationIterator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingleFileDownloadContext.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SizeMetalinkParserState.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SkipTagMetalinkParserState.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SleepCommand.Po@am__quote@
diff --git a/src/MemoryBufferPreDownloadHandler.cc b/src/MemoryBufferPreDownloadHandler.cc
index fe906820..19af96bf 100644
--- a/src/MemoryBufferPreDownloadHandler.cc
+++ b/src/MemoryBufferPreDownloadHandler.cc
@@ -37,6 +37,8 @@
 #include "ByteArrayDiskWriterFactory.h"
 #include "DownloadContext.h"
 
+namespace aria2 {
+
 MemoryBufferPreDownloadHandler::MemoryBufferPreDownloadHandler() {}
 
 MemoryBufferPreDownloadHandler::~MemoryBufferPreDownloadHandler() {}
@@ -49,3 +51,5 @@ void MemoryBufferPreDownloadHandler::execute(RequestGroup* requestGroup)
 
   requestGroup->getDownloadContext()->setDir("[MEMORY]");
 }
+
+} // namespace aria2
diff --git a/src/MemoryBufferPreDownloadHandler.h b/src/MemoryBufferPreDownloadHandler.h
index 2ea6f7b3..32cd32eb 100644
--- a/src/MemoryBufferPreDownloadHandler.h
+++ b/src/MemoryBufferPreDownloadHandler.h
@@ -37,6 +37,8 @@
 
 #include "PreDownloadHandler.h"
 
+namespace aria2 {
+
 class MemoryBufferPreDownloadHandler:public PreDownloadHandler
 {
 public:
@@ -48,4 +50,7 @@ public:
 };
 
 typedef SharedHandle<MemoryBufferPreDownloadHandler> MemoryBufferPreDownloadHandlerHandle;
+
+} // namespace aria2
+
 #endif // _D_MEMORY_BUFFER_PRE_DOWNLOAD_HANDLER_H_
diff --git a/src/MessageDigestHelper.cc b/src/MessageDigestHelper.cc
index edda3c6c..f5d4acce 100644
--- a/src/MessageDigestHelper.cc
+++ b/src/MessageDigestHelper.cc
@@ -38,12 +38,14 @@
 #include "message.h"
 #include "DefaultDiskWriter.h"
 #include "Util.h"
-#include <errno.h>
+#include <cerrno>
 
-string MessageDigestHelper::digest(const string& algo,
-				   const BinaryStreamHandle& bs,
-				   int64_t offset,
-				   int64_t length)
+namespace aria2 {
+
+std::string MessageDigestHelper::digest(const std::string& algo,
+					const BinaryStreamHandle& bs,
+					int64_t offset,
+					int64_t length)
 {
   MessageDigestContext ctx;
   ctx.trySetAlgo(algo);
@@ -68,29 +70,29 @@ string MessageDigestHelper::digest(const string& algo,
     }
     ctx.digestUpdate(BUF, readLength);
   }
-  string rawMD = ctx.digestFinal();
+  std::string rawMD = ctx.digestFinal();
   return Util::toHex((const unsigned char*)rawMD.c_str(), rawMD.size());
 }
 
-string MessageDigestHelper::digest(const string& algo, const string& filename)
+std::string MessageDigestHelper::digest(const std::string& algo, const std::string& filename)
 {
   DiskWriterHandle writer = new DefaultDiskWriter();
   writer->openExistingFile(filename);
   return digest(algo, writer, 0, writer->size());
 }
 
-string MessageDigestHelper::digest(const string& algo, const void* data, int32_t length)
+std::string MessageDigestHelper::digest(const std::string& algo, const void* data, int32_t length)
 {
   MessageDigestContext ctx;
   ctx.trySetAlgo(algo);
   ctx.digestInit();
   ctx.digestUpdate(data, length);
-  string rawMD = ctx.digestFinal();
+  std::string rawMD = ctx.digestFinal();
   return Util::toHex((const unsigned char*)rawMD.c_str(), rawMD.size());
 }
 
 void MessageDigestHelper::digest(unsigned char* md, int32_t mdLength,
-				 const string& algo, const void* data, int32_t length)
+				 const std::string& algo, const void* data, int32_t length)
 {
   if(mdLength < MessageDigestContext::digestLength(algo)) {
     throw new DlAbortEx("Insufficient space for storing message digest: %d required, but only %d is allocated", MessageDigestContext::digestLength(algo), mdLength);
@@ -102,3 +104,4 @@ void MessageDigestHelper::digest(unsigned char* md, int32_t mdLength,
   ctx.digestFinal(md);
 }
 
+} // namespace aria2
diff --git a/src/MessageDigestHelper.h b/src/MessageDigestHelper.h
index 04a7c155..3300eca5 100644
--- a/src/MessageDigestHelper.h
+++ b/src/MessageDigestHelper.h
@@ -36,7 +36,12 @@
 #define _D_MESSAGE_DIGEST_HELPER_H_
 
 #include "common.h"
-#include "BinaryStream.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
+
+class BinaryStream;
 
 class MessageDigestHelper {
 public:
@@ -44,16 +49,16 @@ public:
    * Returns message digest in hexadecimal notation.
    * Digest algorithm is specified by algo.
    */
-  static string digest(const string& algo, const BinaryStreamHandle& bs, int64_t offset, int64_t length);
+  static std::string digest(const std::string& algo, const SharedHandle<BinaryStream>& bs, int64_t offset, int64_t length);
 
   /**
    * Calculates message digest of file denoted by filename.
    */
-  static string digest(const string& algo, const string& filename);
+  static std::string digest(const std::string& algo, const std::string& filename);
 
-  static string digest(const string& algo, const void* data, int32_t length);
+  static std::string digest(const std::string& algo, const void* data, int32_t length);
 
-  static string digestString(const string& algo, const string& data)
+  static std::string digestString(const std::string& algo, const std::string& data)
   {
     return digest(algo, data.c_str(), data.size());
   }
@@ -63,7 +68,9 @@ public:
    * Throws exception when mdLength is less than the size of message digest.
    */
   static void digest(unsigned char* md, int32_t mdLength,
-		     const string& algo, const void* data, int32_t length);
+		     const std::string& algo, const void* data, int32_t length);
 };
 
+} // namespace aria2
+
 #endif // _D_MESSAGE_DIGEST_HELPER_H_
diff --git a/src/MetaEntry.h b/src/MetaEntry.h
index 29c86efb..dbe8c5b1 100644
--- a/src/MetaEntry.h
+++ b/src/MetaEntry.h
@@ -36,6 +36,9 @@
 #define _D_META_ENTRY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class MetaEntryVisitor;
 
@@ -50,4 +53,7 @@ public:
 };
 
 typedef SharedHandle<MetaEntry> MetaEntryHandle;
+
+} // namespace aria2
+
 #endif // _D_META_ENTRY_H_
diff --git a/src/MetaEntryVisitor.h b/src/MetaEntryVisitor.h
index f5bebdc7..589a5747 100644
--- a/src/MetaEntryVisitor.h
+++ b/src/MetaEntryVisitor.h
@@ -35,7 +35,11 @@
 #ifndef _D_META_ENTRY_VISITOR_H_
 #define _D_META_ENTRY_VISITOR_H_
 
-#include "MetaEntry.h"
+#include "common.h"
+
+namespace aria2 {
+
+class MetaEntry;
 
 class MetaEntryVisitor {
 public:
@@ -44,4 +48,6 @@ public:
   virtual void visit(const MetaEntry* e) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_META_ENTRY_VISITOR_H_
diff --git a/src/MetaFileUtil.cc b/src/MetaFileUtil.cc
index 5e4d8787..9f5ea173 100644
--- a/src/MetaFileUtil.cc
+++ b/src/MetaFileUtil.cc
@@ -33,13 +33,17 @@
  */
 /* copyright --> */
 #include "MetaFileUtil.h"
+#include "Data.h"
+#include "Dictionary.h"
+#include "List.h"
 #include "File.h"
 #include "DlAbortEx.h"
 #include "message.h"
-#include "a2io.h"
-#include <string.h>
+#include <cstring>
 
-MetaEntry* MetaFileUtil::parseMetaFile(const string& file) {
+namespace aria2 {
+
+MetaEntry* MetaFileUtil::parseMetaFile(const std::string& file) {
   File f(file);
   int32_t len = f.size();
   char* buf = new char[len];
@@ -116,7 +120,7 @@ Dictionary* MetaFileUtil::parseDictionaryTree(const char** pp, const char* end)
 	(*pp)++;
 	break;
       }
-      string name = decodeWordAsString(pp, end);
+      std::string name = decodeWordAsString(pp, end);
       MetaEntry* e = bdecodingR(pp, end);
       dic->put(name, e);
     }
@@ -194,9 +198,11 @@ Data* MetaFileUtil::decodeWord(const char** pp, const char* end) {
   return data;
 }
 
-string MetaFileUtil::decodeWordAsString(const char** pp, const char* end) {
+std::string MetaFileUtil::decodeWordAsString(const char** pp, const char* end) {
   Data* data = decodeWord(pp, end);
-  string str = data->toString();
+  std::string str = data->toString();
   delete data;
   return str;
 }
+
+} // namespace aria2
diff --git a/src/MetaFileUtil.h b/src/MetaFileUtil.h
index 48693b7f..fdcae8c1 100644
--- a/src/MetaFileUtil.h
+++ b/src/MetaFileUtil.h
@@ -35,14 +35,15 @@
 #ifndef _D_META_FILE_UTIL_H_
 #define _D_META_FILE_UTIL_H_
 
-#include "MetaEntry.h"
-#include "Dictionary.h"
-#include "List.h"
-#include "Data.h"
 #include "common.h"
 #include <string>
 
-using namespace std;
+namespace aria2 {
+
+class MetaEntry;
+class Dictionary;
+class List;
+class Data;
 
 class MetaFileUtil {
 private:
@@ -53,11 +54,13 @@ private:
   static List* parseListTree(const char** pp, const char* end);
   static Data* decodeWord(const char** pp, const char* end);
   static Data* decodeInt(const char** pp, const char* end);
-  static string decodeWordAsString(const char** pp, const char* end);
+  static std::string decodeWordAsString(const char** pp, const char* end);
 
 public:
-  static MetaEntry* parseMetaFile(const string& file);
+  static MetaEntry* parseMetaFile(const std::string& file);
   static MetaEntry* bdecoding(const char* buf, int32_t len);
 };
 
+} // namespace aria2
+
 #endif // _D_META_FILE_UTIL_H_
diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc
index 624a53a9..10536fd4 100644
--- a/src/Metalink2RequestGroup.cc
+++ b/src/Metalink2RequestGroup.cc
@@ -36,6 +36,7 @@
 #include "RequestGroup.h"
 #include "Option.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "prefs.h"
 #include "Util.h"
 #include "message.h"
@@ -45,22 +46,33 @@
 #include "MemoryBufferPreDownloadHandler.h"
 #include "TrueRequestGroupCriteria.h"
 #include "MetalinkEntry.h"
+#include "MetalinkResource.h"
+#include "FileEntry.h"
 #ifdef ENABLE_BITTORRENT
 # include "BtDependency.h"
 #endif // ENABLE_BITTORRENT
+#ifdef ENABLE_MESSAGE_DIGEST
+# include "Checksum.h"
+# include "ChunkChecksum.h"
+#endif // ENABLE_MESSAGE_DIGEST
+#include <algorithm>
 
-Metalink2RequestGroup::Metalink2RequestGroup(const Option* option):_option(option), _logger(LogFactory::getInstance()) {}
+namespace aria2 {
+
+Metalink2RequestGroup::Metalink2RequestGroup(const Option* option):
+  _option(option),
+  _logger(LogFactory::getInstance()) {}
 
 Metalink2RequestGroup::~Metalink2RequestGroup() {}
 
 class AccumulateNonP2PUrl {
 private:
-  Strings& urlsPtr;
+  std::deque<std::string>& urlsPtr;
 public:
-  AccumulateNonP2PUrl(Strings& urlsPtr)
+  AccumulateNonP2PUrl(std::deque<std::string>& urlsPtr)
     :urlsPtr(urlsPtr) {}
 
-  void operator()(const MetalinkResourceHandle& resource) {
+  void operator()(const SharedHandle<MetalinkResource>& resource) {
     switch(resource->type) {
     case MetalinkResource::TYPE_HTTP:
     case MetalinkResource::TYPE_HTTPS:
@@ -77,7 +89,7 @@ class FindBitTorrentUrl {
 public:
   FindBitTorrentUrl() {}
 
-  bool operator()(const MetalinkResourceHandle& resource) {
+  bool operator()(const SharedHandle<MetalinkResource>& resource) {
     if(resource->type == MetalinkResource::TYPE_BITTORRENT) {
       return true;
     } else {
@@ -86,40 +98,43 @@ public:
   }
 };
 
-RequestGroups Metalink2RequestGroup::generate(const string& metalinkFile)
+std::deque<SharedHandle<RequestGroup> >
+Metalink2RequestGroup::generate(const std::string& metalinkFile)
 {
-  MetalinkEntries entries = MetalinkHelper::parseAndQuery(metalinkFile,
+  std::deque<SharedHandle<MetalinkEntry> > entries = MetalinkHelper::parseAndQuery(metalinkFile,
 							  _option);
   return createRequestGroup(entries);
 }
 
-RequestGroups Metalink2RequestGroup::generate(const BinaryStreamHandle& binaryStream)
+std::deque<SharedHandle<RequestGroup> >
+Metalink2RequestGroup::generate(const SharedHandle<BinaryStream>& binaryStream)
 {
-  MetalinkEntries entries = MetalinkHelper::parseAndQuery(binaryStream,
+  std::deque<SharedHandle<MetalinkEntry> > entries = MetalinkHelper::parseAndQuery(binaryStream,
 							  _option);
   return createRequestGroup(entries);
 }
 
-RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
+std::deque<SharedHandle<RequestGroup> >
+Metalink2RequestGroup::createRequestGroup(std::deque<SharedHandle<MetalinkEntry> > entries)
 {
   if(entries.size() == 0) {
     _logger->notice(EX_NO_RESULT_WITH_YOUR_PREFS);
-    return RequestGroups();
+    return std::deque<SharedHandle<RequestGroup> >();
   }
-  Integers selectIndexes = Util::parseIntRange(_option->get(PREF_SELECT_FILE)).flush();
+  std::deque<int32_t> selectIndexes = Util::parseIntRange(_option->get(PREF_SELECT_FILE)).flush();
   bool useIndex;
   if(selectIndexes.size()) {
     useIndex = true;
   } else {
     useIndex = false;
   }
-  RequestGroups groups;
+  std::deque<SharedHandle<RequestGroup> > groups;
   int32_t count = 0;
-  for(MetalinkEntries::iterator itr = entries.begin(); itr != entries.end();
+  for(std::deque<SharedHandle<MetalinkEntry> >::iterator itr = entries.begin(); itr != entries.end();
       itr++, ++count) {
-    MetalinkEntryHandle& entry = *itr;
+    SharedHandle<MetalinkEntry>& entry = *itr;
     if(_option->defined(PREF_METALINK_LOCATION)) {
-      Strings locations;
+      std::deque<std::string> locations;
       Util::slice(locations, _option->get(PREF_METALINK_LOCATION), ',', true);
       entry->setLocationPreference(locations, 100);
     }
@@ -127,7 +142,7 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
       entry->setProtocolPreference(_option->get(PREF_METALINK_PREFERRED_PROTOCOL), 100);
     }
     if(useIndex) {
-      if(find(selectIndexes.begin(), selectIndexes.end(), count+1) == selectIndexes.end()) {
+      if(std::find(selectIndexes.begin(), selectIndexes.end(), count+1) == selectIndexes.end()) {
 	continue;
       }
     }
@@ -136,17 +151,17 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
       continue;
     }
     _logger->info(MSG_METALINK_QUEUEING, entry->getPath().c_str());
-    MetalinkResources::iterator itr = find_if(entry->resources.begin(),
-					      entry->resources.end(),
-					      FindBitTorrentUrl());
+    std::deque<SharedHandle<MetalinkResource> >::iterator itr =
+      std::find_if(entry->resources.begin(), entry->resources.end(), FindBitTorrentUrl());
+
 #ifdef ENABLE_BITTORRENT
-    RequestGroupHandle torrentRg = 0;
+    SharedHandle<RequestGroup> torrentRg = 0;
     // there is torrent entry
     if(itr != entry->resources.end()) {
-      Strings uris;
+      std::deque<std::string> uris;
       uris.push_back((*itr)->url);
       torrentRg = new RequestGroup(_option, uris);
-      SingleFileDownloadContextHandle dctx =
+      SharedHandle<SingleFileDownloadContext> dctx =
 	new SingleFileDownloadContext(_option->getAsInt(PREF_SEGMENT_SIZE),
 				      0,
 				      "");
@@ -155,17 +170,17 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
       torrentRg->clearPreDowloadHandler();
       torrentRg->clearPostDowloadHandler();
       // make it in-memory download
-      PreDownloadHandlerHandle preh = new MemoryBufferPreDownloadHandler();
+      SharedHandle<PreDownloadHandler> preh = new MemoryBufferPreDownloadHandler();
       preh->setCriteria(new TrueRequestGroupCriteria());
       torrentRg->addPreDownloadHandler(preh);
       groups.push_back(torrentRg);
     }
 #endif // ENABLE_BITTORRENT
     entry->reorderResourcesByPreference();
-    Strings uris;
-    for_each(entry->resources.begin(), entry->resources.end(),
-	     AccumulateNonP2PUrl(uris));
-    RequestGroupHandle rg = new RequestGroup(_option, uris);
+    std::deque<std::string> uris;
+    std::for_each(entry->resources.begin(), entry->resources.end(),
+		  AccumulateNonP2PUrl(uris));
+    SharedHandle<RequestGroup> rg = new RequestGroup(_option, uris);
     // If piece hash is specified in the metalink,
     // make segment size equal to piece hash size.
     int32_t pieceLength;
@@ -178,7 +193,7 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
 #else
     pieceLength = _option->getAsInt(PREF_SEGMENT_SIZE);
 #endif // ENABLE_MESSAGE_DIGEST
-    SingleFileDownloadContextHandle dctx =
+    SharedHandle<SingleFileDownloadContext> dctx =
       new SingleFileDownloadContext(pieceLength,
 				    entry->getLength(),
 				    "",
@@ -198,7 +213,7 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
     rg->setDownloadContext(dctx);
     rg->setNumConcurrentCommand(entry->maxConnections < 0 ?
 				_option->getAsInt(PREF_METALINK_SERVERS) :
-				min<int32_t>(_option->getAsInt(PREF_METALINK_SERVERS), entry->maxConnections));
+				std::min<int32_t>(_option->getAsInt(PREF_METALINK_SERVERS), entry->maxConnections));
     // In metalink, multi connection to a single host is not allowed by default.
     rg->setSingleHostMultiConnectionEnabled(!_option->getAsBool(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL));
     
@@ -212,3 +227,5 @@ RequestGroups Metalink2RequestGroup::createRequestGroup(MetalinkEntries entries)
   }
   return groups;
 }
+
+} // namespace aria2
diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h
index d9c82cd3..8c1d0075 100644
--- a/src/Metalink2RequestGroup.h
+++ b/src/Metalink2RequestGroup.h
@@ -36,17 +36,17 @@
 #define _D_METALINK_2_REQUEST_GROUP_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class Option;
 class Logger;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class BinaryStream;
-typedef SharedHandle<BinaryStream> BinaryStreamHandle;
 class MetalinkEntry;
-typedef SharedHandle<MetalinkEntry> MetalinkEntryHandle;
-typedef deque<MetalinkEntryHandle> MetalinkEntries;
 
 class Metalink2RequestGroup {
 private:
@@ -54,15 +54,18 @@ private:
 
   const Logger* _logger;
 
-  RequestGroups createRequestGroup(MetalinkEntries entries);
+  std::deque<SharedHandle<RequestGroup> >
+  createRequestGroup(std::deque<SharedHandle<MetalinkEntry> > entries);
 public:
   Metalink2RequestGroup(const Option* option);
 
   ~Metalink2RequestGroup();
 
-  RequestGroups generate(const string& metalinkFile);
+  std::deque<SharedHandle<RequestGroup> > generate(const std::string& metalinkFile);
 
-  RequestGroups generate(const BinaryStreamHandle& binaryStream);
+  std::deque<SharedHandle<RequestGroup> > generate(const SharedHandle<BinaryStream>& binaryStream);
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_2_REQUEST_GROUP_H_
diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc
index c8b24242..9592750f 100644
--- a/src/MetalinkEntry.cc
+++ b/src/MetalinkEntry.cc
@@ -33,9 +33,18 @@
  */
 /* copyright --> */
 #include "MetalinkEntry.h"
+#include "MetalinkResource.h"
+#include "FileEntry.h"
 #include "Util.h"
+#include "a2functional.h"
+#ifdef ENABLE_MESSAGE_DIGEST
+# include "Checksum.h"
+# include "ChunkChecksum.h"
+#endif // ENABLE_MESSAGE_DIGEST
 #include <algorithm>
 
+namespace aria2 {
+
 MetalinkEntry::MetalinkEntry():
   file(0),
   maxConnections(-1)
@@ -50,39 +59,65 @@ MetalinkEntry::~MetalinkEntry() {}
 
 class AddLocationPreference {
 private:
-  Strings _locations;
+  std::deque<std::string> _locations;
   int32_t _preferenceToAdd;
 public:
-  AddLocationPreference(const Strings& locations, int32_t preferenceToAdd):
+  AddLocationPreference(const std::deque<std::string>& locations, int32_t preferenceToAdd):
     _locations(locations), _preferenceToAdd(preferenceToAdd)
   {
-    transform(_locations.begin(), _locations.end(), _locations.begin(), Util::toUpper);
-    sort(_locations.begin(), _locations.end());
+    std::transform(_locations.begin(), _locations.end(), _locations.begin(), Util::toUpper);
+    std::sort(_locations.begin(), _locations.end());
   }
 
-  void operator()(MetalinkResourceHandle& res) {
-    if(binary_search(_locations.begin(), _locations.end(), res->location)) {
+  void operator()(SharedHandle<MetalinkResource>& res) {
+    if(std::binary_search(_locations.begin(), _locations.end(), res->location)) {
       res->preference += _preferenceToAdd;
     }
   }
 };
 
-void MetalinkEntry::setLocationPreference(const Strings& locations,
+MetalinkEntry& MetalinkEntry::operator=(const MetalinkEntry& metalinkEntry)
+{
+  if(this != &metalinkEntry) {
+    this->file = metalinkEntry.file;
+    this->version = metalinkEntry.version;
+    this->language = metalinkEntry.language;
+    this->os = metalinkEntry.os;
+    this->maxConnections = metalinkEntry.maxConnections;
+#ifdef ENABLE_MESSAGE_DIGEST
+    this->checksum = metalinkEntry.checksum;
+    this->chunkChecksum = metalinkEntry.chunkChecksum;
+#endif // ENABLE_MESSAGE_DIGEST
+  }
+  return *this;
+}
+
+std::string MetalinkEntry::getPath() const
+{
+  return file->getPath();
+}
+
+int64_t MetalinkEntry::getLength() const
+{
+  return file->getLength();
+}
+
+void MetalinkEntry::setLocationPreference(const std::deque<std::string>& locations,
 					  int32_t preferenceToAdd)
 {
-  for_each(resources.begin(), resources.end(),
-	   AddLocationPreference(locations, preferenceToAdd));
+  std::for_each(resources.begin(), resources.end(),
+		AddLocationPreference(locations, preferenceToAdd));
 }
 
 class AddProtocolPreference {
 private:
-  const string& _protocol;
+  const std::string& _protocol;
   int32_t _preferenceToAdd;
 public:
-  AddProtocolPreference(const string& protocol, int32_t prefToAdd):
+  AddProtocolPreference(const std::string& protocol, int32_t prefToAdd):
     _protocol(protocol), _preferenceToAdd(prefToAdd) {}
 
-  void operator()(const MetalinkResourceHandle& res) const
+  void operator()(const SharedHandle<MetalinkResource>& res) const
   {
     if(_protocol == MetalinkResource::getTypeString(res->type)) {
       res->preference += _preferenceToAdd;
@@ -90,29 +125,30 @@ public:
   }
 };
 
-void MetalinkEntry::setProtocolPreference(const string& protocol,
+void MetalinkEntry::setProtocolPreference(const std::string& protocol,
 					  int32_t preferenceToAdd)
 {
-  for_each(resources.begin(), resources.end(),
-	   AddProtocolPreference(protocol, preferenceToAdd));
+  std::for_each(resources.begin(), resources.end(),
+		AddProtocolPreference(protocol, preferenceToAdd));
 }
 
 class PrefOrder {
 public:
-  bool operator()(const MetalinkResourceHandle& res1,
-		  const MetalinkResourceHandle& res2) {
+  bool operator()(const SharedHandle<MetalinkResource>& res1,
+		  const SharedHandle<MetalinkResource>& res2) {
     return res1->preference > res2->preference;
   }
 };
 
 void MetalinkEntry::reorderResourcesByPreference() {
-  random_shuffle(resources.begin(), resources.end());
-  sort(resources.begin(), resources.end(), PrefOrder());
+  std::random_shuffle(resources.begin(), resources.end());
+  std::sort(resources.begin(), resources.end(), PrefOrder());
 }
 
-class Supported {
+class Supported:public std::unary_function<SharedHandle<MetalinkResource>, bool> {
 public:
-  bool operator()(const MetalinkResourceHandle& res) {
+  bool operator()(const SharedHandle<MetalinkResource>& res) const
+  {
     switch(res->type) {
     case MetalinkResource::TYPE_FTP:
     case MetalinkResource::TYPE_HTTP:
@@ -130,18 +166,23 @@ public:
 };
 
 void MetalinkEntry::dropUnsupportedResource() {
-  MetalinkResources::iterator split =
-    partition(resources.begin(), resources.end(), Supported());
-  resources.erase(split, resources.end());
+  resources.erase(std::remove_if(resources.begin(), resources.end(),
+				 std::not1(Supported())),
+		  resources.end());
 }
 
-FileEntries MetalinkEntry::toFileEntry(const MetalinkEntries& metalinkEntries)
+std::deque<SharedHandle<FileEntry> >
+MetalinkEntry::toFileEntry(const std::deque<SharedHandle<MetalinkEntry> >& metalinkEntries)
 {
-  FileEntries entries;
-  for(MetalinkEntries::const_iterator itr = metalinkEntries.begin();
-      itr != metalinkEntries.end(); ++itr) {
-    entries.push_back((*itr)->file);
-  }
+  std::deque<SharedHandle<FileEntry> > entries;
+  std::transform(metalinkEntries.begin(), metalinkEntries.end(), back_inserter(entries),
+		 mem_fun_sh(&MetalinkEntry::getFile));
   return entries;
 }
 
+SharedHandle<FileEntry> MetalinkEntry::getFile() const
+{
+  return file;
+}
+
+} // namespace aria2
diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h
index 8ab64b20..c182e4b7 100644
--- a/src/MetalinkEntry.h
+++ b/src/MetalinkEntry.h
@@ -36,69 +36,55 @@
 #define _D_METALINK_ENTRY_H_
 
 #include "common.h"
-#include "MetalinkResource.h"
-#include "FileEntry.h"
-#ifdef ENABLE_MESSAGE_DIGEST
-# include "Checksum.h"
-# include "ChunkChecksum.h"
-#endif // ENABLE_MESSAGE_DIGEST
+#include "SharedHandle.h"
+#include <string>
 #include <deque>
 
-class MetalinkEntry;
+namespace aria2 {
 
-typedef SharedHandle<MetalinkEntry> MetalinkEntryHandle;
-typedef deque<MetalinkEntryHandle> MetalinkEntries;
+class MetalinkResource;
+class FileEntry;
+#ifdef ENABLE_MESSAGE_DIGEST
+class Checksum;
+class ChunkChecksum;
+#endif // ENABLE_MESSAGE_DIGEST
 
 class MetalinkEntry {
 public:
-  FileEntryHandle file;
-  string version;
-  string language;
-  string os;
-  MetalinkResources resources;
+  SharedHandle<FileEntry> file;
+  std::string version;
+  std::string language;
+  std::string os;
+  std::deque<SharedHandle<MetalinkResource> > resources;
   int32_t maxConnections;
 #ifdef ENABLE_MESSAGE_DIGEST
-  ChecksumHandle checksum;
-  ChunkChecksumHandle chunkChecksum;
+  SharedHandle<Checksum> checksum;
+  SharedHandle<ChunkChecksum> chunkChecksum;
 #endif // ENABLE_MESSAGE_DIGEST
 public:
   MetalinkEntry();
 
   ~MetalinkEntry();
 
-  MetalinkEntry& operator=(const MetalinkEntry& metalinkEntry) {
-    if(this != &metalinkEntry) {
-      this->file = metalinkEntry.file;
-      this->version = metalinkEntry.version;
-      this->language = metalinkEntry.language;
-      this->os = metalinkEntry.os;
-      this->maxConnections = metalinkEntry.maxConnections;
-#ifdef ENABLE_MESSAGE_DIGEST
-      this->checksum = metalinkEntry.checksum;
-      this->chunkChecksum = metalinkEntry.chunkChecksum;
-#endif // ENABLE_MESSAGE_DIGEST
-    }
-    return *this;
-  }
+  MetalinkEntry& operator=(const MetalinkEntry& metalinkEntry);
 
-  string getPath() const
-  {
-    return file->getPath();
-  }
+  std::string getPath() const;
 
-  int64_t getLength() const
-  {
-    return file->getLength();
-  }
+  int64_t getLength() const;
+
+  SharedHandle<FileEntry> getFile() const;
 
   void dropUnsupportedResource();
 
   void reorderResourcesByPreference();
   
-  void setLocationPreference(const Strings& locations, int32_t preferenceToAdd);
-  void setProtocolPreference(const string& protocol, int32_t preferenceToAdd);
+  void setLocationPreference(const std::deque<std::string>& locations, int32_t preferenceToAdd);
+  void setProtocolPreference(const std::string& protocol, int32_t preferenceToAdd);
 
-  static FileEntries toFileEntry(const MetalinkEntries& metalinkEntries);
+  static std::deque<SharedHandle<FileEntry> >
+  toFileEntry(const std::deque<SharedHandle<MetalinkEntry> >& metalinkEntries);
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_ENTRY_H_
diff --git a/src/MetalinkHelper.cc b/src/MetalinkHelper.cc
index 9f269367..8374b855 100644
--- a/src/MetalinkHelper.cc
+++ b/src/MetalinkHelper.cc
@@ -38,38 +38,47 @@
 #include "MetalinkProcessorFactory.h"
 #include "MetalinkParserStateMachine.h"
 #include "Metalinker.h"
+#include "MetalinkProcessor.h"
+#include "MetalinkProcessorFactory.h"
 #include "prefs.h"
 #include "DlAbortEx.h"
 #include "BinaryStream.h"
 
+namespace aria2 {
+
 MetalinkHelper::MetalinkHelper() {}
 
 MetalinkHelper::~MetalinkHelper() {}
 
-MetalinkEntries MetalinkHelper::parseAndQuery(const string& filename, const Option* option)
+std::deque<SharedHandle<MetalinkEntry> >
+MetalinkHelper::parseAndQuery(const std::string& filename, const Option* option)
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
 
-  MetalinkerHandle metalinker = proc->parseFile(filename);
+  SharedHandle<Metalinker> metalinker = proc->parseFile(filename);
   return query(metalinker, option);
 }
 
-MetalinkEntries MetalinkHelper::parseAndQuery(const BinaryStreamHandle& binaryStream, const Option* option)
+std::deque<SharedHandle<MetalinkEntry> >
+MetalinkHelper::parseAndQuery(const SharedHandle<BinaryStream>& binaryStream, const Option* option)
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
 
-  MetalinkerHandle metalinker = proc->parseFromBinaryStream(binaryStream);
+  SharedHandle<Metalinker> metalinker = proc->parseFromBinaryStream(binaryStream);
   return query(metalinker, option);
 }
 
-MetalinkEntries MetalinkHelper::query(const MetalinkerHandle& metalinker, const Option* option)
+std::deque<SharedHandle<MetalinkEntry> >
+MetalinkHelper::query(const SharedHandle<Metalinker>& metalinker, const Option* option)
 {
   if(metalinker->entries.empty()) {
     throw new DlAbortEx("No file entry found. Probably, the metalink file is not configured properly or broken.");
   }
-  MetalinkEntries entries =
+  std::deque<SharedHandle<MetalinkEntry> > entries =
     metalinker->queryEntry(option->get(PREF_METALINK_VERSION),
 			   option->get(PREF_METALINK_LANGUAGE),
 			   option->get(PREF_METALINK_OS));
   return entries;
 }
+
+} // namespace aria2
diff --git a/src/MetalinkHelper.h b/src/MetalinkHelper.h
index d15c23af..729f4e50 100644
--- a/src/MetalinkHelper.h
+++ b/src/MetalinkHelper.h
@@ -36,15 +36,16 @@
 #define _D_METALINK_HELPER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class Option;
 class MetalinkEntry;
-typedef SharedHandle<MetalinkEntry> MetalinkEntryHandle;
-typedef deque<MetalinkEntryHandle> MetalinkEntries;
 class BinaryStream;
-typedef SharedHandle<BinaryStream> BinaryStreamHandle;
 class Metalinker;
-typedef SharedHandle<Metalinker> MetalinkerHandle;
 
 class MetalinkHelper {
 private:
@@ -52,12 +53,17 @@ private:
 
   ~MetalinkHelper();
 
-  static MetalinkEntries query(const MetalinkerHandle& metalinker, const Option* option);
+  static std::deque<SharedHandle<MetalinkEntry> >
+  query(const SharedHandle<Metalinker>& metalinker, const Option* option);
 
 public:
-  static MetalinkEntries parseAndQuery(const string& filename, const Option* option);
+  static std::deque<SharedHandle<MetalinkEntry> >
+  parseAndQuery(const std::string& filename, const Option* option);
 
-  static MetalinkEntries parseAndQuery(const BinaryStreamHandle& binaryStream, const Option* option);
+  static std::deque<SharedHandle<MetalinkEntry> >
+  parseAndQuery(const SharedHandle<BinaryStream>& binaryStream, const Option* option);
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_HELPER_H_
diff --git a/src/MetalinkMetalinkParserState.cc b/src/MetalinkMetalinkParserState.cc
index 61a1b8e4..d2220c4b 100644
--- a/src/MetalinkMetalinkParserState.cc
+++ b/src/MetalinkMetalinkParserState.cc
@@ -35,9 +35,11 @@
 #include "MetalinkMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void MetalinkMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					       const string& name,
-					       const map<string, string>& attrs)
+					       const std::string& name,
+					       const std::map<std::string, std::string>& attrs)
 {
   if(name == "files") {
     stm->setFilesState();
@@ -47,8 +49,10 @@ void MetalinkMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void MetalinkMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					     const string& name,
-					     const string& characters)
+					     const std::string& name,
+					     const std::string& characters)
 {
   stm->setFinState();
 }
+
+} // namespace aria2
diff --git a/src/MetalinkMetalinkParserState.h b/src/MetalinkMetalinkParserState.h
index 06cfe666..e095c127 100644
--- a/src/MetalinkMetalinkParserState.h
+++ b/src/MetalinkMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class MetalinkMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_METALINK_PARSER_STATE_H_
diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc
index fd49914f..1b3bf3ea 100644
--- a/src/MetalinkParserController.cc
+++ b/src/MetalinkParserController.cc
@@ -36,10 +36,16 @@
 #include "Metalinker.h"
 #include "MetalinkEntry.h"
 #include "MetalinkResource.h"
+#include "FileEntry.h"
+#include "a2functional.h"
 #ifdef ENABLE_MESSAGE_DIGEST
 # include "Checksum.h"
 # include "ChunkChecksum.h"
+# include "messageDigest.h"
 #endif // ENABLE_MESSAGE_DIGEST
+#include <algorithm>
+
+namespace aria2 {
 
 MetalinkParserController::MetalinkParserController():
   _metalinker(new Metalinker()),
@@ -54,7 +60,7 @@ MetalinkParserController::MetalinkParserController():
 
 MetalinkParserController::~MetalinkParserController() {}
 
-MetalinkerHandle MetalinkParserController::getResult() const
+SharedHandle<Metalinker> MetalinkParserController::getResult() const
 {
   return _metalinker;
 }
@@ -69,7 +75,7 @@ void MetalinkParserController::newEntryTransaction()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::setFileNameOfEntry(const string& filename)
+void MetalinkParserController::setFileNameOfEntry(const std::string& filename)
 {
   if(_tEntry.isNull()) {
     return;
@@ -93,7 +99,7 @@ void MetalinkParserController::setFileLengthOfEntry(int64_t length)
   }
 }
 
-void MetalinkParserController::setVersionOfEntry(const string& version)
+void MetalinkParserController::setVersionOfEntry(const std::string& version)
 {
   if(_tEntry.isNull()) {
     return;
@@ -101,7 +107,7 @@ void MetalinkParserController::setVersionOfEntry(const string& version)
   _tEntry->version = version;
 }
 
-void MetalinkParserController::setLanguageOfEntry(const string& language)
+void MetalinkParserController::setLanguageOfEntry(const std::string& language)
 {
   if(_tEntry.isNull()) {
     return;
@@ -109,7 +115,7 @@ void MetalinkParserController::setLanguageOfEntry(const string& language)
   _tEntry->language = language;
 }
 
-void MetalinkParserController::setOSOfEntry(const string& os)
+void MetalinkParserController::setOSOfEntry(const std::string& os)
 {
   if(_tEntry.isNull()) {
     return;
@@ -153,7 +159,7 @@ void MetalinkParserController::newResourceTransaction()
   _tResource = new MetalinkResource();
 }
 
-void MetalinkParserController::setURLOfResource(const string& url)
+void MetalinkParserController::setURLOfResource(const std::string& url)
 {
   if(_tResource.isNull()) {
     return;
@@ -161,7 +167,7 @@ void MetalinkParserController::setURLOfResource(const string& url)
   _tResource->url = url;
 }
 
-void MetalinkParserController::setTypeOfResource(const string& type)
+void MetalinkParserController::setTypeOfResource(const std::string& type)
 {
   if(_tResource.isNull()) {
     return;
@@ -179,7 +185,7 @@ void MetalinkParserController::setTypeOfResource(const string& type)
   }
 }
 
-void MetalinkParserController::setLocationOfResource(const string& location)
+void MetalinkParserController::setLocationOfResource(const std::string& location)
 {
   if(_tResource.isNull()) {
     return;
@@ -227,7 +233,7 @@ void MetalinkParserController::newChecksumTransaction()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::setTypeOfChecksum(const string& type)
+void MetalinkParserController::setTypeOfChecksum(const std::string& type)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_tChecksum.isNull()) {
@@ -241,7 +247,7 @@ void MetalinkParserController::setTypeOfChecksum(const string& type)
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::setHashOfChecksum(const string& md)
+void MetalinkParserController::setHashOfChecksum(const std::string& md)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_tChecksum.isNull()) {
@@ -282,7 +288,7 @@ void MetalinkParserController::newChunkChecksumTransaction()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::setTypeOfChunkChecksum(const string& type)
+void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_tChunkChecksum.isNull()) {
@@ -310,13 +316,13 @@ void MetalinkParserController::setLengthOfChunkChecksum(int32_t length)
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::addHashOfChunkChecksum(int32_t order, const string& md)
+void MetalinkParserController::addHashOfChunkChecksum(int32_t order, const std::string& md)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_tChunkChecksum.isNull()) {
     return;
   }
-  _tempChunkChecksums.push_back(pair<int32_t, string>(order, md));
+  _tempChunkChecksums.push_back(std::pair<int32_t, std::string>(order, md));
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
@@ -330,7 +336,7 @@ void MetalinkParserController::createNewHashOfChunkChecksum(int32_t order)
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-void MetalinkParserController::setMessageDigestOfChunkChecksum(const string& md)
+void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string& md)
 {
 #ifdef ENABLE_MESSAGE_DIGEST
   if(_tChunkChecksum.isNull()) {
@@ -350,24 +356,6 @@ void MetalinkParserController::addHashOfChunkChecksum()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-bool firstAsc(const pair<int32_t, string>& p1, const pair<int32_t, string>& p2)
-{
-  return p1.first < p2.first;
-}
-
-class GetSecond
-{
-private:
-  Strings& ss;
-public:
-  GetSecond(Strings& s):ss(s) {}
-
-  void operator()(const pair<int32_t, string>& p)
-  {
-    ss.push_back(p.second);
-  }
-};
-
 void MetalinkParserController::commitChunkChecksumTransaction()
 {
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -375,10 +363,10 @@ void MetalinkParserController::commitChunkChecksumTransaction()
     return;
   }
   if(_tEntry->chunkChecksum.isNull() || _tEntry->chunkChecksum->getAlgo() != "sha1") {
-    sort(_tempChunkChecksums.begin(), _tempChunkChecksums.end(), firstAsc);
-    Strings checksums;
-    for_each(_tempChunkChecksums.begin(), _tempChunkChecksums.end(), GetSecond(checksums));
-    
+    std::sort(_tempChunkChecksums.begin(), _tempChunkChecksums.end(), Ascend1st<std::pair<int32_t, std::string> >());
+    std::deque<std::string> checksums;
+    std::transform(_tempChunkChecksums.begin(), _tempChunkChecksums.end(),
+		   back_inserter(checksums), select2nd<std::pair<int32_t, std::string> >());
     _tChunkChecksum->setChecksums(checksums);
     _tEntry->chunkChecksum = _tChunkChecksum;
   }
@@ -393,4 +381,4 @@ void MetalinkParserController::cancelChunkChecksumTransaction()
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
-
+} // namespace aria2
diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h
index cf498362..ab2a5952 100644
--- a/src/MetalinkParserController.h
+++ b/src/MetalinkParserController.h
@@ -36,37 +36,38 @@
 #define _D_METALINK_PARSER_CONTROLLER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <utility>
+#include <deque>
+
+namespace aria2 {
 
 class Metalinker;
-typedef SharedHandle<Metalinker> MetalinkerHandle;
 class MetalinkEntry;
-typedef SharedHandle<MetalinkEntry> MetalinkEntryHandle;
 class MetalinkResource;
-typedef SharedHandle<MetalinkResource> MetalinkResourceHandle;
 
 #ifdef ENABLE_MESSAGE_DIGEST
 class Checksum;
-typedef SharedHandle<Checksum> ChecksumHandle;
 class ChunkChecksum;
-typedef SharedHandle<ChunkChecksum> ChunkChecksumHandle;
 #endif // ENABLE_MESSAGE_DIGEST
 
 class MetalinkParserController {
 private:
-  MetalinkerHandle _metalinker;
+  SharedHandle<Metalinker> _metalinker;
 
-  MetalinkEntryHandle _tEntry;
+  SharedHandle<MetalinkEntry> _tEntry;
 
-  MetalinkResourceHandle _tResource;
+  SharedHandle<MetalinkResource> _tResource;
 
 #ifdef ENABLE_MESSAGE_DIGEST
-  ChecksumHandle _tChecksum;
+  SharedHandle<Checksum> _tChecksum;
 
-  ChunkChecksumHandle _tChunkChecksum;
+  SharedHandle<ChunkChecksum> _tChunkChecksum;
 
-  deque<pair<int32_t, string> > _tempChunkChecksums;
+  std::deque<std::pair<int32_t, std::string> > _tempChunkChecksums;
   
-  pair<int32_t, string> _tempHashPair;
+  std::pair<int32_t, std::string> _tempHashPair;
 #endif // ENABLE_MESSAGE_DIGEST
 
 public:
@@ -74,19 +75,19 @@ public:
 
   ~MetalinkParserController();
 
-  MetalinkerHandle getResult() const;
+  SharedHandle<Metalinker> getResult() const;
 
   void newEntryTransaction();
 
-  void setFileNameOfEntry(const string& filename);
+  void setFileNameOfEntry(const std::string& filename);
 
   void setFileLengthOfEntry(int64_t length);
 
-  void setVersionOfEntry(const string& version);
+  void setVersionOfEntry(const std::string& version);
 
-  void setLanguageOfEntry(const string& language);
+  void setLanguageOfEntry(const std::string& language);
 
-  void setOSOfEntry(const string& os);
+  void setOSOfEntry(const std::string& os);
 
   void setMaxConnectionsOfEntry(int32_t maxConnections);
 
@@ -96,11 +97,11 @@ public:
 
   void newResourceTransaction();
 
-  void setURLOfResource(const string& url);
+  void setURLOfResource(const std::string& url);
 
-  void setTypeOfResource(const string& type);
+  void setTypeOfResource(const std::string& type);
 
-  void setLocationOfResource(const string& location);
+  void setLocationOfResource(const std::string& location);
 
   void setPreferenceOfResource(int32_t preference);
 
@@ -112,9 +113,9 @@ public:
 
   void newChecksumTransaction();
 
-  void setTypeOfChecksum(const string& type);
+  void setTypeOfChecksum(const std::string& type);
 
-  void setHashOfChecksum(const string& md);
+  void setHashOfChecksum(const std::string& md);
 
   void commitChecksumTransaction();
 
@@ -122,15 +123,15 @@ public:
   
   void newChunkChecksumTransaction();
 
-  void setTypeOfChunkChecksum(const string& type);
+  void setTypeOfChunkChecksum(const std::string& type);
 
   void setLengthOfChunkChecksum(int32_t length);
 
-  void addHashOfChunkChecksum(int32_t order, const string& md);
+  void addHashOfChunkChecksum(int32_t order, const std::string& md);
 
   void createNewHashOfChunkChecksum(int32_t order);
 
-  void setMessageDigestOfChunkChecksum(const string& md);
+  void setMessageDigestOfChunkChecksum(const std::string& md);
 
   void addHashOfChunkChecksum();
 
@@ -139,4 +140,6 @@ public:
   void cancelChunkChecksumTransaction();
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_PARSER_CONTROLLER_H_
diff --git a/src/MetalinkParserState.h b/src/MetalinkParserState.h
index 8ad87b93..436758c2 100644
--- a/src/MetalinkParserState.h
+++ b/src/MetalinkParserState.h
@@ -38,16 +38,20 @@
 #include "common.h"
 #include <map>
 
+namespace aria2 {
+
 class MetalinkParserStateMachine;
 
 class MetalinkParserState
 {
 public:
   virtual void beginElement(MetalinkParserStateMachine* stm,
-			    const string& name, const map<string, string>& attrs) = 0;
+			    const std::string& name, const std::map<std::string, std::string>& attrs) = 0;
   
   virtual void endElement(MetalinkParserStateMachine* stm,
-			  const string& name, const string& characters) = 0;
+			  const std::string& name, const std::string& characters) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_PARSER_STATE_H_
diff --git a/src/MetalinkParserStateMachine.cc b/src/MetalinkParserStateMachine.cc
index 6d0fcbdf..990f1436 100644
--- a/src/MetalinkParserStateMachine.cc
+++ b/src/MetalinkParserStateMachine.cc
@@ -51,6 +51,9 @@
 #include "FinMetalinkParserState.h"
 #include "SkipTagMetalinkParserState.h"
 #include "Metalinker.h"
+#include "MetalinkEntry.h"
+
+namespace aria2 {
 
 MetalinkParserState* MetalinkParserStateMachine::_initialState = new InitialMetalinkParserState();
 MetalinkParserState* MetalinkParserStateMachine::_metalinkState = new MetalinkMetalinkParserState();
@@ -170,7 +173,7 @@ void MetalinkParserStateMachine::newEntryTransaction()
   _ctrl->newEntryTransaction();
 }
 
-void MetalinkParserStateMachine::setFileNameOfEntry(const string& filename)
+void MetalinkParserStateMachine::setFileNameOfEntry(const std::string& filename)
 {
   _ctrl->setFileNameOfEntry(filename);
 }
@@ -180,17 +183,17 @@ void MetalinkParserStateMachine::setFileLengthOfEntry(int64_t length)
   _ctrl->setFileLengthOfEntry(length);
 }
 
-void MetalinkParserStateMachine::setVersionOfEntry(const string& version)
+void MetalinkParserStateMachine::setVersionOfEntry(const std::string& version)
 {
   _ctrl->setVersionOfEntry(version);
 }
 
-void MetalinkParserStateMachine::setLanguageOfEntry(const string& language)
+void MetalinkParserStateMachine::setLanguageOfEntry(const std::string& language)
 {
   _ctrl->setLanguageOfEntry(language);
 }
 
-void MetalinkParserStateMachine::setOSOfEntry(const string& os)
+void MetalinkParserStateMachine::setOSOfEntry(const std::string& os)
 {
   _ctrl->setOSOfEntry(os);
 }
@@ -210,17 +213,17 @@ void MetalinkParserStateMachine::newResourceTransaction()
   _ctrl->newResourceTransaction();
 }
 
-void MetalinkParserStateMachine::setURLOfResource(const string& url)
+void MetalinkParserStateMachine::setURLOfResource(const std::string& url)
 {
   _ctrl->setURLOfResource(url);
 }
 
-void MetalinkParserStateMachine::setTypeOfResource(const string& type)
+void MetalinkParserStateMachine::setTypeOfResource(const std::string& type)
 {
   _ctrl->setTypeOfResource(type);
 }
 
-void MetalinkParserStateMachine::setLocationOfResource(const string& location)
+void MetalinkParserStateMachine::setLocationOfResource(const std::string& location)
 {
   _ctrl->setLocationOfResource(location);
 }
@@ -250,12 +253,12 @@ void MetalinkParserStateMachine::newChecksumTransaction()
   _ctrl->newChecksumTransaction();
 }
 
-void MetalinkParserStateMachine::setTypeOfChecksum(const string& type)
+void MetalinkParserStateMachine::setTypeOfChecksum(const std::string& type)
 {
   _ctrl->setTypeOfChecksum(type);
 }
 
-void MetalinkParserStateMachine::setHashOfChecksum(const string& md)
+void MetalinkParserStateMachine::setHashOfChecksum(const std::string& md)
 {
   _ctrl->setHashOfChecksum(md);
 }
@@ -280,7 +283,7 @@ void MetalinkParserStateMachine::setLengthOfChunkChecksum(int32_t length)
   _ctrl->setLengthOfChunkChecksum(length);
 }
 
-void MetalinkParserStateMachine::setTypeOfChunkChecksum(const string& type)
+void MetalinkParserStateMachine::setTypeOfChunkChecksum(const std::string& type)
 {
   _ctrl->setTypeOfChunkChecksum(type);
 }
@@ -290,7 +293,7 @@ void MetalinkParserStateMachine::createNewHashOfChunkChecksum(int32_t order)
   _ctrl->createNewHashOfChunkChecksum(order);
 }
 
-void MetalinkParserStateMachine::setMessageDigestOfChunkChecksum(const string& md)
+void MetalinkParserStateMachine::setMessageDigestOfChunkChecksum(const std::string& md)
 {
   _ctrl->setMessageDigestOfChunkChecksum(md);
 }
@@ -310,18 +313,20 @@ void MetalinkParserStateMachine::cancelChunkChecksumTransaction()
   _ctrl->cancelChunkChecksumTransaction();
 }
 
-void MetalinkParserStateMachine::beginElement(const string& name,
-					      const map<string, string>& attrs)
+void MetalinkParserStateMachine::beginElement(const std::string& name,
+					      const std::map<std::string, std::string>& attrs)
 {
   _state->beginElement(this, name, attrs);
 }
   
-void MetalinkParserStateMachine::endElement(const string& name, const string& characters)
+void MetalinkParserStateMachine::endElement(const std::string& name, const std::string& characters)
 {
   _state->endElement(this, name, characters);
 }
 
-MetalinkerHandle MetalinkParserStateMachine::getResult() const
+SharedHandle<Metalinker> MetalinkParserStateMachine::getResult() const
 {
   return _ctrl->getResult();
 }
+
+} // namespace aria2
diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h
index 0be7a352..501de16d 100644
--- a/src/MetalinkParserStateMachine.h
+++ b/src/MetalinkParserStateMachine.h
@@ -36,18 +36,20 @@
 #define _D_METALINK_PARSER_STATE_MACHINE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
 #include <map>
 
+namespace aria2 {
+
 class MetalinkParserController;
-typedef SharedHandle<MetalinkParserController> MetalinkParserControllerHandle;
 class MetalinkParserState;
 class SkipTagMetalinkParserState;
 class Metalinker;
-typedef SharedHandle<Metalinker> MetalinkerHandle;
 
 class MetalinkParserStateMachine {
 private:
-  MetalinkParserControllerHandle _ctrl;
+  SharedHandle<MetalinkParserController> _ctrl;
 
   MetalinkParserState* _state;
 
@@ -109,21 +111,21 @@ public:
 
   bool error() const;
 
-  void beginElement(const string& name, const map<string, string>& attrs);
+  void beginElement(const std::string& name, const std::map<std::string, std::string>& attrs);
   
-  void endElement(const string& name, const string& characters);
+  void endElement(const std::string& name, const std::string& characters);
 
   void newEntryTransaction();
 
-  void setFileNameOfEntry(const string& filename);
+  void setFileNameOfEntry(const std::string& filename);
 
   void setFileLengthOfEntry(int64_t length);
 
-  void setVersionOfEntry(const string& version);
+  void setVersionOfEntry(const std::string& version);
 
-  void setLanguageOfEntry(const string& language);
+  void setLanguageOfEntry(const std::string& language);
 
-  void setOSOfEntry(const string& os);
+  void setOSOfEntry(const std::string& os);
 
   void setMaxConnectionsOfEntry(int32_t maxConnections);
 
@@ -131,11 +133,11 @@ public:
 
   void newResourceTransaction();
 
-  void setURLOfResource(const string& url);
+  void setURLOfResource(const std::string& url);
 
-  void setTypeOfResource(const string& type);
+  void setTypeOfResource(const std::string& type);
 
-  void setLocationOfResource(const string& location);
+  void setLocationOfResource(const std::string& location);
 
   void setPreferenceOfResource(int32_t preference);
 
@@ -147,9 +149,9 @@ public:
 
   void newChecksumTransaction();
 
-  void setTypeOfChecksum(const string& type);
+  void setTypeOfChecksum(const std::string& type);
 
-  void setHashOfChecksum(const string& md);
+  void setHashOfChecksum(const std::string& md);
 
   void commitChecksumTransaction();
 
@@ -159,11 +161,11 @@ public:
 
   void setLengthOfChunkChecksum(int32_t length);
 
-  void setTypeOfChunkChecksum(const string& type);
+  void setTypeOfChunkChecksum(const std::string& type);
 
   void createNewHashOfChunkChecksum(int32_t order);
 
-  void setMessageDigestOfChunkChecksum(const string& md);
+  void setMessageDigestOfChunkChecksum(const std::string& md);
 
   void addHashOfChunkChecksum();
 
@@ -171,8 +173,9 @@ public:
 
   void cancelChunkChecksumTransaction();
 
-  MetalinkerHandle getResult() const;
+  SharedHandle<Metalinker> getResult() const;
 };
 
-typedef SharedHandle<MetalinkParserStateMachine> MetalinkParserStateMachineHandle;
+} //  namespace aria2
+
 #endif // _D_METALINK_PARSER_STATE_MACHINE_H_
diff --git a/src/MetalinkPostDownloadHandler.cc b/src/MetalinkPostDownloadHandler.cc
index a0f305c4..f8b48c24 100644
--- a/src/MetalinkPostDownloadHandler.cc
+++ b/src/MetalinkPostDownloadHandler.cc
@@ -40,6 +40,9 @@
 #include "PieceStorage.h"
 #include "DownloadHandlerConstants.h"
 #include "ContentTypeRequestGroupCriteria.h"
+#include "Exception.h"
+
+namespace aria2 {
 
 MetalinkPostDownloadHandler::MetalinkPostDownloadHandler()
 {
@@ -49,15 +52,16 @@ MetalinkPostDownloadHandler::MetalinkPostDownloadHandler()
 
 MetalinkPostDownloadHandler::~MetalinkPostDownloadHandler() {}
 
-RequestGroups MetalinkPostDownloadHandler::getNextRequestGroups(RequestGroup* requestGroup)
+std::deque<SharedHandle<RequestGroup> >
+MetalinkPostDownloadHandler::getNextRequestGroups(RequestGroup* requestGroup)
 {
   const Option* op = requestGroup->getOption();
   _logger->debug("Generating RequestGroups for Metalink file %s",
 		 requestGroup->getFilePath().c_str());
-  DiskAdaptorHandle diskAdaptor = requestGroup->getPieceStorage()->getDiskAdaptor();
+  SharedHandle<DiskAdaptor> diskAdaptor = requestGroup->getPieceStorage()->getDiskAdaptor();
   try {
     diskAdaptor->openExistingFile();
-    RequestGroups rgs = Metalink2RequestGroup(op).generate(diskAdaptor);
+    std::deque<SharedHandle<RequestGroup> > rgs = Metalink2RequestGroup(op).generate(diskAdaptor);
     diskAdaptor->closeFile();
     return rgs;
   } catch(Exception* e) {
@@ -65,3 +69,5 @@ RequestGroups MetalinkPostDownloadHandler::getNextRequestGroups(RequestGroup* re
     throw;
   }
 }
+
+} // namespace aria2
diff --git a/src/MetalinkPostDownloadHandler.h b/src/MetalinkPostDownloadHandler.h
index a4af00a8..78590662 100644
--- a/src/MetalinkPostDownloadHandler.h
+++ b/src/MetalinkPostDownloadHandler.h
@@ -37,6 +37,8 @@
 
 #include "PostDownloadHandler.h"
 
+namespace aria2 {
+
 class MetalinkPostDownloadHandler:public PostDownloadHandler
 {
 public:
@@ -44,8 +46,12 @@ public:
 
   virtual ~MetalinkPostDownloadHandler();
 
-  virtual RequestGroups getNextRequestGroups(RequestGroup* requestGroup);
+  virtual std::deque<SharedHandle<RequestGroup> >
+  getNextRequestGroups(RequestGroup* requestGroup);
 };
 
 typedef SharedHandle<MetalinkPostDownloadHandler> MetalinkPostDownloadHandlerHandle;
+
+} // namespace aria2
+
 #endif // _D_METALINK_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/MetalinkProcessor.h b/src/MetalinkProcessor.h
index 7ea64647..a6060650 100644
--- a/src/MetalinkProcessor.h
+++ b/src/MetalinkProcessor.h
@@ -35,21 +35,24 @@
 #ifndef _D_METALINK_PROCESSOR_H_
 #define _D_METALINK_PROCESSOR_H_
 
-#include "Metalinker.h"
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
 
+namespace aria2 {
+
+class Metalinker;
 class BinaryStream;
-typedef SharedHandle<BinaryStream> BinaryStreamHandle;
 
 class MetalinkProcessor {
 public:
   virtual ~MetalinkProcessor() {}
 
-  virtual MetalinkerHandle parseFile(const string& filename) = 0;
+  virtual SharedHandle<Metalinker> parseFile(const std::string& filename) = 0;
 
-  virtual MetalinkerHandle parseFromBinaryStream(const BinaryStreamHandle& binaryStream) = 0;
+  virtual SharedHandle<Metalinker> parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream) = 0;
 };
 
-typedef SharedHandle<MetalinkProcessor> MetalinkProcessorHandle;
+} // namespace aria2
 
 #endif // _D_METALINK_PROCESSOR_H_
diff --git a/src/MetalinkProcessorFactory.cc b/src/MetalinkProcessorFactory.cc
index 6be29798..a293e2da 100644
--- a/src/MetalinkProcessorFactory.cc
+++ b/src/MetalinkProcessorFactory.cc
@@ -40,7 +40,9 @@
 #endif
 #include "MetalinkParserStateMachine.h"
 
-MetalinkProcessorHandle MetalinkProcessorFactory::newInstance()
+namespace aria2 {
+
+SharedHandle<MetalinkProcessor> MetalinkProcessorFactory::newInstance()
 {
 #ifdef HAVE_LIBXML2
   return new XML2SAXMetalinkProcessor();
@@ -50,3 +52,5 @@ MetalinkProcessorHandle MetalinkProcessorFactory::newInstance()
   return 0;
 #endif
 }
+
+} // namespace aria2
diff --git a/src/MetalinkProcessorFactory.h b/src/MetalinkProcessorFactory.h
index 50163512..e5bb6e49 100644
--- a/src/MetalinkProcessorFactory.h
+++ b/src/MetalinkProcessorFactory.h
@@ -36,13 +36,19 @@
 #define _D_METALINK_PROCESSOR_FACTORY_H_
 
 #include "common.h"
-#include "MetalinkProcessor.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class MetalinkProcessor;
 
 class MetalinkProcessorFactory {
 private:
   MetalinkProcessorFactory() {}
 public:
-  static MetalinkProcessorHandle newInstance(); 
+  static SharedHandle<MetalinkProcessor> newInstance(); 
 };
 
+} // namespace aria2
+
 #endif // _D_METALINK_PROCESSOR_FACTORY_H__
diff --git a/src/MetalinkResource.cc b/src/MetalinkResource.cc
index 1fa2277f..d5376cad 100644
--- a/src/MetalinkResource.cc
+++ b/src/MetalinkResource.cc
@@ -34,7 +34,9 @@
 /* copyright --> */
 #include "MetalinkResource.h"
 
-string MetalinkResource::type2String[] = {
+namespace aria2 {
+
+std::string MetalinkResource::type2String[] = {
   "ftp", "http", "https", "bittorrent", "not_supported"
 };
 
@@ -43,3 +45,5 @@ MetalinkResource::MetalinkResource():
 {}
 
 MetalinkResource::~MetalinkResource() {}
+
+} // namespace aria2
diff --git a/src/MetalinkResource.h b/src/MetalinkResource.h
index 7fb872cc..f3e1d2b7 100644
--- a/src/MetalinkResource.h
+++ b/src/MetalinkResource.h
@@ -36,6 +36,9 @@
 #define _D_METALINK_RESOURCE_H_
 
 #include "common.h"
+#include <string>
+
+namespace aria2 {
 
 class MetalinkResource {
 public:
@@ -47,11 +50,11 @@ public:
     TYPE_NOT_SUPPORTED
   };
 
-  static string type2String[];
+  static std::string type2String[];
 public:
-  string url;
+  std::string url;
   TYPE type;
-  string location;
+  std::string location;
   int32_t preference;
   int32_t maxConnections;
 public:
@@ -69,13 +72,12 @@ public:
     return *this;
   }
 
-  static const string& getTypeString(TYPE type)
+  static const std::string& getTypeString(TYPE type)
   {
     return type2String[type];
   }
 };
 
-typedef SharedHandle<MetalinkResource> MetalinkResourceHandle;
-typedef deque<MetalinkResourceHandle> MetalinkResources;
+} // namespace aria2
 
 #endif // _D_METALINK_RESOURCE_H_
diff --git a/src/Metalinker.cc b/src/Metalinker.cc
index db8a2854..6e6ef6ee 100644
--- a/src/Metalinker.cc
+++ b/src/Metalinker.cc
@@ -33,27 +33,29 @@
  */
 /* copyright --> */
 #include "Metalinker.h"
+#include "MetalinkEntry.h"
 #include <algorithm>
 
-Metalinker::Metalinker() {
-}
+namespace aria2 {
+
+Metalinker::Metalinker() {}
 
 Metalinker::~Metalinker() {}
 
-class EntryQuery {
+class EntryQuery:public std::unary_function<SharedHandle<MetalinkEntry>, bool> {
 private:
-  string version;
-  string language;
-  string os;
+  std::string version;
+  std::string language;
+  std::string os;
 public:
-  EntryQuery(const string& version,
-	     const string& language,
-	     const string& os):
+  EntryQuery(const std::string& version,
+	     const std::string& language,
+	     const std::string& os):
     version(version),
     language(language),
     os(os) {}
 
-  bool operator()(const MetalinkEntryHandle& entry) {
+  bool operator()(const SharedHandle<MetalinkEntry>& entry) const {
     if(!version.empty()) {
       if(version != entry->version) {
 	return false;
@@ -73,13 +75,17 @@ public:
   }
 };
 
-MetalinkEntries Metalinker::queryEntry(const string& version,
-				       const string& language,
-				       const string& os) const {
-  MetalinkEntries resultEntries(entries.begin(), entries.end());
-  MetalinkEntries::iterator split =
-    partition(resultEntries.begin(), resultEntries.end(),
-	      EntryQuery(version, language, os));
-  resultEntries.erase(split, resultEntries.end());
+std::deque<SharedHandle<MetalinkEntry> >
+Metalinker::queryEntry(const std::string& version,
+		       const std::string& language,
+		       const std::string& os) const
+{
+  std::deque<SharedHandle<MetalinkEntry> > resultEntries(entries);
+  resultEntries.erase(std::remove_if(resultEntries.begin(),
+				     resultEntries.end(),
+				     std::not1(EntryQuery(version, language, os))),
+		      resultEntries.end());
   return resultEntries;
 }
+
+} // namespace aria2
diff --git a/src/Metalinker.h b/src/Metalinker.h
index 21e7a957..4ede3cee 100644
--- a/src/Metalinker.h
+++ b/src/Metalinker.h
@@ -36,12 +36,17 @@
 #define _D_METALINKER_H_
 
 #include "common.h"
-#include "MetalinkEntry.h"
+#include "SharedHandle.h"
+#include <string>
 #include <deque>
 
+namespace aria2 {
+
+class MetalinkEntry;
+
 class Metalinker {
 public:
-  MetalinkEntries entries;
+  std::deque<SharedHandle<MetalinkEntry> > entries;
 public:
   Metalinker();
   ~Metalinker();
@@ -53,11 +58,11 @@ public:
     return *this;
   }
 
-  MetalinkEntries queryEntry(const string& version,
-			     const string& language,
-			     const string& os) const;
+  std::deque<SharedHandle<MetalinkEntry> >
+  queryEntry(const std::string& version, const std::string& language,
+	     const std::string& os) const;
 };
 
-typedef SharedHandle<Metalinker> MetalinkerHandle;
+} // namespace aria2
 
 #endif // _D_METALINKER_H_
diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc
index c8aaaa62..9f245c72 100644
--- a/src/MultiDiskAdaptor.cc
+++ b/src/MultiDiskAdaptor.cc
@@ -36,9 +36,79 @@
 #include "DefaultDiskWriter.h"
 #include "message.h"
 #include "Util.h"
+#include "FileEntry.h"
 #include "MultiFileAllocationIterator.h"
 #include "DefaultDiskWriterFactory.h"
 #include "DlAbortEx.h"
+#include "File.h"
+
+namespace aria2 {
+
+DiskWriterEntry::DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry):
+  fileEntry(fileEntry),
+  diskWriter(0) {}
+
+DiskWriterEntry::~DiskWriterEntry() {}
+
+std::string DiskWriterEntry::getFilePath(const std::string& topDir) const
+{
+  return topDir+"/"+fileEntry->getPath();
+}
+
+void DiskWriterEntry::initAndOpenFile(const std::string& topDir)
+{
+  diskWriter->initAndOpenFile(getFilePath(topDir), fileEntry->getLength());
+}
+
+void DiskWriterEntry::openFile(const std::string& topDir)
+{
+  diskWriter->openFile(getFilePath(topDir), fileEntry->getLength());
+}
+
+void DiskWriterEntry::openExistingFile(const std::string& topDir)
+{
+  diskWriter->openExistingFile(getFilePath(topDir), fileEntry->getLength());
+}
+
+void DiskWriterEntry::closeFile()
+{
+  diskWriter->closeFile();
+}
+
+bool DiskWriterEntry::fileExists(const std::string& topDir)
+{
+  return File(getFilePath(topDir)).exists();
+}
+
+int64_t DiskWriterEntry::size() const
+{
+  return diskWriter->size();
+}
+
+SharedHandle<FileEntry> DiskWriterEntry::getFileEntry() const
+{
+  return fileEntry;
+}
+
+void DiskWriterEntry::setDiskWriter(const SharedHandle<DiskWriter>& diskWriter)
+{
+  this->diskWriter = diskWriter;
+}
+
+SharedHandle<DiskWriter> DiskWriterEntry::getDiskWriter() const
+{
+  return diskWriter;
+}
+
+bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const
+{
+  return fileEntry < entry.fileEntry;
+}
+
+MultiDiskAdaptor::MultiDiskAdaptor():
+  pieceLength(0) {}
+
+MultiDiskAdaptor::~MultiDiskAdaptor() {}
 
 void MultiDiskAdaptor::resetDiskWriterEntries()
 {
@@ -56,7 +126,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
   }
 }
 
-string MultiDiskAdaptor::getTopDirPath() const
+std::string MultiDiskAdaptor::getTopDirPath() const
 {
   return storeDir+"/"+topDir;
 }
@@ -224,3 +294,5 @@ void MultiDiskAdaptor::disableDirectIO()
     (*itr)->getDiskWriter()->disableDirectIO();
   }
 }
+
+} // namespace aria2
diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h
index d28a468a..713a4751 100644
--- a/src/MultiDiskAdaptor.h
+++ b/src/MultiDiskAdaptor.h
@@ -36,83 +36,53 @@
 #define _D_MULTI_DISK_ADAPTOR_H_
 
 #include "DiskAdaptor.h"
-#include "DiskWriter.h"
-#include "File.h"
+
+namespace aria2 {
 
 class MultiFileAllocationIterator;
+class FileEntry;
+class DiskWriter;
 
 class DiskWriterEntry {
 private:
-  FileEntryHandle fileEntry;
-  DiskWriterHandle diskWriter;
+  SharedHandle<FileEntry> fileEntry;
+  SharedHandle<DiskWriter> diskWriter;
 public:
-  DiskWriterEntry(const FileEntryHandle& fileEntry):
-    fileEntry(fileEntry),
-    diskWriter(0) {}
+  DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry);
 
-  ~DiskWriterEntry() {}
+  ~DiskWriterEntry();
 
-  string getFilePath(const string& topDir) const
-  {
-    return topDir+"/"+fileEntry->getPath();
-  }
+  std::string getFilePath(const std::string& topDir) const;
 
-  void initAndOpenFile(const string& topDir)
-  {
-    diskWriter->initAndOpenFile(getFilePath(topDir), fileEntry->getLength());
-  }
+  void initAndOpenFile(const std::string& topDir);
 
-  void openFile(const string& topDir)
-  {
-    diskWriter->openFile(getFilePath(topDir), fileEntry->getLength());
-  }
+  void openFile(const std::string& topDir);
 
-  void openExistingFile(const string& topDir)
-  {
-    diskWriter->openExistingFile(getFilePath(topDir), fileEntry->getLength());
-  }
+  void openExistingFile(const std::string& topDir);
 
-  void closeFile()
-  {
-    diskWriter->closeFile();
-  }
+  void closeFile();
 
-  bool fileExists(const string& topDir)
-  {
-    return File(getFilePath(topDir)).exists();
-  }
+  bool fileExists(const std::string& topDir);
 
-  int64_t size() const
-  {
-    return diskWriter->size();
-  }
+  int64_t size() const;
 
-  FileEntryHandle getFileEntry() const {
-    return fileEntry;
-  }
+  SharedHandle<FileEntry> getFileEntry() const;
 
-  void setDiskWriter(const DiskWriterHandle& diskWriter) {
-    this->diskWriter = diskWriter;
-  }
+  void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter);
 
-  DiskWriterHandle getDiskWriter() const {
-    return diskWriter;
-  }
+  SharedHandle<DiskWriter> getDiskWriter() const;
 
-  bool operator<(const DiskWriterEntry& entry) const
-  {
-    return fileEntry < entry.fileEntry;
-  }
+  bool operator<(const DiskWriterEntry& entry) const;
 };
 
 typedef SharedHandle<DiskWriterEntry> DiskWriterEntryHandle;
 
-typedef deque<DiskWriterEntryHandle> DiskWriterEntries;
+typedef std::deque<DiskWriterEntryHandle> DiskWriterEntries;
 
 class MultiDiskAdaptor : public DiskAdaptor {
   friend class MultiFileAllocationIterator;
 private:
-  string topDir;
+  std::string topDir;
   int32_t pieceLength;
   DiskWriterEntries diskWriterEntries;
 
@@ -128,12 +98,11 @@ private:
 			  int64_t fileOffset,
 			  int32_t rem) const;
 
-  string getTopDirPath() const;
+  std::string getTopDirPath() const;
 public:
-  MultiDiskAdaptor():pieceLength(0)
-  {}
+  MultiDiskAdaptor();
 
-  virtual ~MultiDiskAdaptor() {}
+  virtual ~MultiDiskAdaptor();
 
   virtual void initAndOpenFile();
 
@@ -152,24 +121,24 @@ public:
 
   virtual bool fileExists();
 
-  virtual string getFilePath()
+  virtual std::string getFilePath()
   {
     return getTopDirPath();
   }
 
   virtual int64_t size() const;
 
-  virtual FileAllocationIteratorHandle fileAllocationIterator();
+  virtual SharedHandle<FileAllocationIterator> fileAllocationIterator();
 
   virtual void enableDirectIO();
 
   virtual void disableDirectIO();
 
-  void setTopDir(const string& topDir) {
+  void setTopDir(const std::string& topDir) {
     this->topDir = topDir;
   }
 
-  const string& getTopDir() const {
+  const std::string& getTopDir() const {
     return topDir;
   }
 
@@ -194,4 +163,6 @@ public:
 
 typedef SharedHandle<MultiDiskAdaptor> MultiDiskAdaptorHandle;
 
+} // namespace aria2
+
 #endif // _D_MULTI_DISK_ADAPTOR_H_
diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc
index b6f8dd10..6828a2c4 100644
--- a/src/MultiFileAllocationIterator.cc
+++ b/src/MultiFileAllocationIterator.cc
@@ -36,6 +36,9 @@
 #include "MultiDiskAdaptor.h"
 #include "FileEntry.h"
 #include "SingleFileAllocationIterator.h"
+#include "DiskWriter.h"
+
+namespace aria2 {
 
 MultiFileAllocationIterator::MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor):
   _diskAdaptor(diskAdaptor),
@@ -115,7 +118,7 @@ DiskWriterEntries MultiFileAllocationIterator::makeDiskWriterEntries(const DiskW
   DiskWriterEntries entries;
   DiskWriterEntries::const_iterator done = temp.begin();
   for(DiskWriterEntries::const_iterator itr = temp.begin()+1; itr != temp.end(); ++itr) {
-    FileEntryHandle fileEntry = (*itr)->getFileEntry();
+    const FileEntryHandle& fileEntry = (*itr)->getFileEntry();
     if(!fileEntry->isRequested()) {
       continue;
     }
@@ -132,3 +135,5 @@ DiskWriterEntries MultiFileAllocationIterator::makeDiskWriterEntries(const DiskW
   }
   return entries;
 }
+
+} // namespace aria2
diff --git a/src/MultiFileAllocationIterator.h b/src/MultiFileAllocationIterator.h
index a9b4aa8a..4e79b599 100644
--- a/src/MultiFileAllocationIterator.h
+++ b/src/MultiFileAllocationIterator.h
@@ -36,23 +36,25 @@
 #define _D_MULTI_FILE_ALLOCATION_ITERATOR_H_
 
 #include "FileAllocationIterator.h"
+#include <deque>
+
+namespace aria2 {
 
 class MultiDiskAdaptor;
 class DiskWriterEntry;
-typedef SharedHandle<DiskWriterEntry> DiskWriterEntryHandle;
-typedef deque<DiskWriterEntryHandle> DiskWriterEntries;
 class SingleFileAllocationIterator;
-typedef SharedHandle<SingleFileAllocationIterator> SingleFileAllocationIteratorHandle;
 
 class MultiFileAllocationIterator:public FileAllocationIterator
 {
 private:
   MultiDiskAdaptor* _diskAdaptor;
-  DiskWriterEntries _entries;
-  SingleFileAllocationIteratorHandle _fileAllocationIterator;
+  std::deque<SharedHandle<DiskWriterEntry> > _entries;
+  SharedHandle<SingleFileAllocationIterator> _fileAllocationIterator;
   int64_t _offset;
 
-  DiskWriterEntries makeDiskWriterEntries(const DiskWriterEntries& srcEntries, int32_t pieceLength) const;
+  std::deque<SharedHandle<DiskWriterEntry> >
+  makeDiskWriterEntries(const std::deque<SharedHandle<DiskWriterEntry> >& srcEntries,
+			int32_t pieceLength) const;
 public:
   MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor);
 
@@ -66,9 +68,11 @@ public:
 
   virtual int64_t getTotalLength();
 
-  const DiskWriterEntries& getDiskWriterEntries() const;
+  const std::deque<SharedHandle<DiskWriterEntry> >& getDiskWriterEntries() const;
 };
 
 typedef SharedHandle<MultiFileAllocationIterator> MultiFileAllocationIteratorHandle;
 
+} // namespace aria2
+
 #endif // _D_MULTI_FILE_ALLOCATION_ITERATOR_H_
diff --git a/src/MultiUrlRequestInfo.cc b/src/MultiUrlRequestInfo.cc
index db129d1f..9180c551 100644
--- a/src/MultiUrlRequestInfo.cc
+++ b/src/MultiUrlRequestInfo.cc
@@ -36,6 +36,7 @@
 #include "RequestGroupMan.h"
 #include "DownloadEngine.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "RequestGroup.h"
 #include "prefs.h"
 #include "DownloadEngineFactory.h"
@@ -45,6 +46,9 @@
 #include "Util.h"
 #include "ConsoleStatCalc.h"
 #include <signal.h>
+#include <iostream>
+
+namespace aria2 {
 
 #ifndef SA_RESETHAND
 # define SA_RESETHAND 0x80000000
@@ -70,11 +74,11 @@ MultiUrlRequestInfo::~MultiUrlRequestInfo() {}
 
 void MultiUrlRequestInfo::printMessageForContinue()
 {
-  cout << "\n"
-       << _("aria2 will resume download if the transfer is restarted.")
-       << "\n"
-       << _("If there are any errors, then see the log file. See '-l' option in help/man page for details.")
-       << "\n";
+  std::cout << "\n"
+	    << _("aria2 will resume download if the transfer is restarted.")
+	    << "\n"
+	    << _("If there are any errors, then see the log file. See '-l' option in help/man page for details.")
+	    << "\n";
 }
 
 void MultiUrlRequestInfo::execute()
@@ -103,8 +107,8 @@ void MultiUrlRequestInfo::execute()
     
     e->run();
     
-    e->_requestGroupMan->showDownloadResults(cout);
-    cout << flush;
+    e->_requestGroupMan->showDownloadResults(std::cout);
+    std::cout << std::flush;
 
     if(!e->_requestGroupMan->downloadFinished()) {
       printMessageForContinue();
@@ -116,3 +120,5 @@ void MultiUrlRequestInfo::execute()
   Util::setGlobalSignalHandler(SIGINT, SIG_DFL, 0);
   Util::setGlobalSignalHandler(SIGTERM, SIG_DFL, 0);
 }
+
+} // namespace aria2
diff --git a/src/MultiUrlRequestInfo.h b/src/MultiUrlRequestInfo.h
index 650141a9..87a429f1 100644
--- a/src/MultiUrlRequestInfo.h
+++ b/src/MultiUrlRequestInfo.h
@@ -36,16 +36,18 @@
 #define _D_MULTI_URL_REQUEST_INFO_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class Option;
 class Logger;
 
 class MultiUrlRequestInfo {
 private:
-  RequestGroups _requestGroups;
+  std::deque<SharedHandle<RequestGroup> > _requestGroups;
 
   Option* _option;
 
@@ -54,7 +56,7 @@ private:
   void printMessageForContinue();
 
 public:
-  MultiUrlRequestInfo(const RequestGroups& requestGroups, Option* op);
+  MultiUrlRequestInfo(const std::deque<SharedHandle<RequestGroup> >& requestGroups, Option* op);
   
   virtual ~MultiUrlRequestInfo();
 
@@ -62,4 +64,7 @@ public:
 };
 
 typedef SharedHandle<MultiUrlRequestInfo> MultiUrlRequestInfoHandle;
+
+} // namespace aria2
+
 #endif // _D_MULTI_URL_REQUEST_INFO_H_
diff --git a/src/NameMatchOptionHandler.h b/src/NameMatchOptionHandler.h
index 2cdce59e..5f4c1139 100644
--- a/src/NameMatchOptionHandler.h
+++ b/src/NameMatchOptionHandler.h
@@ -38,22 +38,26 @@
 #include "OptionHandler.h"
 #include "DlAbortEx.h"
 
+namespace aria2 {
+
+class Option;
+
 class NameMatchOptionHandler : public OptionHandler {
 protected:
-  string _optName;
+  std::string _optName;
 
-  virtual void parseArg(Option* option, const string& arg) = 0;
+  virtual void parseArg(Option* option, const std::string& arg) = 0;
 public:
-  NameMatchOptionHandler(const string& optName):_optName(optName) {}
+  NameMatchOptionHandler(const std::string& optName):_optName(optName) {}
 
   virtual ~NameMatchOptionHandler() {}
   
-  virtual bool canHandle(const string& optName)
+  virtual bool canHandle(const std::string& optName)
   {
     return strcasecmp(_optName.c_str(), optName.c_str()) == 0;
   }
 
-  virtual void parse(Option* option, const string& arg)
+  virtual void parse(Option* option, const std::string& arg)
   {
     try {
       parseArg(option, arg);
@@ -65,4 +69,6 @@ public:
 
 typedef SharedHandle<NameMatchOptionHandler> NameMatchOptionHandlerHandle;
 
+} // namespace aria2
+
 #endif // _D_NAME_MATCH_OPTION_HANDLER_H_
diff --git a/src/NameResolver.cc b/src/NameResolver.cc
index 383ae7c8..6cdbae83 100644
--- a/src/NameResolver.cc
+++ b/src/NameResolver.cc
@@ -33,14 +33,18 @@
  */
 /* copyright --> */
 #include "NameResolver.h"
+#include <cstring>
+
+namespace aria2 {
 
 #ifdef ENABLE_ASYNC_DNS
 
 #ifdef HAVE_LIBCARES1_5
-void callback(void* arg, int status, int timeouts, struct hostent* host) {
+void callback(void* arg, int status, int timeouts, struct hostent* host)
 #else
-void callback(void* arg, int status, struct hostent* host) {
+void callback(void* arg, int status, struct hostent* host)
 #endif // HAVE_LIBCARES1_5
+{
   NameResolver* resolverPtr = (NameResolver*)arg;
 #ifdef HAVE_LIBARES
   // This block is required since the assertion in ares_strerror fails
@@ -64,12 +68,28 @@ void callback(void* arg, int status, struct hostent* host) {
   resolverPtr->status = NameResolver::STATUS_SUCCESS;
 }
 
+void NameResolver::resolve(const std::string& name)
+{
+  status = STATUS_QUERYING;
+  ares_gethostbyname(channel, name.c_str(), AF_INET, callback, this);
+}
+
+std::string NameResolver::getAddrString() const
+{
+  return inet_ntoa(addr);
+}
+
+void NameResolver::setAddr(const std::string& addrString)
+{
+  inet_aton(addrString.c_str(), &addr);
+}
+ 
 #else // ENABLE_ASYNC_DNS
 
 #include "DlAbortEx.h"
 #include "message.h"
 
-void NameResolver::resolve(const string& hostname)
+void NameResolver::resolve(const std::string& hostname)
 {
   memset(&_addr, 0, sizeof(in_addr));
   struct addrinfo ai;
@@ -88,4 +108,16 @@ void NameResolver::resolve(const string& hostname)
   freeaddrinfo(res);
 }
 
+std::string NameResolver::getAddrString() const
+{
+  return inet_ntoa(_addr);
+}
+
+void NameResolver::setAddr(const std::string& addrString)
+{
+  inet_aton(addrString.c_str(), &_addr);
+}
+
 #endif // ENABLE_ASYNC_DNS
+
+} // namespace aria2
diff --git a/src/NameResolver.h b/src/NameResolver.h
index bd55781a..5c4814df 100644
--- a/src/NameResolver.h
+++ b/src/NameResolver.h
@@ -36,7 +36,9 @@
 #define _D_NAME_RESOLVER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "a2netcompat.h"
+#include <string>
 
 #ifdef ENABLE_ASYNC_DNS
 
@@ -48,6 +50,8 @@ extern "C" {
 } /* end of extern "C" */
 #endif
 
+namespace aria2 {
+
 #ifdef HAVE_LIBCARES1_5
 void callback(void* arg, int status, int timeouts, struct hostent* host);
 #else
@@ -72,7 +76,7 @@ private:
   STATUS status;
   ares_channel channel;
   struct in_addr addr;
-  string error;
+  std::string error;
 public:
   NameResolver():
     status(STATUS_READY)
@@ -84,20 +88,15 @@ public:
     ares_destroy(channel);
   }
 
-  void resolve(const string& name) {
-    status = STATUS_QUERYING;
-    ares_gethostbyname(channel, name.c_str(), AF_INET, callback, this);
-  }
+  void resolve(const std::string& name);
 
-  string getAddrString() const {
-    return inet_ntoa(addr);
-  }
+  std::string getAddrString() const;
 
   const struct in_addr& getAddr() const {
     return addr;
   }
 
-  const string& getError() const {
+  const std::string& getError() const {
     return error;
   }
 
@@ -117,10 +116,7 @@ public:
     return this == &resolver;
   }
 
-  void setAddr(const string& addrString)
-  {
-    inet_aton(addrString.c_str(), &addr);
-  }
+  void setAddr(const std::string& addrString);
 };
 
 #else // ENABLE_ASYNC_DNS
@@ -129,20 +125,17 @@ class NameResolver {
 private:
   struct in_addr _addr;
 public:
-  void resolve(const string& hostname);
+  void resolve(const std::string& hostname);
 
-  string getAddrString() const {
-    return inet_ntoa(_addr);
-  }
+  std::string getAddrString() const;
   
-  void setAddr(const string& addrString)
-  {
-    inet_aton(addrString.c_str(), &_addr);
-  }
+  void setAddr(const std::string& addrString);
 };
 
 #endif // ENABLE_ASYNC_DNS
 
 typedef SharedHandle<NameResolver> NameResolverHandle;
 
+} // namespace aria2
+
 #endif // _D_NAME_RESOLVER_H_
diff --git a/src/Netrc.cc b/src/Netrc.cc
index 4538f526..518be851 100644
--- a/src/Netrc.cc
+++ b/src/Netrc.cc
@@ -33,13 +33,15 @@
  */
 /* copyright --> */
 #include "Netrc.h"
-#include "Util.h"
 #include "RecoverableException.h"
 #include <fstream>
+#include <algorithm>
 
-string Netrc::getRequiredNextToken(ifstream& f) const
+namespace aria2 {
+
+std::string Netrc::getRequiredNextToken(std::ifstream& f) const
 {
-  string token;
+  std::string token;
   if(f >> token) {
     return token;
   } else {
@@ -47,9 +49,9 @@ string Netrc::getRequiredNextToken(ifstream& f) const
   }
 }
 
-void Netrc::skipMacdef(ifstream& f) const
+void Netrc::skipMacdef(std::ifstream& f) const
 {
-  string line;
+  std::string line;
   getline(f, line);
   while(getline(f, line)) {
     if(line == "\r" || line == "") {
@@ -58,17 +60,17 @@ void Netrc::skipMacdef(ifstream& f) const
   }
 }
 
-void Netrc::parse(const string& path)
+void Netrc::parse(const std::string& path)
 {
   authenticators.clear();
-  ifstream f(path.c_str());
+  std::ifstream f(path.c_str());
   
   if(!f) {
     throw new RecoverableException("File not found: %s", path.c_str());
   }
 
   AuthenticatorHandle authenticator = 0;
-  string token;
+  std::string token;
   while(f >> token) {
     if(token == "machine") {
       storeAuthenticator(authenticator);
@@ -105,9 +107,9 @@ void Netrc::storeAuthenticator(const AuthenticatorHandle& authenticator)
 
 class AuthHostMatch {
 private:
-  string hostname;
+  std::string hostname;
 public:
-  AuthHostMatch(const string& hostname):hostname(hostname) {}
+  AuthHostMatch(const std::string& hostname):hostname(hostname) {}
 
   bool operator()(const AuthenticatorHandle& authenticator)
   {
@@ -115,14 +117,16 @@ public:
   }
 };
 
-AuthenticatorHandle Netrc::findAuthenticator(const string& hostname) const
+AuthenticatorHandle Netrc::findAuthenticator(const std::string& hostname) const
 {
   Authenticators::const_iterator itr =
-    find_if(authenticators.begin(), authenticators.end(),
-	    AuthHostMatch(hostname));
+    std::find_if(authenticators.begin(), authenticators.end(),
+		 AuthHostMatch(hostname));
   if(itr == authenticators.end()) {
     return 0;
   } else {
     return *itr;
   }
 }
+
+} // namespace aria2
diff --git a/src/Netrc.h b/src/Netrc.h
index fa81c3c5..b18f16aa 100644
--- a/src/Netrc.h
+++ b/src/Netrc.h
@@ -36,29 +36,35 @@
 #define _D_NETRC_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+#include <iosfwd>
+
+namespace aria2 {
 
 class Authenticatable {
 public:
   virtual ~Authenticatable() {}
 
-  virtual bool match(const string& hostname) const = 0;
+  virtual bool match(const std::string& hostname) const = 0;
 };
 
 typedef SharedHandle<Authenticatable> AuthenticatableHandle;
 
 class Authenticator : public Authenticatable {
 private:
-  string machine;
-  string login;
-  string password;
-  string account;
+  std::string machine;
+  std::string login;
+  std::string password;
+  std::string account;
 public:
   Authenticator() {}
 
-  Authenticator(const string& machine,
-		const string& login,
-		const string& password,
-		const string& account)
+  Authenticator(const std::string& machine,
+		const std::string& login,
+		const std::string& password,
+		const std::string& account)
     :machine(machine),
      login(login),
      password(password),
@@ -66,55 +72,55 @@ public:
 
   virtual ~Authenticator() {}
 
-  virtual bool match(const string& hostname) const
+  virtual bool match(const std::string& hostname) const
   {
     return hostname == machine;
   }
 
-  const string& getMachine() const
+  const std::string& getMachine() const
   {
     return machine;
   }
 
-  void setMachine(const string& machine) { this->machine = machine; }
+  void setMachine(const std::string& machine) { this->machine = machine; }
 
-  const string& getLogin() const
+  const std::string& getLogin() const
   {
     return login;
   }
 
-  void setLogin(const string& login) { this->login = login; }
+  void setLogin(const std::string& login) { this->login = login; }
 
-  const string& getPassword() const
+  const std::string& getPassword() const
   {
     return password;
   }
 
-  void setPassword(const string& password) { this->password = password; }
+  void setPassword(const std::string& password) { this->password = password; }
 
-  const string& getAccount() const
+  const std::string& getAccount() const
   {
     return account;
   }
 
-  void setAccount(const string& account) { this->account = account; }
+  void setAccount(const std::string& account) { this->account = account; }
 };
 
 typedef SharedHandle<Authenticator> AuthenticatorHandle;
-typedef deque<AuthenticatorHandle> Authenticators;
+typedef std::deque<AuthenticatorHandle> Authenticators;
 
 class DefaultAuthenticator : public Authenticator {
 public:
   DefaultAuthenticator() {}
 
-  DefaultAuthenticator(const string& login,
-		       const string& password,
-		       const string& account)
+  DefaultAuthenticator(const std::string& login,
+		       const std::string& password,
+		       const std::string& account)
     :Authenticator("", login, password, account) {}
 
   virtual ~DefaultAuthenticator() {}
 
-  virtual bool match(const string& hostname) const
+  virtual bool match(const std::string& hostname) const
   {
     return true;
   }
@@ -128,15 +134,15 @@ private:
 
   void storeAuthenticator(const AuthenticatorHandle& authenticator);
 
-  string getRequiredNextToken(ifstream& f) const;
+  std::string getRequiredNextToken(std::ifstream& f) const;
   
-  void skipMacdef(ifstream& f) const;
+  void skipMacdef(std::ifstream& f) const;
 public:
   Netrc() {}
 
-  void parse(const string& path);
+  void parse(const std::string& path);
 
-  AuthenticatorHandle findAuthenticator(const string& hostname) const;
+  AuthenticatorHandle findAuthenticator(const std::string& hostname) const;
 
   const Authenticators& getAuthenticators() const
   {
@@ -150,6 +156,7 @@ public:
 };
 
 typedef SharedHandle<Netrc> NetrcHandle;
-//typedef SingletonHolder<NetrcHandle> NetrcSingletonHolder;
+
+} // namespace aria2
 
 #endif // _D_NETRC_H_
diff --git a/src/NetrcAuthResolver.cc b/src/NetrcAuthResolver.cc
index c055a88f..d1c1af13 100644
--- a/src/NetrcAuthResolver.cc
+++ b/src/NetrcAuthResolver.cc
@@ -33,8 +33,12 @@
  */
 /* copyright --> */
 #include "NetrcAuthResolver.h"
+#include "AuthConfig.h"
+#include "Netrc.h"
 
-AuthConfigHandle NetrcAuthResolver::resolveAuthConfig(const string& hostname)
+namespace aria2 {
+
+AuthConfigHandle NetrcAuthResolver::resolveAuthConfig(const std::string& hostname)
 {
   if(_userDefinedAuthConfig.isNull()) {
     return findNetrcAuthenticator(hostname);
@@ -43,7 +47,7 @@ AuthConfigHandle NetrcAuthResolver::resolveAuthConfig(const string& hostname)
   }
 }
 
-AuthConfigHandle NetrcAuthResolver::findNetrcAuthenticator(const string& hostname) const
+AuthConfigHandle NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const
 {
   if(_netrc.isNull()) {
     return _defaultAuthConfig;
@@ -56,3 +60,15 @@ AuthConfigHandle NetrcAuthResolver::findNetrcAuthenticator(const string& hostnam
     }
   }
 }
+
+void NetrcAuthResolver::setNetrc(const NetrcHandle& netrc)
+{
+  _netrc = netrc;
+}
+
+NetrcHandle NetrcAuthResolver::getNetrc() const
+{
+  return _netrc;
+}
+
+} // namespace aria2
diff --git a/src/NetrcAuthResolver.h b/src/NetrcAuthResolver.h
index 098b33dc..bf19559f 100644
--- a/src/NetrcAuthResolver.h
+++ b/src/NetrcAuthResolver.h
@@ -36,30 +36,28 @@
 #define _D_NETRC_AUTH_RESOLVER_H_
 
 #include "AbstractAuthResolver.h"
-#include "Netrc.h"
+
+namespace aria2 {
+
+class Netrc;
 
 class NetrcAuthResolver : public AbstractAuthResolver {
 private:
-  NetrcHandle _netrc;
+  SharedHandle<Netrc> _netrc;
 
-  AuthConfigHandle findNetrcAuthenticator(const string& hostname) const;
+  SharedHandle<AuthConfig> findNetrcAuthenticator(const std::string& hostname) const;
 public:
   virtual ~NetrcAuthResolver() {}
 
-  virtual AuthConfigHandle resolveAuthConfig(const string& hostname);
+  virtual SharedHandle<AuthConfig> resolveAuthConfig(const std::string& hostname);
 
-  void setNetrc(const NetrcHandle& netrc)
-  {
-    _netrc = netrc;
-  }
+  void setNetrc(const SharedHandle<Netrc>& netrc);
 
-  NetrcHandle getNetrc() const
-  {
-    return _netrc;
-  }
-      
+  SharedHandle<Netrc> getNetrc() const;
 };
 
 typedef SharedHandle<NetrcAuthResolver> NetrcAuthResolverHandle;
 
+} // namespace aria2
+
 #endif // _D_NETRC_AUTH_RESOLVER_H_
diff --git a/src/NullLogger.h b/src/NullLogger.h
index 94f5f667..b6d3b298 100644
--- a/src/NullLogger.h
+++ b/src/NullLogger.h
@@ -37,8 +37,6 @@
 
 #include "Logger.h"
 
-using namespace std;
-
 class NullLogger : public Logger {
 public:
   NullLogger() {}
diff --git a/src/NullProgressInfoFile.h b/src/NullProgressInfoFile.h
index 7fd8415c..d4f58093 100644
--- a/src/NullProgressInfoFile.h
+++ b/src/NullProgressInfoFile.h
@@ -37,11 +37,13 @@
 
 #include "BtProgressInfoFile.h"
 
+namespace aria2 {
+
 class NullProgressInfoFile:public BtProgressInfoFile {
 public:
   virtual ~NullProgressInfoFile() {}
 
-  virtual string getFilename()
+  virtual std::string getFilename()
   {
     return "";
   }
@@ -57,4 +59,6 @@ public:
 
 typedef SharedHandle<NullProgressInfoFile> NullProgressInfoFileHandle;
 
+} // namespace aria2
+
 #endif // _D_NULL_PROGRESS_INFO_FILE_H_
diff --git a/src/NumberDecorator.h b/src/NumberDecorator.h
index 0f0f2733..4b70851c 100644
--- a/src/NumberDecorator.h
+++ b/src/NumberDecorator.h
@@ -36,14 +36,20 @@
 #define _D_NUMBER_DECORATOR_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
 
 class NumberDecorator {
 public:
   virtual ~NumberDecorator() {}
 
-  virtual string decorate(int32_t number) = 0;
+  virtual std::string decorate(int32_t number) = 0;
 };
 
 typedef SharedHandle<NumberDecorator> NumberDecoratorHandle;
 
+} // namespace aria2;
+
 #endif // _D_NUMBER_DECORATOR_H_
diff --git a/src/OSMetalinkParserState.cc b/src/OSMetalinkParserState.cc
index c2c8e6e4..b509dcf5 100644
--- a/src/OSMetalinkParserState.cc
+++ b/src/OSMetalinkParserState.cc
@@ -35,17 +35,21 @@
 #include "OSMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void OSMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					 const string& name,
-					 const map<string, string>& attrs)
+					 const std::string& name,
+					 const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void OSMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-				       const string& name,
-				       const string& characters)
+				       const std::string& name,
+				       const std::string& characters)
 {
   stm->setOSOfEntry(characters);
   stm->setFileState();
 }
+
+} // namespace aria2
diff --git a/src/OSMetalinkParserState.h b/src/OSMetalinkParserState.h
index 32d0d3e4..cf6fec3a 100644
--- a/src/OSMetalinkParserState.h
+++ b/src/OSMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class OSMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_OS_METALINK_PARSER_STATE_H_
diff --git a/src/Option.cc b/src/Option.cc
index 67ecb047..362d9db1 100644
--- a/src/Option.cc
+++ b/src/Option.cc
@@ -34,21 +34,24 @@
 /* copyright --> */
 #include "Option.h"
 #include "prefs.h"
+#include <cstdlib>
+
+namespace aria2 {
 
 Option::Option() {}
 
 Option::~Option() {}
 
-void Option::put(const string& name, const string& value) {
+void Option::put(const std::string& name, const std::string& value) {
   table[name] = value;
 }
 
-bool Option::defined(const string& name) const {
+bool Option::defined(const std::string& name) const {
   return table.count(name) == 1;
 }
 
-string Option::get(const string& name) const {
-  map<string, string>::const_iterator itr = table.find(name);
+std::string Option::get(const std::string& name) const {
+  std::map<std::string, std::string>::const_iterator itr = table.find(name);
   if(itr == table.end()) {
     return "";
   } else {
@@ -56,8 +59,8 @@ string Option::get(const string& name) const {
   }
 }
 
-int32_t Option::getAsInt(const string& name) const {
-  string value = get(name);
+int32_t Option::getAsInt(const std::string& name) const {
+  std::string value = get(name);
   if(value == "") {
     return 0;
   } else {
@@ -65,8 +68,8 @@ int32_t Option::getAsInt(const string& name) const {
   }
 }
 
-int64_t Option::getAsLLInt(const string& name) const {
-  string value = get(name);
+int64_t Option::getAsLLInt(const std::string& name) const {
+  std::string value = get(name);
   if(value == "") {
     return 0;
   } else {
@@ -74,8 +77,8 @@ int64_t Option::getAsLLInt(const string& name) const {
   }
 }
 
-bool Option::getAsBool(const string& name) const {
-  string value = get(name);
+bool Option::getAsBool(const std::string& name) const {
+  std::string value = get(name);
   if(value == V_TRUE) {
     return true;
   } else {
@@ -83,8 +86,8 @@ bool Option::getAsBool(const string& name) const {
   }
 }
 
-double Option::getAsDouble(const string& name) const {
-  string value = get(name);
+double Option::getAsDouble(const std::string& name) const {
+  std::string value = get(name);
   if(value == "") {
     return 0.0;
   } else {
@@ -96,3 +99,5 @@ void Option::clear()
 {
   table.clear();
 }
+
+} // namespace aria2
diff --git a/src/Option.h b/src/Option.h
index 9552ccad..78cdccbb 100644
--- a/src/Option.h
+++ b/src/Option.h
@@ -39,24 +39,26 @@
 #include <string>
 #include <map>
 
-using namespace std;
+namespace aria2 {
 
 class Option {
 private:
-  map<string, string> table;
+  std::map<std::string, std::string> table;
 public:
   Option();
   ~Option();
 
-  void put(const string& name, const string& value);
-  bool defined(const string& name) const;
-  string get(const string& name) const;
-  int32_t getAsInt(const string& name) const;
-  int64_t getAsLLInt(const string& name) const;
-  bool getAsBool(const string& name) const;
-  double getAsDouble(const string& name) const;
+  void put(const std::string& name, const std::string& value);
+  bool defined(const std::string& name) const;
+  std::string get(const std::string& name) const;
+  int32_t getAsInt(const std::string& name) const;
+  int64_t getAsLLInt(const std::string& name) const;
+  bool getAsBool(const std::string& name) const;
+  double getAsDouble(const std::string& name) const;
   
   void clear();
 };
 
+} // namespace aria2
+
 #endif // _D_OPTION_H_
diff --git a/src/OptionHandler.h b/src/OptionHandler.h
index 3a26d9f2..10587cef 100644
--- a/src/OptionHandler.h
+++ b/src/OptionHandler.h
@@ -36,16 +36,25 @@
 #define _D_OPTION_HANDLER_H_
 
 #include "common.h"
-#include "Option.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
+
+class Option;
 
 class OptionHandler {
 public:
   virtual ~OptionHandler() {}
   
-  virtual bool canHandle(const string& optName) = 0;
-  virtual void parse(Option* option, const string& arg) = 0;
+  virtual bool canHandle(const std::string& optName) = 0;
+  virtual void parse(Option* option, const std::string& arg) = 0;
 };
 
 typedef SharedHandle<OptionHandler> OptionHandlerHandle;
-typedef deque<OptionHandlerHandle> OptionHandlers;
+typedef std::deque<OptionHandlerHandle> OptionHandlers;
+
+} // namespace aria2
+
 #endif // _D_OPTION_HANDLER_H_
diff --git a/src/OptionHandlerFactory.cc b/src/OptionHandlerFactory.cc
index b9c7b6ba..ffd74f1b 100644
--- a/src/OptionHandlerFactory.cc
+++ b/src/OptionHandlerFactory.cc
@@ -35,7 +35,9 @@
 #include "OptionHandlerFactory.h"
 #include "prefs.h"
 #include "OptionHandlerImpl.h"
-#include "a2functional.h"
+#include "array_fun.h"
+
+namespace aria2 {
 
 OptionHandlers OptionHandlerFactory::createOptionHandlers()
 {
@@ -108,7 +110,7 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
   {
     const char* params[] = { V_HTTP, V_HTTPS, V_FTP, V_NONE };
     handlers.push_back(new ParameterOptionHandler(PREF_METALINK_PREFERRED_PROTOCOL,
-						  Strings(&params[0], &params[arrayLength(params)])));
+						  std::deque<std::string>(&params[0], &params[arrayLength(params)])));
   }
   handlers.push_back(new BooleanOptionHandler(PREF_ENABLE_PEER_EXCHANGE));
   handlers.push_back(new BooleanOptionHandler(PREF_ENABLE_DHT));
@@ -119,3 +121,5 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers()
 
   return handlers;
 }
+
+} // namespace aria2
diff --git a/src/OptionHandlerFactory.h b/src/OptionHandlerFactory.h
index 085bf51b..738c5751 100644
--- a/src/OptionHandlerFactory.h
+++ b/src/OptionHandlerFactory.h
@@ -36,11 +36,18 @@
 #define _D_OPTION_HANDLER_FACTORY_H_
 
 #include "common.h"
-#include "OptionHandler.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class OptionHandler;
 
 class OptionHandlerFactory {
 public:
-  static OptionHandlers createOptionHandlers();
+  static std::deque<SharedHandle<OptionHandler> > createOptionHandlers();
 };
 
+} // namespace aria2
+
 #endif // _D_OPTION_HANDLER_FACTORY_H_
diff --git a/src/OptionHandlerImpl.h b/src/OptionHandlerImpl.h
index 194f3f73..683875e0 100644
--- a/src/OptionHandlerImpl.h
+++ b/src/OptionHandlerImpl.h
@@ -38,32 +38,36 @@
 #include "OptionHandler.h"
 #include "NameMatchOptionHandler.h"
 #include "Util.h"
-#include "DlAbortEx.h"
 #include "FatalException.h"
 #include "prefs.h"
+#include "Option.h"
+#include <utility>
+#include <algorithm>
+
+namespace aria2 {
 
 class NullOptionHandler : public OptionHandler {
 public:
   virtual ~NullOptionHandler() {}
 
-  virtual bool canHandle(const string& optName) { return true; }
+  virtual bool canHandle(const std::string& optName) { return true; }
 
-  virtual void parse(Option* option, const string& arg) {}
+  virtual void parse(Option* option, const std::string& arg) {}
 };
 
 class BooleanOptionHandler : public NameMatchOptionHandler {
 public:
-  BooleanOptionHandler(const string& optName):NameMatchOptionHandler(optName) {}
+  BooleanOptionHandler(const std::string& optName):NameMatchOptionHandler(optName) {}
   virtual ~BooleanOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     if(optarg == "true") {
       option->put(_optName, V_TRUE);
     } else if(optarg == "false") {
       option->put(_optName, V_FALSE);
     } else {
-      string msg = _optName+" "+_("must be either 'true' or 'false'.");
+      std::string msg = _optName+" "+_("must be either 'true' or 'false'.");
       throw new FatalException(msg.c_str());
     }
   }
@@ -74,18 +78,18 @@ private:
   int32_t _min;
   int32_t _max;
 public:
-  IntegerRangeOptionHandler(const string& optName, int32_t min, int32_t max):NameMatchOptionHandler(optName), _min(min), _max(max) {}
+  IntegerRangeOptionHandler(const std::string& optName, int32_t min, int32_t max):NameMatchOptionHandler(optName), _min(min), _max(max) {}
 
   virtual ~IntegerRangeOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     IntSequence seq = Util::parseIntRange(optarg);
     while(seq.hasNext()) {
       int32_t v = seq.next();
       if(v < _min || _max < v) {
-	string msg = _optName+" "+_("must be between %s and %s.");
-	throw new DlAbortEx(msg.c_str(), Util::llitos(_min).c_str(), Util::llitos(_max).c_str());
+	std::string msg = _optName+" "+_("must be between %s and %s.");
+	throw new FatalException(msg.c_str(), Util::llitos(_min).c_str(), Util::llitos(_max).c_str());
       }
       option->put(_optName, optarg);
     }
@@ -97,11 +101,11 @@ private:
   int64_t _min;
   int64_t _max;
 public:
-  NumberOptionHandler(const string& optName, int64_t min = -1, int64_t max = -1):NameMatchOptionHandler(optName), _min(min), _max(max) {}
+  NumberOptionHandler(const std::string& optName, int64_t min = -1, int64_t max = -1):NameMatchOptionHandler(optName), _min(min), _max(max) {}
 
   virtual ~NumberOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     int64_t num = Util::parseLLInt(optarg);
     parseArg(option, num);
@@ -112,7 +116,7 @@ public:
     if((_min == -1 || _min <= number) && (_max ==  -1 || number <= _max)) {
       option->put(_optName, Util::llitos(number));
     } else {
-      string msg = _optName+" ";
+      std::string msg = _optName+" ";
       if(_min == -1 && _max != -1) {
 	msg += _("must be smaller than or equal to %s.");
 	throw new FatalException(msg.c_str(), Util::llitos(_max).c_str());
@@ -132,11 +136,11 @@ public:
 
 class UnitNumberOptionHandler : public NumberOptionHandler {
 public:
-  UnitNumberOptionHandler(const string& optName, int64_t min = -1, int64_t max = -1):NumberOptionHandler(optName, min, max) {}
+  UnitNumberOptionHandler(const std::string& optName, int64_t min = -1, int64_t max = -1):NumberOptionHandler(optName, min, max) {}
 
   virtual ~UnitNumberOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     int64_t num = Util::getRealSize(optarg);
     NumberOptionHandler::parseArg(option, num);
@@ -148,17 +152,17 @@ private:
   double _min;
   double _max;
 public:
-  FloatNumberOptionHandler(const string& optName, double min = -1, double max = -1):NameMatchOptionHandler(optName), _min(min), _max(max) {}
+  FloatNumberOptionHandler(const std::string& optName, double min = -1, double max = -1):NameMatchOptionHandler(optName), _min(min), _max(max) {}
 
   virtual ~FloatNumberOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     double number = strtod(optarg.c_str(), 0);
     if((_min < 0 || _min <= number) && (_max < 0 || number <= _max)) {
       option->put(_optName, optarg);
     } else {
-      string msg = _optName+" ";
+      std::string msg = _optName+" ";
       if(_min < 0 && _max >= 0) {
 	msg += _("must be smaller than or equal to %.1f.");
 	throw new FatalException(msg.c_str(), _max);
@@ -178,11 +182,11 @@ public:
 
 class DefaultOptionHandler : public NameMatchOptionHandler {
 public:
-  DefaultOptionHandler(const string& optName):NameMatchOptionHandler(optName) {}
+  DefaultOptionHandler(const std::string& optName):NameMatchOptionHandler(optName) {}
 
   virtual ~DefaultOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     option->put(_optName, optarg);
   }
@@ -190,30 +194,30 @@ public:
 
 class ParameterOptionHandler : public NameMatchOptionHandler {
 private:
-  Strings _validParamValues;
+  std::deque<std::string> _validParamValues;
 public:
-  ParameterOptionHandler(const string& optName, const Strings& validParamValues):
+  ParameterOptionHandler(const std::string& optName, const std::deque<std::string>& validParamValues):
     NameMatchOptionHandler(optName), _validParamValues(validParamValues) {}
 
-  ParameterOptionHandler(const string& optName, const string& validParamValue):
+  ParameterOptionHandler(const std::string& optName, const std::string& validParamValue):
     NameMatchOptionHandler(optName)
   {
     _validParamValues.push_back(validParamValue);
   }
 
-  ParameterOptionHandler(const string& optName,
-			 const string& validParamValue1,
-			 const string& validParamValue2):
+  ParameterOptionHandler(const std::string& optName,
+			 const std::string& validParamValue1,
+			 const std::string& validParamValue2):
     NameMatchOptionHandler(optName)
   {
     _validParamValues.push_back(validParamValue1);
     _validParamValues.push_back(validParamValue2);
   }
 
-  ParameterOptionHandler(const string& optName,
-			 const string& validParamValue1,
-			 const string& validParamValue2,
-			 const string& validParamValue3):
+  ParameterOptionHandler(const std::string& optName,
+			 const std::string& validParamValue1,
+			 const std::string& validParamValue2,
+			 const std::string& validParamValue3):
     NameMatchOptionHandler(optName)
   {
     _validParamValues.push_back(validParamValue1);
@@ -223,15 +227,16 @@ public:
    
   virtual ~ParameterOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
-    Strings::const_iterator itr = find(_validParamValues.begin(), _validParamValues.end(), optarg);
+    std::deque<std::string>::const_iterator itr =
+      std::find(_validParamValues.begin(), _validParamValues.end(), optarg);
     if(itr == _validParamValues.end()) {
-      string msg = _optName+" "+_("must be one of the following:");
+      std::string msg = _optName+" "+_("must be one of the following:");
       if(_validParamValues.size() == 0) {
 	msg += "''";
       } else {
-	for(Strings::const_iterator itr = _validParamValues.begin();
+	for(std::deque<std::string>::const_iterator itr = _validParamValues.begin();
 	    itr != _validParamValues.end(); ++itr) {
 	  msg += "'"+*itr+"' ";
 	}
@@ -245,22 +250,22 @@ public:
 
 class HostPortOptionHandler : public NameMatchOptionHandler {
 private:
-  string _hostOptionName;
+  std::string _hostOptionName;
   
-  string _portOptionName;
+  std::string _portOptionName;
 public:
-  HostPortOptionHandler(const string& optName,
-			const string& hostOptionName,
-			const string& portOptionName):
+  HostPortOptionHandler(const std::string& optName,
+			const std::string& hostOptionName,
+			const std::string& portOptionName):
     NameMatchOptionHandler(optName),
     _hostOptionName(hostOptionName),
     _portOptionName(portOptionName) {}
 
   virtual ~HostPortOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
-    pair<string, string> proxy = Util::split(optarg, ":");
+    std::pair<std::string, std::string> proxy = Util::split(optarg, ":");
     int32_t port = Util::parseInt(proxy.second);
     if(proxy.first.empty() || proxy.second.empty() ||
        port <= 0 || 65535 < port) {
@@ -270,7 +275,7 @@ public:
     setHostAndPort(option, proxy.first, port);
   }
 
-  void setHostAndPort(Option* option, const string& hostname, uint16_t port)
+  void setHostAndPort(Option* option, const std::string& hostname, uint16_t port)
   {
     option->put(_hostOptionName, hostname);
     option->put(_portOptionName, Util::uitos(port));
@@ -279,14 +284,14 @@ public:
 
 class HttpProxyOptionHandler : public HostPortOptionHandler {
 public:
-  HttpProxyOptionHandler(const string& optName,
-			 const string& hostOptionName,
-			 const string& portOptionName):
+  HttpProxyOptionHandler(const std::string& optName,
+			 const std::string& hostOptionName,
+			 const std::string& portOptionName):
     HostPortOptionHandler(optName, hostOptionName, portOptionName) {}
 
   virtual ~HttpProxyOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     HostPortOptionHandler::parseArg(option, optarg);
     option->put(PREF_HTTP_PROXY_ENABLED, V_TRUE);
@@ -295,11 +300,11 @@ public:
 
 class LogOptionHandler : public NameMatchOptionHandler {
 public:
-  LogOptionHandler(const string& optName):NameMatchOptionHandler(optName) {}
+  LogOptionHandler(const std::string& optName):NameMatchOptionHandler(optName) {}
 
   virtual ~LogOptionHandler() {}
 
-  virtual void parseArg(Option* option, const string& optarg)
+  virtual void parseArg(Option* option, const std::string& optarg)
   {
     if("-" == optarg) {
       option->put(PREF_STDOUT_LOG, V_TRUE);
@@ -309,4 +314,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_OPTION_HANDLER_IMPL_H_
diff --git a/src/OptionParser.cc b/src/OptionParser.cc
index 95629c44..8267e1dc 100644
--- a/src/OptionParser.cc
+++ b/src/OptionParser.cc
@@ -35,23 +35,28 @@
 #include "OptionParser.h"
 #include "Util.h"
 #include "OptionHandlerImpl.h"
+#include "Option.h"
+#include <istream>
+#include <utility>
 
-void OptionParser::parse(Option* option, istream& is)
+namespace aria2 {
+
+void OptionParser::parse(Option* option, std::istream& is)
 {
-  string line;
+  std::string line;
   int32_t linenum = 0;
   while(getline(is, line)) {
     ++linenum;
     if(Util::startsWith(line, "#")) {
       continue;
     }
-    pair<string, string> nv = Util::split(line, "=");
+    std::pair<std::string, std::string> nv = Util::split(line, "=");
     OptionHandlerHandle handler = getOptionHandlerByName(nv.first);
     handler->parse(option, nv.second);
   }
 }
 
-OptionHandlerHandle OptionParser::getOptionHandlerByName(const string& optName)
+OptionHandlerHandle OptionParser::getOptionHandlerByName(const std::string& optName)
 {
   for(OptionHandlers::iterator itr = _optionHandlers.begin();
       itr != _optionHandlers.end(); ++itr) {
@@ -61,3 +66,10 @@ OptionHandlerHandle OptionParser::getOptionHandlerByName(const string& optName)
   }
   return new NullOptionHandler();
 }
+
+void OptionParser::setOptionHandlers(const std::deque<SharedHandle<OptionHandler> >& optionHandlers)
+{
+  _optionHandlers = optionHandlers;
+}
+
+} // namespace aria2
diff --git a/src/OptionParser.h b/src/OptionParser.h
index 629763c1..764f7f8a 100644
--- a/src/OptionParser.h
+++ b/src/OptionParser.h
@@ -36,26 +36,31 @@
 #define _D_OPTION_PARSER_H_
 
 #include "common.h"
-#include "Option.h"
-#include "OptionHandler.h"
-#include <istream>
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
+#include <iosfwd>
+
+namespace aria2 {
+
+class Option;
+class OptionHandler;
 
 class OptionParser {
 private:
-  OptionHandlers _optionHandlers;
+  std::deque<SharedHandle<OptionHandler> > _optionHandlers;
 public:
   ~OptionParser() {}
 
-  OptionHandlerHandle getOptionHandlerByName(const string& optName);
+  SharedHandle<OptionHandler> getOptionHandlerByName(const std::string& optName);
 
-  void parse(Option* option, istream& ios);
+  void parse(Option* option, std::istream& ios);
 
-  void setOptionHandlers(const OptionHandlers& optionHandlers)
-  {
-    _optionHandlers = optionHandlers;
-  }
+  void setOptionHandlers(const std::deque<SharedHandle<OptionHandler> >& optionHandlers);
 };
 
 typedef SharedHandle<OptionParser> OptionParserHandle;
 
+} // namespace aria2
+
 #endif // _D_OPTION_PARSER_H_
diff --git a/src/PStringBuildVisitor.cc b/src/PStringBuildVisitor.cc
index 7487b45b..585f77d6 100644
--- a/src/PStringBuildVisitor.cc
+++ b/src/PStringBuildVisitor.cc
@@ -34,9 +34,11 @@
 /* copyright --> */
 #include "PStringBuildVisitor.h"
 
+namespace aria2 {
+
 void PStringBuildVisitor::hello(PStringSegment* segment)
 {
-  string uri;
+  std::string uri;
   if(_buildQueue.empty()) {
     uri += segment->getValue();
   } else {
@@ -52,3 +54,5 @@ void PStringBuildVisitor::goodbye(PStringSegment* segment)
 {
   _buildQueue.pop_front();
 }
+
+} // namespace aria2
diff --git a/src/PStringBuildVisitor.h b/src/PStringBuildVisitor.h
index 4bb01d07..2e8d484f 100644
--- a/src/PStringBuildVisitor.h
+++ b/src/PStringBuildVisitor.h
@@ -35,15 +35,18 @@
 #ifndef _D_P_STRING_BUILD_VISITOR_H_
 #define _D_P_STRING_BUILD_VISITOR_H_
 
+#include "PStringVisitor.h"
 #include "PStringSegment.h"
 
+namespace aria2 {
+
 class PStringBuildVisitor : public PStringVisitor, public PStringSegmentVisitor
 {
 private:
 
-  Strings _buildQueue;
+  std::deque<std::string> _buildQueue;
 
-  Strings _uris;
+  std::deque<std::string> _uris;
 
 public:
   
@@ -51,7 +54,7 @@ public:
 
   virtual void goodbye(PStringSegment* segment);
 
-  const Strings& getURIs() const
+  const std::deque<std::string>& getURIs() const
   {
     return _uris;
   }
@@ -65,4 +68,6 @@ public:
 
 typedef SharedHandle<PStringBuildVisitor> PStringBuildVisitorHandle;
 
+} // namespace aria2
+
 #endif // _D_P_STRING_BUILD_VISITOR_H_
diff --git a/src/PStringDatum.h b/src/PStringDatum.h
index 7a000ce2..6050ba36 100644
--- a/src/PStringDatum.h
+++ b/src/PStringDatum.h
@@ -36,16 +36,23 @@
 #define _D_P_STRING_DATUM_H_
 
 #include "common.h"
-#include "PStringVisitor.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class PStringVisitor;
 
 class PStringDatum {
 public:
   virtual ~PStringDatum() {}
 
-  virtual void accept(const PStringVisitorHandle& visitor) = 0;
+  virtual void accept(PStringVisitor* visitor) = 0;
 };
 
 typedef SharedHandle<PStringDatum> PStringDatumHandle;
-typedef deque<PStringDatumHandle> PStringData;
+typedef std::deque<PStringDatumHandle> PStringData;
+
+} // namespace aria2
 
 #endif // _D_P_STRING_DATUM_H_
diff --git a/src/PStringNumLoop.h b/src/PStringNumLoop.h
index 1717d236..b8c0d0cb 100644
--- a/src/PStringNumLoop.h
+++ b/src/PStringNumLoop.h
@@ -36,10 +36,11 @@
 #define _D_P_STRING_NUM_LOOP_H_
 
 #include "PStringDatum.h"
-#include "Util.h"
 #include "PStringSegment.h"
 #include "NumberDecorator.h"
 
+namespace aria2 {
+
 class PStringNumLoop : public PStringDatum
 {
 private:
@@ -66,7 +67,7 @@ public:
 
   virtual ~PStringNumLoop() {}
 
-  virtual void accept(const PStringVisitorHandle& visitor)
+  virtual void accept(PStringVisitor* visitor)
   {
     for(int32_t i = _startValue; i <= _endValue; i += _step) {
       PStringSegment(_numberDecorator->decorate(i), _next).accept(visitor);
@@ -97,4 +98,6 @@ public:
 
 typedef SharedHandle<PStringNumLoop> PStringNumLoopHandle;
 
+} // namespace aria2
+
 #endif // _D_P_STRING_NUM_LOOP_H_
diff --git a/src/PStringSegment.cc b/src/PStringSegment.cc
index 28d9796b..13653fec 100644
--- a/src/PStringSegment.cc
+++ b/src/PStringSegment.cc
@@ -34,11 +34,20 @@
 /* copyright --> */
 #include "PStringSegment.h"
 #include "FatalException.h"
+#include "PStringVisitor.h"
 
-void PStringSegment::accept(const PStringVisitorHandle& visitor)
+namespace aria2 {
+
+PStringSegment::PStringSegment(const std::string& value,
+			       const SharedHandle<PStringDatum>& next):
+  _value(value), _next(next) {}
+
+PStringSegment::~PStringSegment() {}
+
+void PStringSegment::accept(PStringVisitor* visitor)
 {
-  PStringSegmentVisitorHandle v = visitor;
-  if(v.isNull()) {
+  PStringSegmentVisitor* v = dynamic_cast<PStringSegmentVisitor*>(visitor);
+  if(!v) {
     throw new FatalException("Class cast exception");
   }
   v->hello(this);
@@ -47,3 +56,20 @@ void PStringSegment::accept(const PStringVisitorHandle& visitor)
   }
   v->goodbye(this);
 }
+
+const std::string& PStringSegment::getValue() const
+{
+  return _value;
+}
+
+bool PStringSegment::hasNext() const
+{
+  return !_next.isNull();
+}
+
+SharedHandle<PStringDatum> PStringSegment::getNext() const
+{
+  return _next;
+}
+
+} // namespace aria2
diff --git a/src/PStringSegment.h b/src/PStringSegment.h
index ac35bb81..1942352a 100644
--- a/src/PStringSegment.h
+++ b/src/PStringSegment.h
@@ -36,41 +36,33 @@
 #define _D_P_STRING_SEGMENT_H_
 
 #include "PStringDatum.h"
+#include <string>
+
+namespace aria2 {
 
 class PStringSegmentVisitor;
 
-typedef SharedHandle<PStringSegmentVisitor> PStringSegmentVisitorHandle;
-
 class PStringSegment : public PStringDatum
 {
 private:
 
-  string _value;
+  std::string _value;
 
-  PStringDatumHandle _next;
+  SharedHandle<PStringDatum> _next;
 
 public:
-  PStringSegment(const string& value, const PStringDatumHandle& next = 0):
-    _value(value), _next(next) {}
+  PStringSegment(const std::string& value,
+		 const SharedHandle<PStringDatum>& next = 0);
 
-  virtual ~PStringSegment() {}
+  virtual ~PStringSegment();
 
-  virtual void accept(const PStringVisitorHandle& visitor);
+  virtual void accept(PStringVisitor* visitor);
 
-  const string& getValue() const
-  {
-    return _value;
-  }
+  const std::string& getValue() const;
 
-  bool hasNext() const
-  {
-    return !_next.isNull();
-  }
+  bool hasNext() const;
 
-  PStringDatumHandle getNext() const
-  {
-    return _next;
-  }
+  SharedHandle<PStringDatum> getNext() const;
 };
 
 typedef SharedHandle<PStringSegment> PStringSegmentHandle;
@@ -86,4 +78,6 @@ public:
 
 typedef SharedHandle<PStringSegmentVisitor> PStringSegmentVisitorHandle;
 
+} // namespace aria2
+
 #endif // _D_P_STRING_SEGMENT_H_
diff --git a/src/PStringSelect.h b/src/PStringSelect.h
index 305ef9d9..4a1364cd 100644
--- a/src/PStringSelect.h
+++ b/src/PStringSelect.h
@@ -38,29 +38,33 @@
 #include "PStringDatum.h"
 #include "PStringSegment.h"
 
+namespace aria2 {
+
+class PStringVisitor;
+
 class PStringSelect : public PStringDatum
 {
 private:
   
-  Strings _values;
+  std::deque<std::string> _values;
 
   PStringDatumHandle _next;
 
 public:
-  PStringSelect(const Strings& values, const PStringDatumHandle& next = 0):
+  PStringSelect(const std::deque<std::string>& values, const PStringDatumHandle& next = 0):
     _values(values),
     _next(next) {}
 
   virtual ~PStringSelect() {}
 
-  virtual void accept(const PStringVisitorHandle& visitor)
+  virtual void accept(PStringVisitor* visitor)
   {
-    for(Strings::iterator itr = _values.begin(); itr != _values.end(); ++itr) {
+    for(std::deque<std::string>::iterator itr = _values.begin(); itr != _values.end(); ++itr) {
       PStringSegment(*itr, _next).accept(visitor);
     }
   }
 
-  const Strings& getValues() const
+  const std::deque<std::string>& getValues() const
   {
     return _values;
   }
@@ -73,4 +77,6 @@ public:
 
 typedef SharedHandle<PStringSelect> PStringSelectHandle;
 
+} // namespace aria2
+
 #endif // _D_P_STRING_SELECT_H_
diff --git a/src/PStringVisitor.h b/src/PStringVisitor.h
index 8c8c9807..56dc6c48 100644
--- a/src/PStringVisitor.h
+++ b/src/PStringVisitor.h
@@ -36,6 +36,9 @@
 #define _D_P_STRING_VISITOR_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class PStringVisitor {
 public:
@@ -44,4 +47,6 @@ public:
 
 typedef SharedHandle<PStringVisitor> PStringVisitorHandle;
 
+} // namespace aria2
+
 #endif // _D_P_STRING_VISITOR_H_
diff --git a/src/ParameterizedStringParser.cc b/src/ParameterizedStringParser.cc
index 409f5847..d04eecbc 100644
--- a/src/ParameterizedStringParser.cc
+++ b/src/ParameterizedStringParser.cc
@@ -41,14 +41,17 @@
 #include "NumberDecorator.h"
 #include "FixedWidthNumberDecorator.h"
 #include "AlphaNumberDecorator.h"
+#include <utility>
 
-PStringDatumHandle ParameterizedStringParser::parse(const string& src)
+namespace aria2 {
+
+PStringDatumHandle ParameterizedStringParser::parse(const std::string& src)
 {
   int32_t offset = 0;
   return diggPString(src, offset);
 }
 
-PStringDatumHandle ParameterizedStringParser::diggPString(const string& src,
+PStringDatumHandle ParameterizedStringParser::diggPString(const std::string& src,
 							  int32_t& offset)
 {
   if(src.size() == (size_t)offset) {
@@ -64,28 +67,28 @@ PStringDatumHandle ParameterizedStringParser::diggPString(const string& src,
   } 
 }
 
-PStringDatumHandle ParameterizedStringParser::createSegment(const string& src,
+PStringDatumHandle ParameterizedStringParser::createSegment(const std::string& src,
 							    int32_t& offset)
 {
-  string::size_type nextDelimiterIndex = src.find_first_of("[{", offset);
-  if(nextDelimiterIndex == string::npos) {
+  std::string::size_type nextDelimiterIndex = src.find_first_of("[{", offset);
+  if(nextDelimiterIndex == std::string::npos) {
     nextDelimiterIndex = src.size();
   }
-  string value = src.substr(offset, nextDelimiterIndex-offset);
+  std::string value = src.substr(offset, nextDelimiterIndex-offset);
   offset = nextDelimiterIndex;
   PStringDatumHandle next = diggPString(src, offset);
   return new PStringSegment(value, next);
 }
 
-PStringDatumHandle ParameterizedStringParser::createSelect(const string& src,
+PStringDatumHandle ParameterizedStringParser::createSelect(const std::string& src,
 							   int32_t& offset)
 {
   ++offset;
-  string::size_type rightParenIndex = src.find("}", offset);
-  if(rightParenIndex == string::npos) {
+  std::string::size_type rightParenIndex = src.find("}", offset);
+  if(rightParenIndex == std::string::npos) {
     throw new FatalException("Missing '}' in the parameterized string.");
   }
-  Strings values;
+  std::deque<std::string> values;
   Util::slice(values, src.substr(offset, rightParenIndex-offset), ',', true);
   if(values.empty()) {
     throw new FatalException("Empty {} is not allowed.");
@@ -95,21 +98,21 @@ PStringDatumHandle ParameterizedStringParser::createSelect(const string& src,
   return new PStringSelect(values, next);
 }
 
-PStringDatumHandle ParameterizedStringParser::createLoop(const string& src,
+PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
 							 int32_t& offset)
 {
   ++offset;
-  string::size_type rightParenIndex = src.find("]", offset);
-  if(rightParenIndex == string::npos) {
+  std::string::size_type rightParenIndex = src.find("]", offset);
+  if(rightParenIndex == std::string::npos) {
     throw new FatalException("Missing ']' in the parameterized string.");
   }
-  string loopStr = src.substr(offset, rightParenIndex-offset);
+  std::string loopStr = src.substr(offset, rightParenIndex-offset);
   offset = rightParenIndex+1;
 
   int32_t step = 1;
-  string::size_type colonIndex = loopStr.find(":");
-  if(colonIndex != string::npos) {
-    string stepStr = loopStr.substr(colonIndex+1);
+  std::string::size_type colonIndex = loopStr.find(":");
+  if(colonIndex != std::string::npos) {
+    std::string stepStr = loopStr.substr(colonIndex+1);
     if(Util::isNumber(stepStr)) {
       step = Util::parseInt(stepStr);
     } else {
@@ -117,7 +120,7 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const string& src,
     }
     loopStr.erase(colonIndex);
   }
-  pair<string, string> range = Util::split(loopStr, "-");
+  std::pair<std::string, std::string> range = Util::split(loopStr, "-");
   if(range.first == "" || range.second == "") {
     throw new FatalException("Loop range missing.");
   }
@@ -143,3 +146,5 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const string& src,
   PStringDatumHandle next = diggPString(src, offset);
   return new PStringNumLoop(start, end, step, nd, next);
 }
+
+} // namespace aria2
diff --git a/src/ParameterizedStringParser.h b/src/ParameterizedStringParser.h
index 10077a7a..07aa98d5 100644
--- a/src/ParameterizedStringParser.h
+++ b/src/ParameterizedStringParser.h
@@ -38,19 +38,23 @@
 #include "common.h"
 #include "PStringDatum.h"
 
+namespace aria2 {
+
 class ParameterizedStringParser {
 private:
-  PStringDatumHandle diggPString(const string& src, int32_t& offset);
+  SharedHandle<PStringDatum> diggPString(const std::string& src, int32_t& offset);
 
-  PStringDatumHandle createSegment(const string& src, int32_t& offset);
+  SharedHandle<PStringDatum> createSegment(const std::string& src, int32_t& offset);
 
-  PStringDatumHandle createLoop(const string& src, int32_t& offset);
+  SharedHandle<PStringDatum> createLoop(const std::string& src, int32_t& offset);
 
-  PStringDatumHandle createSelect(const string& src, int32_t& offset);
+  SharedHandle<PStringDatum> createSelect(const std::string& src, int32_t& offset);
 
 
 public:
-  PStringDatumHandle parse(const string& parameterizedUri);
+  SharedHandle<PStringDatum> parse(const std::string& parameterizedUri);
 };
 
+} // namespace aria2
+
 #endif // _D_PARAMETERIZED_STRING_PARSER_H_
diff --git a/src/Peer.cc b/src/Peer.cc
index 995fbc7d..521812eb 100644
--- a/src/Peer.cc
+++ b/src/Peer.cc
@@ -34,14 +34,20 @@
 /* copyright --> */
 #include "Peer.h"
 #include "BitfieldManFactory.h"
+#include "BitfieldMan.h"
 #include "Util.h"
 #ifdef ENABLE_MESSAGE_DIGEST
 # include "MessageDigestHelper.h"
 #endif // ENABLE_MESSAGE_DIGEST
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+
+namespace aria2 {
 
 #define BAD_CONDITION_INTERVAL 10
 
-Peer::Peer(string ipaddr, uint16_t port):
+Peer::Peer(std::string ipaddr, uint16_t port):
   ipaddr(ipaddr),
   port(port),
   _bitfield(0),
@@ -52,7 +58,7 @@ Peer::Peer(string ipaddr, uint16_t port):
   _seeder(false)
 {
   resetStatus();
-  string idSeed = ipaddr+":"+Util::itos(port);
+  std::string idSeed = ipaddr+":"+Util::itos(port);
 #ifdef ENABLE_MESSAGE_DIGEST
   id = MessageDigestHelper::digestString("sha1", idSeed);
 #else
@@ -60,6 +66,21 @@ Peer::Peer(string ipaddr, uint16_t port):
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
+Peer::~Peer()
+{
+  delete _bitfield;
+}
+
+bool Peer::operator==(const Peer& p)
+{
+  return id == p.id;
+}
+  
+bool Peer::operator!=(const Peer& p)
+{
+  return !(*this == p);
+}
+
 void Peer::allocateBitfield(int32_t pieceLength, int64_t totalLength)
 {
   delete _bitfield;
@@ -72,6 +93,18 @@ void Peer::deallocateBitfield()
   _bitfield = 0;
 }
 
+void Peer::updateUploadLength(int32_t bytes)
+{
+  peerStat.updateUploadLength(bytes);
+  sessionUploadLength += bytes;
+}
+
+void Peer::updateDownloadLength(int32_t bytes)
+{
+  peerStat.updateDownloadLength(bytes);
+  sessionDownloadLength += bytes;
+}
+
 void Peer::updateSeeder()
 {
   assert(_bitfield);
@@ -90,6 +123,82 @@ void Peer::updateBitfield(int32_t index, int32_t operation) {
   updateSeeder();
 }
 
+int32_t Peer::calculateUploadSpeed()
+{
+  return peerStat.calculateUploadSpeed();
+}
+
+int32_t Peer::calculateUploadSpeed(const struct timeval& now)
+{
+  return peerStat.calculateUploadSpeed(now);
+}
+
+int32_t Peer::calculateDownloadSpeed()
+{
+  return peerStat.calculateDownloadSpeed();
+}
+
+int32_t Peer::calculateDownloadSpeed(const struct timeval& now)
+{
+  return peerStat.calculateDownloadSpeed(now);
+}
+
+int64_t Peer::getSessionUploadLength() const
+{
+  return sessionUploadLength;
+}
+
+int64_t Peer::getSessionDownloadLength() const
+{
+  return sessionDownloadLength;
+}
+
+void Peer::activate()
+{
+  peerStat.downloadStart();
+  active = true;
+}
+
+void Peer::deactivate()
+{
+  peerStat.downloadStop();
+  active = false;
+}
+
+bool Peer::isActive() const
+{
+  return active;
+}
+
+void Peer::setPeerId(const unsigned char* peerId)
+{
+  memcpy(this->peerId, peerId, PEER_ID_LENGTH);
+}
+
+const unsigned char* Peer::getPeerId() const
+{
+  return this->peerId;
+}
+  
+void Peer::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength)
+{
+  assert(_bitfield);
+  _bitfield->setBitfield(bitfield, bitfieldLength);
+  updateSeeder();
+}
+
+const unsigned char* Peer::getBitfield() const
+{
+  assert(_bitfield);
+  return _bitfield->getBitfield();
+}
+
+int32_t Peer::getBitfieldLength() const
+{
+  assert(_bitfield);
+  return _bitfield->getBitfieldLength();
+}
+
 #define THRESHOLD 1024*1024*2
 
 bool Peer::shouldBeChoking() const {
@@ -124,9 +233,29 @@ void Peer::resetStatus() {
   peerStat.reset();
 }
 
+void Peer::setFastExtensionEnabled(bool enabled)
+{
+  fastExtensionEnabled = enabled;
+}
+
+bool Peer::isFastExtensionEnabled() const
+{
+  return fastExtensionEnabled;
+}
+
+int32_t Peer::countPeerAllowedIndexSet() const
+{
+  return peerAllowedIndexSet.size();
+}
+
+const std::deque<int32_t>& Peer::getPeerAllowedIndexSet() const
+{
+  return peerAllowedIndexSet;
+}
+
 bool Peer::isInPeerAllowedIndexSet(int32_t index) const {
-  return find(peerAllowedIndexSet.begin(), peerAllowedIndexSet.end(),
-	      index) != peerAllowedIndexSet.end();
+  return std::find(peerAllowedIndexSet.begin(), peerAllowedIndexSet.end(),
+		   index) != peerAllowedIndexSet.end();
 }
 
 void Peer::addPeerAllowedIndex(int32_t index) {
@@ -136,8 +265,8 @@ void Peer::addPeerAllowedIndex(int32_t index) {
 }
 
 bool Peer::isInAmAllowedIndexSet(int32_t index) const {
-  return find(amAllowedIndexSet.begin(), amAllowedIndexSet.end(),
-	      index) != amAllowedIndexSet.end();
+  return std::find(amAllowedIndexSet.begin(), amAllowedIndexSet.end(),
+		   index) != amAllowedIndexSet.end();
 }
 
 void Peer::addAmAllowedIndex(int32_t index) {
@@ -166,7 +295,7 @@ bool Peer::isGood() const
   return _badConditionStartTime.elapsed(BAD_CONDITION_INTERVAL);
 }
 
-uint8_t Peer::getExtensionMessageID(const string& name)
+uint8_t Peer::getExtensionMessageID(const std::string& name)
 {
   Extensions::const_iterator itr = _extensions.find(name);
   if(itr == _extensions.end()) {
@@ -176,7 +305,7 @@ uint8_t Peer::getExtensionMessageID(const string& name)
   }
 }
 
-string Peer::getExtensionName(uint8_t id)
+std::string Peer::getExtensionName(uint8_t id)
 {
   for(Extensions::const_iterator itr = _extensions.begin();
       itr != _extensions.end(); ++itr) {
@@ -188,7 +317,9 @@ string Peer::getExtensionName(uint8_t id)
   return "";
 }
 
-void Peer::setExtension(const string& name, uint8_t id)
+void Peer::setExtension(const std::string& name, uint8_t id)
 {
   _extensions[name] = id;
 }
+
+} // namespace aria2
diff --git a/src/Peer.h b/src/Peer.h
index 37e2d745..9f26f615 100644
--- a/src/Peer.h
+++ b/src/Peer.h
@@ -36,19 +36,20 @@
 #define _D_PEER_H_
 
 #include "common.h"
-#include "BitfieldMan.h"
-#include "PeerStat.h"
+#include "PeerDecl.h"
 #include "TimeA2.h"
 #include "BtConstants.h"
-#include "PeerDecl.h"
-#include <string.h>
+#include "PeerStat.h"
+#include <string>
+#include <deque>
 
-#define PEER_ID_LENGTH 20
-#define DEFAULT_LATENCY 1500
+namespace aria2 {
+
+class BitfieldMan;
 
 class Peer {
 public:
-  string ipaddr;
+  std::string ipaddr;
   // TCP port which this peer is listening for incoming connections.
   // If it is unknown, for example, localhost accepted the incoming connection
   // from this peer, set port to 0.
@@ -67,9 +68,9 @@ private:
   BitfieldMan* _bitfield;
   bool fastExtensionEnabled;
   // fast index set which a peer has sent to localhost.
-  Integers peerAllowedIndexSet;
+  std::deque<int32_t> peerAllowedIndexSet;
   // fast index set which localhost has sent to a peer.
-  Integers amAllowedIndexSet;
+  std::deque<int32_t> amAllowedIndexSet;
   bool _extendedMessagingEnabled;
   Extensions _extensions;
   bool _dhtEnabled;
@@ -78,109 +79,66 @@ private:
   int64_t sessionDownloadLength;
   int32_t latency;
   bool active;
-  string id;
+  std::string id;
   Time _firstContactTime;
   Time _badConditionStartTime;
   bool _seeder;
 
   void updateSeeder();
 public:
-  Peer(string ipaddr, uint16_t port);
+  Peer(std::string ipaddr, uint16_t port);
 
-  ~Peer() {
-    delete _bitfield;
-  }
+  ~Peer();
 
-  bool operator==(const Peer& p) {
-    return id == p.id;
-  }
+  bool operator==(const Peer& p);
   
-  bool operator!=(const Peer& p) {
-    return !(*this == p);
-  }
+  bool operator!=(const Peer& p);
 
   void resetStatus();
 
-  void updateUploadLength(int32_t bytes) {
-    peerStat.updateUploadLength(bytes);
-    sessionUploadLength += bytes;
-  }
+  void updateUploadLength(int32_t bytes);
 
-  void updateDownloadLength(int32_t bytes) {
-    peerStat.updateDownloadLength(bytes);
-    sessionDownloadLength += bytes;
-  }
+  void updateDownloadLength(int32_t bytes);
 
   /**
    * Returns the transfer rate from localhost to remote host.
    */
-  int32_t calculateUploadSpeed() {
-    return peerStat.calculateUploadSpeed();
-  }
+  int32_t calculateUploadSpeed();
 
-  int32_t calculateUploadSpeed(const struct timeval& now) {
-    return peerStat.calculateUploadSpeed(now);
-  }
+  int32_t calculateUploadSpeed(const struct timeval& now);
 
   /**
    * Returns the transfer rate from remote host to localhost.
    */
-  int32_t calculateDownloadSpeed() {
-    return peerStat.calculateDownloadSpeed();
-  }
+  int32_t calculateDownloadSpeed();
 
-  int32_t calculateDownloadSpeed(const struct timeval& now) {
-    return peerStat.calculateDownloadSpeed(now);
-  }
+  int32_t calculateDownloadSpeed(const struct timeval& now);
 
   /**
    * Returns the number of bytes uploaded to the remote host.
    */
-  int64_t getSessionUploadLength() const {
-    return sessionUploadLength;
-  }
+  int64_t getSessionUploadLength() const;
 
   /**
    * Returns the number of bytes downloaded from the remote host.
    */
-  int64_t getSessionDownloadLength() const {
-    return sessionDownloadLength;
-  }
+  int64_t getSessionDownloadLength() const;
 
-  void activate() {
-    peerStat.downloadStart();
-    active = true;
-  }
+  void activate();
 
-  void deactivate() {
-    peerStat.downloadStop();
-    active = false;
-  }
+  void deactivate();
 
-  bool isActive() const {
-    return active;
-  }
+  bool isActive() const;
 
-  void setPeerId(const unsigned char* peerId) {
-    memcpy(this->peerId, peerId, PEER_ID_LENGTH);
-  }
-  const unsigned char* getPeerId() const { return this->peerId; }
+  void setPeerId(const unsigned char* peerId);
+
+  const unsigned char* getPeerId() const;
   
-  void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) {
-    assert(_bitfield);
-    _bitfield->setBitfield(bitfield, bitfieldLength);
-    updateSeeder();
-  }
+  void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength);
 
-  const unsigned char* getBitfield() const {
-    assert(_bitfield);
-    return _bitfield->getBitfield();
-  }
+  const unsigned char* getBitfield() const;
 
-  int32_t getBitfieldLength() const {
-    assert(_bitfield);
-    return _bitfield->getBitfieldLength();
-  }
+  int32_t getBitfieldLength() const;
 
   void setAllBitfield();
 
@@ -190,23 +148,16 @@ public:
    */
   void updateBitfield(int32_t index, int32_t operation);
   
-  void setFastExtensionEnabled(bool enabled) {
-    fastExtensionEnabled = enabled;
-  }
-  bool isFastExtensionEnabled() const { return fastExtensionEnabled; }
+  void setFastExtensionEnabled(bool enabled);
+
+  bool isFastExtensionEnabled() const;
 
   void addPeerAllowedIndex(int32_t index);
   bool isInPeerAllowedIndexSet(int32_t index) const;
 
-  int32_t countPeerAllowedIndexSet() const
-  {
-    return peerAllowedIndexSet.size();
-  }
+  int32_t countPeerAllowedIndexSet() const;
 
-  const Integers& getPeerAllowedIndexSet() const
-  {
-    return peerAllowedIndexSet;
-  }
+  const std::deque<int32_t>& getPeerAllowedIndexSet() const;
 
   void addAmAllowedIndex(int32_t index);
   bool isInAmAllowedIndexSet(int32_t index) const;
@@ -241,9 +192,10 @@ public:
   }
 
   void updateLatency(int32_t latency);
+
   int32_t getLatency() const { return latency; }
 
-  const string& getId() const {
+  const std::string& getId() const {
     return id;
   }
 
@@ -265,11 +217,13 @@ public:
     return _badConditionStartTime;
   }
 
-  uint8_t getExtensionMessageID(const string& name);
+  uint8_t getExtensionMessageID(const std::string& name);
 
-  string getExtensionName(uint8_t id);
+  std::string getExtensionName(uint8_t id);
 
-  void setExtension(const string& name, uint8_t id);
+  void setExtension(const std::string& name, uint8_t id);
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_H_
diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc
index 4454a519..c46e5d34 100644
--- a/src/PeerAbstractCommand.cc
+++ b/src/PeerAbstractCommand.cc
@@ -37,11 +37,13 @@
 #include "DownloadEngine.h"
 #include "Option.h"
 #include "DlAbortEx.h"
-#include "DlRetryEx.h"
-#include "Util.h"
+#include "Socket.h"
+#include "Logger.h"
 #include "message.h"
 #include "prefs.h"
 
+namespace aria2 {
+
 PeerAbstractCommand::PeerAbstractCommand(int32_t cuid,
 					 const PeerHandle& peer,
 					 DownloadEngine* e,
@@ -54,6 +56,17 @@ PeerAbstractCommand::PeerAbstractCommand(int32_t cuid,
   timeout = e->option->getAsInt(PREF_BT_TIMEOUT);
 }
 
+PeerAbstractCommand::PeerAbstractCommand(int32_t cuid,
+					 const PeerHandle& peer,
+					 DownloadEngine* e)
+  :Command(cuid), e(e), socket(new SocketCore()), peer(peer),
+   checkSocketIsReadable(false), checkSocketIsWritable(false),
+   uploadLimitCheck(false), uploadLimit(0), noCheck(false)
+{
+  setReadCheckSocket(socket);
+  timeout = e->option->getAsInt(PREF_BT_TIMEOUT);
+}
+
 PeerAbstractCommand::~PeerAbstractCommand() {
   disableReadCheckSocket();
   disableWriteCheckSocket();
@@ -75,7 +88,7 @@ bool PeerAbstractCommand::execute() {
       checkPoint.reset();
     }
     if(checkPoint.elapsed(timeout)) {
-      throw new DlRetryEx(EX_TIME_OUT);
+      throw new DlAbortEx(EX_TIME_OUT);
     }
     return executeInternal();
   } catch(RecoverableException* err) {
@@ -160,3 +173,5 @@ void PeerAbstractCommand::setUploadLimitCheck(bool check) {
 void PeerAbstractCommand::setNoCheck(bool check) {
   this->noCheck = check;
 }
+
+} // namespace aria2
diff --git a/src/PeerAbstractCommand.h b/src/PeerAbstractCommand.h
index 103e3713..381c4223 100644
--- a/src/PeerAbstractCommand.h
+++ b/src/PeerAbstractCommand.h
@@ -36,13 +36,15 @@
 #define _D_PEER_ABSTRACT_COMMAND_H_
 
 #include "Command.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
-#include "Socket.h"
+
+namespace aria2 {
 
 class DownloadEngine;
 class Exception;
 class Peer;
-typedef SharedHandle<Peer> PeerHandle;
+class SocketCore;
 
 class PeerAbstractCommand : public Command {
 private:
@@ -50,8 +52,8 @@ private:
   int32_t timeout;
 protected:
   DownloadEngine* e;
-  SocketHandle socket;
-  PeerHandle peer;
+  SharedHandle<SocketCore> socket;
+  SharedHandle<Peer> peer;
 
   void setTimeout(int32_t timeout) { this->timeout = timeout; }
   virtual bool prepareForNextPeer(int32_t wait);
@@ -59,8 +61,8 @@ protected:
   virtual void onAbort(Exception* ex) {};
   virtual bool exitBeforeExecute() = 0;
   virtual bool executeInternal() = 0;
-  void setReadCheckSocket(const SocketHandle& socket);
-  void setWriteCheckSocket(const SocketHandle& socket);
+  void setReadCheckSocket(const SharedHandle<SocketCore>& socket);
+  void setWriteCheckSocket(const SharedHandle<SocketCore>& socket);
   void disableReadCheckSocket();
   void disableWriteCheckSocket();
   void setUploadLimit(int32_t uploadLimit);
@@ -69,19 +71,26 @@ protected:
 private:
   bool checkSocketIsReadable;
   bool checkSocketIsWritable;
-  SocketHandle readCheckTarget;
-  SocketHandle writeCheckTarget;
+  SharedHandle<SocketCore> readCheckTarget;
+  SharedHandle<SocketCore> writeCheckTarget;
   bool uploadLimitCheck;
   int32_t uploadLimit;
   bool noCheck;
 public:
   PeerAbstractCommand(int32_t cuid,
-		      const PeerHandle& peer,
+		      const SharedHandle<Peer>& peer,
 		      DownloadEngine* e,
-		      const SocketHandle& s = SocketHandle());
+		      const SharedHandle<SocketCore>& s);
+
+  PeerAbstractCommand(int32_t cuid,
+		      const SharedHandle<Peer>& peer,
+		      DownloadEngine* e);
+
   virtual ~PeerAbstractCommand();
 
   virtual bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_ABSTRACT_COMMAND_H_
diff --git a/src/PeerAddrEntry.h b/src/PeerAddrEntry.h
index b2a6d3fe..348a4ca2 100644
--- a/src/PeerAddrEntry.h
+++ b/src/PeerAddrEntry.h
@@ -37,19 +37,22 @@
 
 #include "common.h"
 #include "TimeA2.h"
+#include <string>
+
+namespace aria2 {
 
 class PeerAddrEntry {
 private:
-  string _ipaddr;
+  std::string _ipaddr;
   
   uint16_t _port;
 
   Time _lastUpdated;
 public:
-  PeerAddrEntry(const string& ipaddr, uint16_t port, Time updated = Time()):
+  PeerAddrEntry(const std::string& ipaddr, uint16_t port, Time updated = Time()):
     _ipaddr(ipaddr), _port(port), _lastUpdated(updated) {}
 
-  const string& getIPAddress() const
+  const std::string& getIPAddress() const
   {
     return _ipaddr;
   }
@@ -75,6 +78,6 @@ public:
   }
 };
 
-typedef deque<PeerAddrEntry> PeerAddrEntries;
+} // namespace aria2
 
 #endif // _D_DHT_PEER_ADDR_ENTRY_H_
diff --git a/src/PeerChokeCommand.cc b/src/PeerChokeCommand.cc
index 7c2eec0e..1edc827c 100644
--- a/src/PeerChokeCommand.cc
+++ b/src/PeerChokeCommand.cc
@@ -34,6 +34,16 @@
 /* copyright --> */
 #include "PeerChokeCommand.h"
 #include "Util.h"
+#include "Peer.h"
+#include "DownloadEngine.h"
+#include "BtContext.h"
+#include "BtRuntime.h"
+#include "PieceStorage.h"
+#include "PeerStorage.h"
+#include "Logger.h"
+#include <algorithm>
+
+namespace aria2 {
 
 PeerChokeCommand::PeerChokeCommand(int32_t cuid,
 				   RequestGroup* requestGroup,
@@ -62,7 +72,7 @@ void PeerChokeCommand::optUnchokingPeer(Peers& peers) const {
   if(peers.empty()) {
     return;
   }
-  random_shuffle(peers.begin(), peers.end());
+  std::random_shuffle(peers.begin(), peers.end());
   int32_t optUnchokCount = 1;
   for(Peers::iterator itr = peers.begin(); itr != peers.end(); itr++) {
     Peers::value_type peer = *itr;
@@ -85,7 +95,7 @@ public:
 };
 
 void PeerChokeCommand::orderByUploadRate(Peers& peers) const {
-  sort(peers.begin(), peers.end(), UploadFaster());
+  std::sort(peers.begin(), peers.end(), UploadFaster());
 }
 
 class DownloadFaster {
@@ -96,7 +106,7 @@ public:
 };
 
 void PeerChokeCommand::orderByDownloadRate(Peers& peers) const {
-  sort(peers.begin(), peers.end(), DownloadFaster());
+  std::sort(peers.begin(), peers.end(), DownloadFaster());
 }
 
 bool PeerChokeCommand::execute() {
@@ -106,7 +116,7 @@ bool PeerChokeCommand::execute() {
   if(checkPoint.elapsed(interval)) {
     checkPoint.reset();
     Peers peers = peerStorage->getActivePeers();
-    for_each(peers.begin(), peers.end(), ChokePeer());
+    std::for_each(peers.begin(), peers.end(), ChokePeer());
     if(pieceStorage->downloadFinished()) {
       orderByUploadRate(peers);
     } else {
@@ -162,3 +172,5 @@ bool PeerChokeCommand::execute() {
   e->commands.push_back(this);
   return false;
 }
+
+} // namespace aria2
diff --git a/src/PeerChokeCommand.h b/src/PeerChokeCommand.h
index 0a2b2f67..c51df91a 100644
--- a/src/PeerChokeCommand.h
+++ b/src/PeerChokeCommand.h
@@ -37,9 +37,13 @@
 
 #include "Command.h"
 #include "BtContextAwareCommand.h"
-#include "DownloadEngine.h"
-#include "TimeA2.h"
 #include "RequestGroupAware.h"
+#include "TimeA2.h"
+
+namespace aria2 {
+
+class DownloadEngine;
+class Peer;
 
 class PeerChokeCommand : public Command,
 			 public BtContextAwareCommand,
@@ -51,15 +55,15 @@ private:
   int32_t rotate;
   Time checkPoint;
 
-  void orderByUploadRate(Peers& peers) const;
-  void orderByDownloadRate(Peers& peers) const;
-  void optUnchokingPeer(Peers& peers) const;
+  void orderByUploadRate(std::deque<SharedHandle<Peer> >& peers) const;
+  void orderByDownloadRate(std::deque<SharedHandle<Peer> >& peers) const;
+  void optUnchokingPeer(std::deque<SharedHandle<Peer> >& peers) const;
 
 public:
   PeerChokeCommand(int32_t cuid,
 		   RequestGroup* requestGroup,
 		   DownloadEngine* e,
-		   const BtContextHandle& btContext,
+		   const SharedHandle<BtContext>& btContext,
 		   int32_t interval);
 
   virtual ~PeerChokeCommand();
@@ -67,4 +71,6 @@ public:
   virtual bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_CHOKE_COMMAND_H_
diff --git a/src/PeerConnection.cc b/src/PeerConnection.cc
index da65572b..83c6737d 100644
--- a/src/PeerConnection.cc
+++ b/src/PeerConnection.cc
@@ -35,11 +35,14 @@
 #include "PeerConnection.h"
 #include "message.h"
 #include "DlAbortEx.h"
-#include "PeerMessageUtil.h"
-#include "Util.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "BtHandshakeMessage.h"
+#include "Socket.h"
 #include "a2netcompat.h"
+#include <cstring>
+
+namespace aria2 {
 
 PeerConnection::PeerConnection(int32_t cuid,
 			       const SocketHandle& socket,
@@ -51,14 +54,9 @@ PeerConnection::PeerConnection(int32_t cuid,
    resbufLength(0),
    currentPayloadLength(0),
    lenbufLength(0)
-{
-  //logger->debug("PeerConnection::instantiated");
-}
+{}
 
-PeerConnection::~PeerConnection()
-{
-  //logger->debug("PeerConnection::deleted");
-}
+PeerConnection::~PeerConnection() {}
 
 int32_t PeerConnection::sendMessage(const unsigned char* data, int32_t dataLength) {
   int32_t writtenLength = 0;
@@ -154,3 +152,5 @@ bool PeerConnection::receiveHandshake(unsigned char* data, int32_t& dataLength,
   }
   return retval;
 }
+
+} // namespace aria2
diff --git a/src/PeerConnection.h b/src/PeerConnection.h
index d64b6f9e..5f254600 100644
--- a/src/PeerConnection.h
+++ b/src/PeerConnection.h
@@ -35,10 +35,14 @@
 #ifndef _D_PEER_CONNECTION_H_
 #define _D_PEER_CONNECTION_H_
 
-#include "Option.h"
-#include "Socket.h"
-#include "Logger.h"
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class Option;
+class Logger;
+class SocketCore;
 
 // we assume maximum length of incoming message is "piece" message with 16KB
 // data. Messages beyond that size are dropped.
@@ -47,7 +51,7 @@
 class PeerConnection {
 private:
   int32_t cuid;
-  SocketHandle socket;
+  SharedHandle<SocketCore> socket;
   const Option* option;
   const Logger* logger;
 
@@ -58,7 +62,8 @@ private:
   int32_t lenbufLength;
 
 public:
-  PeerConnection(int32_t cuid, const SocketHandle& socket, const Option* op);
+  PeerConnection(int32_t cuid, const SharedHandle<SocketCore>& socket, const Option* op);
+
   ~PeerConnection();
   
   // Returns the number of bytes written
@@ -77,4 +82,7 @@ public:
 
 typedef SharedHandle<PeerConnection> PeerConnectionHandle;
 typedef WeakHandle<PeerConnection> PeerConnectionWeakHandle;
+
+} // namespace aria2
+
 #endif // _D_PEER_CONNECTION_H_
diff --git a/src/PeerDecl.h b/src/PeerDecl.h
index 318beff9..5c780eb1 100644
--- a/src/PeerDecl.h
+++ b/src/PeerDecl.h
@@ -38,8 +38,12 @@
 #include "SharedHandle.h"
 #include <deque>
 
+namespace aria2 {
+
 class Peer;
 typedef SharedHandle<Peer> PeerHandle;
 typedef std::deque<PeerHandle> Peers;
 
+} // namespace aria2
+
 #endif // _D_PEER_DECL_H_
diff --git a/src/PeerInitiateConnectionCommand.cc b/src/PeerInitiateConnectionCommand.cc
index 8139f1fe..a2d0079d 100644
--- a/src/PeerInitiateConnectionCommand.cc
+++ b/src/PeerInitiateConnectionCommand.cc
@@ -35,11 +35,22 @@
 #include "PeerInitiateConnectionCommand.h"
 #include "DownloadEngine.h"
 #include "PeerInteractionCommand.h"
-#include "Util.h"
 #include "DlAbortEx.h"
 #include "message.h"
 #include "prefs.h"
 #include "CUIDCounter.h"
+#include "Socket.h"
+#include "Logger.h"
+#include "Peer.h"
+#include "PeerConnection.h"
+#include "BtContext.h"
+#include "BtRuntime.h"
+#include "PieceStorage.h"
+#include "PeerStorage.h"
+#include "BtAnnounce.h"
+#include "BtProgressInfoFile.h"
+
+namespace aria2 {
 
 PeerInitiateConnectionCommand::PeerInitiateConnectionCommand(int cuid,
 							     RequestGroup* requestGroup,
@@ -111,3 +122,5 @@ bool PeerInitiateConnectionCommand::exitBeforeExecute()
 {
   return btRuntime->isHalt();
 }
+
+} // namespace aria2
diff --git a/src/PeerInitiateConnectionCommand.h b/src/PeerInitiateConnectionCommand.h
index ee366ce6..a3e22ecc 100644
--- a/src/PeerInitiateConnectionCommand.h
+++ b/src/PeerInitiateConnectionCommand.h
@@ -39,6 +39,8 @@
 #include "RequestGroupAware.h"
 #include "BtContextAwareCommand.h"
 
+namespace aria2 {
+
 class PeerInitiateConnectionCommand : public PeerAbstractCommand,
 				      public BtContextAwareCommand,
 				      public RequestGroupAware
@@ -53,11 +55,13 @@ protected:
 public:
   PeerInitiateConnectionCommand(int cuid,
 				RequestGroup* requestGroup,
-				const PeerHandle& peer,
+				const SharedHandle<Peer>& peer,
 				DownloadEngine* e,
-				const BtContextHandle& btContext);
+				const SharedHandle<BtContext>& btContext);
 
   virtual ~PeerInitiateConnectionCommand();
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_INITIATE_CONNECTION_H_
diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc
index 3a60b6b7..160ad5e6 100644
--- a/src/PeerInteractionCommand.cc
+++ b/src/PeerInteractionCommand.cc
@@ -35,17 +35,26 @@
 #include "PeerInteractionCommand.h"
 #include "DownloadEngine.h"
 #include "PeerInitiateConnectionCommand.h"
-#include "PeerMessageUtil.h"
 #include "DefaultBtInteractive.h"
 #include "DlAbortEx.h"
-#include "Util.h"
 #include "message.h"
 #include "prefs.h"
+#include "Socket.h"
+#include "Option.h"
+#include "BtContext.h"
+#include "BtRegistry.h"
+#include "PeerObject.h"
+#include "Peer.h"
+#include "BtMessage.h"
+#include "BtRuntime.h"
+#include "PeerStorage.h"
 #include "DefaultBtMessageDispatcher.h"
 #include "DefaultBtMessageReceiver.h"
 #include "DefaultBtRequestFactory.h"
 #include "DefaultBtMessageFactory.h"
 #include "DefaultBtInteractive.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
 #include "CUIDCounter.h"
 #include "DHTTaskQueue.h"
 #include "DHTTaskFactory.h"
@@ -54,6 +63,8 @@
 #include "DHTRegistry.h"
 #include <algorithm>
 
+namespace aria2 {
+
 PeerInteractionCommand::PeerInteractionCommand(int32_t cuid,
 					       RequestGroup* requestGroup,
 					       const PeerHandle& p,
@@ -108,10 +119,8 @@ PeerInteractionCommand::PeerInteractionCommand(int32_t cuid,
   reqFactory->setBtMessageDispatcher(dispatcher);
   reqFactory->setBtMessageFactory(factory);
 
-  DefaultBtInteractiveHandle btInteractive = new DefaultBtInteractive();
+  DefaultBtInteractiveHandle btInteractive = new DefaultBtInteractive(btContext, peer);
   btInteractive->setCuid(cuid);
-  btInteractive->setPeer(peer);
-  btInteractive->setBtContext(btContext);
   btInteractive->setBtMessageReceiver(receiver);
   btInteractive->setDispatcher(dispatcher);
   btInteractive->setBtRequestFactory(reqFactory);
@@ -256,3 +265,4 @@ bool PeerInteractionCommand::exitBeforeExecute()
   return btRuntime->isHalt();
 }
 
+} // namespace aria2
diff --git a/src/PeerInteractionCommand.h b/src/PeerInteractionCommand.h
index 046504cc..e27974c0 100644
--- a/src/PeerInteractionCommand.h
+++ b/src/PeerInteractionCommand.h
@@ -38,8 +38,11 @@
 #include "PeerAbstractCommand.h"
 #include "RequestGroupAware.h"
 #include "BtContextAwareCommand.h"
-#include "BtInteractive.h"
-#include "PeerConnection.h"
+
+namespace aria2 {
+
+class BtInteractive;
+class PeerConnection;
 
 class PeerInteractionCommand : public PeerAbstractCommand,
 			       public BtContextAwareCommand,
@@ -49,12 +52,11 @@ public:
   enum Seq {
     INITIATOR_SEND_HANDSHAKE,
     INITIATOR_WAIT_HANDSHAKE,
-    //RECEIVER_SEND_HANDSHAKE,
     RECEIVER_WAIT_HANDSHAKE,
     WIRED};
 private:
   Seq sequence;
-  BtInteractiveHandle btInteractive;
+  SharedHandle<BtInteractive> btInteractive;
   int32_t maxDownloadSpeedLimit;
 protected:
   virtual bool executeInternal();
@@ -65,15 +67,17 @@ protected:
 public:
   PeerInteractionCommand(int32_t cuid,
 			 RequestGroup* requestGroup,
-			 const PeerHandle& peer,
+			 const SharedHandle<Peer>& peer,
 			 DownloadEngine* e,
-			 const BtContextHandle& btContext,
-			 const SocketHandle& s,
+			 const SharedHandle<BtContext>& btContext,
+			 const SharedHandle<SocketCore>& s,
 			 Seq sequence,
-			 const PeerConnectionHandle& peerConnection = 0);
+			 const SharedHandle<PeerConnection>& peerConnection = 0);
 
   virtual ~PeerInteractionCommand();
 
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_INTERACTION_COMMAND_H_
diff --git a/src/PeerListProcessor.h b/src/PeerListProcessor.h
index 7a235641..c4b66e4f 100644
--- a/src/PeerListProcessor.h
+++ b/src/PeerListProcessor.h
@@ -36,19 +36,26 @@
 #define _D_PEER_LIST_PROCESSOR_H_
 
 #include "common.h"
-#include "MetaEntry.h"
-#include "Peer.h"
 #include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
+
+class MetaEntry;
+class Peer;
 
 class PeerListProcessor {
 public:
   virtual ~PeerListProcessor() {}
 
-  virtual Peers extractPeer(const MetaEntry* peersEntry) = 0;
+  virtual std::deque<SharedHandle<Peer> >
+  extractPeer(const MetaEntry* peersEntry) = 0;
 
   virtual bool canHandle(const MetaEntry* peersEntry) const = 0;
 };
 
 typedef SharedHandle<PeerListProcessor> PeerListProcessorHandle;
 
+} // namespace aria2
+
 #endif // _D_PEER_LIST_PROCESSOR_H_
diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc
index a8f52afa..40ddcfa9 100644
--- a/src/PeerListenCommand.cc
+++ b/src/PeerListenCommand.cc
@@ -40,6 +40,11 @@
 #include "CUIDCounter.h"
 #include "message.h"
 #include "PeerReceiveHandshakeCommand.h"
+#include "Logger.h"
+#include "Socket.h"
+#include <utility>
+
+namespace aria2 {
 
 int32_t PeerListenCommand::__numInstance = 0;
 
@@ -86,9 +91,9 @@ bool PeerListenCommand::execute() {
     SocketHandle peerSocket;
     try {
       peerSocket = socket->acceptConnection();
-      pair<string, int32_t> peerInfo;
+      std::pair<std::string, int32_t> peerInfo;
       peerSocket->getPeerInfo(peerInfo);
-      pair<string, int32_t> localInfo;
+      std::pair<std::string, int32_t> localInfo;
       peerSocket->getAddrInfo(localInfo);
 
       if(peerInfo.first == localInfo.first) {
@@ -121,3 +126,5 @@ PeerListenCommand* PeerListenCommand::getInstance(DownloadEngine* e)
   }
   return __instance;
 }
+
+} // namespace aria2
diff --git a/src/PeerListenCommand.h b/src/PeerListenCommand.h
index e2696f63..1271f59d 100644
--- a/src/PeerListenCommand.h
+++ b/src/PeerListenCommand.h
@@ -36,15 +36,18 @@
 #define _D_PEER_LISTEN_COMMAND_H_
 
 #include "Command.h"
-#include "Socket.h"
+#include "SharedHandle.h"
 #include "IntSequence.h"
 
+namespace aria2 {
+
 class DownloadEngine;
+class SocketCore;
 
 class PeerListenCommand : public Command {
 private:
   DownloadEngine* e;
-  SocketHandle socket;
+  SharedHandle<SocketCore> socket;
   int32_t _lowestSpeedLimit;
 
   static int32_t __numInstance;
@@ -74,4 +77,6 @@ public:
   
 };
 
+} // namespace aria2 
+
 #endif // _D_PEER_LISTEN_COMMAND_H_
diff --git a/src/PeerMessageUtil.cc b/src/PeerMessageUtil.cc
index eb526407..c32ac949 100644
--- a/src/PeerMessageUtil.cc
+++ b/src/PeerMessageUtil.cc
@@ -34,8 +34,11 @@
 /* copyright --> */
 #include "PeerMessageUtil.h"
 #include "DlAbortEx.h"
-#include "Util.h"
 #include "a2netcompat.h"
+#include <cassert>
+#include <cstring>
+
+namespace aria2 {
 
 int8_t PeerMessageUtil::getId(const unsigned char* msg) {
   return msg[0];
@@ -90,7 +93,7 @@ void PeerMessageUtil::checkRange(int32_t begin, int32_t length, int32_t pieceLen
 void PeerMessageUtil::checkBitfield(const unsigned char* bitfield,
 				    int32_t bitfieldLength,
 				    int32_t pieces) {
-  if(!(bitfieldLength == BITFIELD_LEN_FROM_PIECES(pieces))) {
+  if(!(bitfieldLength == (pieces+7)/8)) {
     throw new DlAbortEx("Invalid bitfield length: %d",
 			bitfieldLength);
   }
@@ -122,7 +125,7 @@ void PeerMessageUtil::createPeerMessageString(unsigned char* msg,
   msg[4] = messageId;
 }
 
-bool PeerMessageUtil::createcompact(char* compact, const string& addr, uint16_t port)
+bool PeerMessageUtil::createcompact(char* compact, const std::string& addr, uint16_t port)
 {
   struct in_addr in;
   if(inet_aton(addr.c_str(), &in) == 0) {
@@ -135,11 +138,13 @@ bool PeerMessageUtil::createcompact(char* compact, const string& addr, uint16_t
   return true;
 }
 
-pair<string, uint16_t> PeerMessageUtil::unpackcompact(const char* compact)
+std::pair<std::string, uint16_t> PeerMessageUtil::unpackcompact(const char* compact)
 {
   struct in_addr in;
   in.s_addr = *(uint32_t*)(compact);
-  string ipaddr = inet_ntoa(in);
+  std::string ipaddr = inet_ntoa(in);
   uint16_t port = ntohs(*(uint16_t*)(compact+sizeof(uint32_t)));
-  return pair<string, uint16_t>(ipaddr, port);
+  return std::pair<std::string, uint16_t>(ipaddr, port);
 }
+
+} // namespace aria2
diff --git a/src/PeerMessageUtil.h b/src/PeerMessageUtil.h
index 29bf1479..c2446c1c 100644
--- a/src/PeerMessageUtil.h
+++ b/src/PeerMessageUtil.h
@@ -36,6 +36,10 @@
 #define _D_PEER_MESSAGE_UTIL_H_
 
 #include "common.h"
+#include <string>
+#include <utility>
+
+namespace aria2 {
 
 #define MAX_BLOCK_LENGTH (128*1024)
 
@@ -74,9 +78,11 @@ public:
    * The example of failure reason is that addr is not numbers-and-dots
    * notation.
    */
-  static bool createcompact(char* compact, const string& addr, uint16_t port);
+  static bool createcompact(char* compact, const std::string& addr, uint16_t port);
 
-  static pair<string, uint16_t> unpackcompact(const char* compact);
+  static std::pair<std::string, uint16_t> unpackcompact(const char* compact);
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_MESSAGE_UTIL_H_
diff --git a/src/PeerObject.h b/src/PeerObject.h
index 44521c8f..59e382cc 100644
--- a/src/PeerObject.h
+++ b/src/PeerObject.h
@@ -36,12 +36,15 @@
 #define _D_PEER_OBJECT_H_
 
 #include "common.h"
-#include "BtMessageFactory.h"
-#include "BtRequestFactory.h"
-#include "BtMessageDispatcher.h"
-#include "PeerConnection.h"
-#include "BtMessageReceiver.h"
-#include "ExtensionMessageFactory.h"
+
+namespace aria2 {
+
+class BtMessageFactory;
+class BtRequestFactory;
+class BtMessageDispatcher;
+class BtMessageReceiver;
+class ExtensionMessageFactory;
+class PeerConnection;
 
 class PeerObject {
 public:
@@ -52,14 +55,16 @@ public:
 	       peerConnection(0),
 	       extensionMessageFactory(0) {}
   
-  BtMessageFactoryHandle btMessageFactory;
-  BtRequestFactoryHandle btRequestFactory;
-  BtMessageDispatcherHandle btMessageDispatcher;
-  BtMessageReceiverHandle btMessageReceiver;
-  PeerConnectionHandle peerConnection;
-  ExtensionMessageFactoryHandle extensionMessageFactory;
+  SharedHandle<BtMessageFactory> btMessageFactory;
+  SharedHandle<BtRequestFactory> btRequestFactory;
+  SharedHandle<BtMessageDispatcher> btMessageDispatcher;
+  SharedHandle<BtMessageReceiver> btMessageReceiver;
+  SharedHandle<PeerConnection> peerConnection;
+  SharedHandle<ExtensionMessageFactory> extensionMessageFactory;
 };
 
 typedef SharedHandle<PeerObject> PeerObjectHandle;
 
+} // namespace aria2
+
 #endif // _D_PEER_OBJECT_H_
diff --git a/src/PeerReceiveHandshakeCommand.cc b/src/PeerReceiveHandshakeCommand.cc
index fc6db478..924a8cfb 100644
--- a/src/PeerReceiveHandshakeCommand.cc
+++ b/src/PeerReceiveHandshakeCommand.cc
@@ -40,7 +40,17 @@
 #include "BtContext.h"
 #include "DlAbortEx.h"
 #include "PeerInteractionCommand.h"
+#include "Peer.h"
+#include "BtRegistry.h"
+#include "PeerStorage.h"
+#include "PieceStorage.h"
+#include "BtRuntime.h"
+#include "BtConstants.h"
 #include "message.h"
+#include "Socket.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand(int32_t cuid,
 							 const PeerHandle& peer,
@@ -68,7 +78,7 @@ bool PeerReceiveHandshakeCommand::executeInternal()
   // To handle tracker's NAT-checking feature
   if(dataLength >= 48) {
     // check info_hash
-    string infoHash = Util::toHex(&data[28], INFO_HASH_LENGTH);
+    std::string infoHash = Util::toHex(&data[28], INFO_HASH_LENGTH);
     BtContextHandle btContext = BtRegistry::getBtContext(infoHash);
     if(btContext.isNull() || !BT_RUNTIME(btContext)->ready()) {
       throw new DlAbortEx("Unknown info hash %s", infoHash.c_str());
@@ -99,3 +109,5 @@ bool PeerReceiveHandshakeCommand::executeInternal()
     return false;
   }
 }
+
+} // namespace aria2
diff --git a/src/PeerReceiveHandshakeCommand.h b/src/PeerReceiveHandshakeCommand.h
index 8784dd99..fed9049c 100644
--- a/src/PeerReceiveHandshakeCommand.h
+++ b/src/PeerReceiveHandshakeCommand.h
@@ -37,13 +37,16 @@
 
 #include "PeerAbstractCommand.h"
 
+namespace aria2 {
+
 class PeerConnection;
-typedef SharedHandle<PeerConnection> PeerConnectionHandle;
+class SocketCore;
+class Peer;
 
 class PeerReceiveHandshakeCommand:public PeerAbstractCommand
 {
 private:
-  PeerConnectionHandle _peerConnection;
+  SharedHandle<PeerConnection> _peerConnection;
 
   int32_t _lowestSpeedLimit;
 
@@ -56,13 +59,15 @@ protected:
   virtual bool exitBeforeExecute();
 public:
   PeerReceiveHandshakeCommand(int32_t cuid,
-			      const PeerHandle& peer,
+			      const SharedHandle<Peer>& peer,
 			      DownloadEngine* e,
-			      const SocketHandle& s);
+			      const SharedHandle<SocketCore>& s);
 
   virtual ~PeerReceiveHandshakeCommand();
 
 
 };
 
+} // namespace aria2
+
 #endif // _D_PEER_RECEIVE_HANDSHAKE_COMMAND_H_
diff --git a/src/PeerStat.h b/src/PeerStat.h
index 5a99014c..1a38b47e 100644
--- a/src/PeerStat.h
+++ b/src/PeerStat.h
@@ -39,6 +39,8 @@
 #include "SpeedCalc.h"
 #include "SharedHandle.h"
 
+namespace aria2 {
+
 class PeerStat {
 public:
   enum STATUS {
@@ -135,5 +137,8 @@ public:
 };
 
 typedef SharedHandle<PeerStat> PeerStatHandle;
+typedef std::deque<PeerStatHandle> PeerStats;
+
+} // namespace aria2
 
 #endif // _D_PEER_STAT_H_
diff --git a/src/PeerStorage.h b/src/PeerStorage.h
index 2c76c514..e0ef37d3 100644
--- a/src/PeerStorage.h
+++ b/src/PeerStorage.h
@@ -36,8 +36,13 @@
 #define _D_PEER_STORAGE_H_
 
 #include "common.h"
-#include "Peer.h"
+#include "SharedHandle.h"
 #include "TransferStat.h"
+#include <deque>
+
+namespace aria2 {
+
+class Peer;
 
 class PeerStorage {
 public:
@@ -47,22 +52,22 @@ public:
    * Adds new peer to the internal peer list.
    * If the peer is added successfully, returns true. Otherwise returns false.
    */
-  virtual bool addPeer(const PeerHandle& peer) = 0;
+  virtual bool addPeer(const SharedHandle<Peer>& peer) = 0;
 
   /**
    * Adds all peers in peers to internal peer list.
    */
-  virtual void addPeer(const Peers& peers) = 0;
+  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers) = 0;
 
   /**
    * Returns internal peer list.
    */
-  virtual const Peers& getPeers() = 0;
+  virtual const std::deque<SharedHandle<Peer> >& getPeers() = 0;
 
   /**
    * Returns one of the unused peers.
    */
-  virtual PeerHandle getUnusedPeer() = 0;
+  virtual SharedHandle<Peer> getUnusedPeer() = 0;
 
   /**
    * Returns true if at least one unused peer exists.
@@ -73,7 +78,7 @@ public:
   /**
    * Returns the list of peers which are currently connected from localhost.
    */
-  virtual Peers getActivePeers() = 0;
+  virtual std::deque<SharedHandle<Peer> > getActivePeers() = 0;
 
   /**
    * Calculates current download/upload statistics.
@@ -83,9 +88,11 @@ public:
   /**
    * Tells PeerStorage object that peer is no longer used in the session.
    */
-  virtual void returnPeer(const PeerHandle& peer) = 0;
+  virtual void returnPeer(const SharedHandle<Peer>& peer) = 0;
 };
 
 typedef SharedHandle<PeerStorage> PeerStorageHandle;
 
+} // namespace aria2
+
 #endif // _D_PEER_STORAGE_H_
diff --git a/src/Piece.cc b/src/Piece.cc
index ed866760..837bf11d 100644
--- a/src/Piece.cc
+++ b/src/Piece.cc
@@ -35,6 +35,9 @@
 #include "Piece.h"
 #include "Util.h"
 #include "BitfieldManFactory.h"
+#include "BitfieldMan.h"
+
+namespace aria2 {
 
 Piece::Piece():index(0), length(0), _blockLength(BLOCK_LENGTH), bitfield(0) {}
 
@@ -54,6 +57,31 @@ Piece::Piece(const Piece& piece) {
   }
 }
 
+Piece::~Piece()
+{
+  delete bitfield;
+}
+
+Piece& Piece::operator=(const Piece& piece)
+{
+  if(this != &piece) {
+    index = piece.index;
+    length = piece.length;
+    delete bitfield;
+    if(piece.bitfield) {
+      bitfield = new BitfieldMan(*piece.bitfield);
+    } else {
+      bitfield = 0;
+    }
+  }
+  return *this;
+}
+
+bool Piece::operator==(const Piece& piece) const
+{
+  return index == piece.index;
+}
+
 void Piece::completeBlock(int32_t blockIndex) {
   bitfield->setBit(blockIndex);
   bitfield->unsetUseBit(blockIndex);
@@ -73,10 +101,50 @@ bool Piece::pieceComplete() const {
   return bitfield->isAllBitSet();
 }
 
+int32_t Piece::countBlock() const
+{
+  return bitfield->countBlock();
+}
+
+int32_t Piece::getBlockLength(int32_t index) const
+{
+  return bitfield->getBlockLength(index);
+}
+
+int32_t Piece::getBlockLength() const
+{
+  return bitfield->getBlockLength();
+}
+
+const unsigned char* Piece::getBitfield() const
+{
+  return bitfield->getBitfield();
+}
+
+int32_t Piece::getBitfieldLength() const
+{
+  return bitfield->getBitfieldLength();
+}
+
+bool Piece::isBlockUsed(int32_t index) const
+{
+  return bitfield->isUseBitSet(index);
+}
+
 void Piece::cancelBlock(int32_t blockIndex) {
   bitfield->unsetUseBit(blockIndex);
 }
 
+int32_t Piece::countCompleteBlock() const
+{
+  return bitfield->countBlock()-bitfield->countMissingBlock();
+}
+
+bool Piece::hasBlock(int32_t blockIndex) const
+{
+  return bitfield->isBitSet(blockIndex);
+}
+
 int32_t Piece::getMissingUnusedBlockIndex() const {
   int32_t blockIndex = bitfield->getFirstMissingUnusedIndex();
   if(blockIndex == -1) {
@@ -100,11 +168,11 @@ int32_t Piece::getFirstMissingBlockIndexWithoutLock() const
   return bitfield->getFirstMissingIndex();
 }
 
-BlockIndexes Piece::getAllMissingBlockIndexes() const {
+std::deque<int32_t> Piece::getAllMissingBlockIndexes() const {
   return bitfield->getAllMissingIndexes();
 }
 
-string Piece::toString() const {
+std::string Piece::toString() const {
   return "piece: index="+Util::itos(index)+", length="+Util::itos(length);
 }
 
@@ -214,3 +282,4 @@ int32_t Piece::getCompletedLength()
   return length;
 }
 
+} // namespace aria2
diff --git a/src/Piece.h b/src/Piece.h
index 5686dab4..1b1c5c1e 100644
--- a/src/Piece.h
+++ b/src/Piece.h
@@ -35,12 +35,15 @@
 #ifndef _D_PIECE_H_
 #define _D_PIECE_H_
 
-#include "BitfieldMan.h"
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+#include <deque>
+#include <string>
 
-class Piece;
-typedef SharedHandle<Piece> PieceHandle;
-typedef deque<PieceHandle> Pieces;
+namespace aria2 {
+
+class BitfieldMan;
 
 class Piece {
 private:
@@ -49,7 +52,7 @@ private:
   int32_t _blockLength;
   BitfieldMan* bitfield;
 
-  Pieces _subPieces;
+  std::deque<SharedHandle<Piece> > _subPieces;
 public:
 
   static const int32_t BLOCK_LENGTH  = 16*1024;
@@ -60,80 +63,64 @@ public:
 
   Piece(const Piece& piece);
 
-  ~Piece() {
-    delete bitfield;
-  }
+  ~Piece();
 
-  Piece& operator=(const Piece& piece) {
-    if(this != &piece) {
-      index = piece.index;
-      length = piece.length;
-      if(bitfield != NULL) {
-	delete bitfield;
-      }
-      if(piece.bitfield == NULL) {
-	bitfield = NULL;
-      } else {
-	bitfield = new BitfieldMan(*piece.bitfield);
-      }
-    }
-    return *this;
-  }
+  Piece& operator=(const Piece& piece);
   
-  bool operator==(const Piece& piece) const {
-    return index == piece.index;
-  }
+  bool operator==(const Piece& piece) const;
 
   int32_t getMissingUnusedBlockIndex() const;
   int32_t getMissingBlockIndex() const;
   int32_t getFirstMissingBlockIndexWithoutLock() const;
-  BlockIndexes getAllMissingBlockIndexes() const;
+  std::deque<int32_t> getAllMissingBlockIndexes() const;
   void completeBlock(int32_t blockIndex);
   void cancelBlock(int32_t blockIndex);
-  int32_t countCompleteBlock() const {
-    return bitfield->countBlock()-bitfield->countMissingBlock();
-  }
-  bool hasBlock(int32_t blockIndex) const {
-    return bitfield->isBitSet(blockIndex);
-  }
+
+  int32_t countCompleteBlock() const;
+
+  bool hasBlock(int32_t blockIndex) const;
+
   /**
    * Returns true if all blocks of this piece have been downloaded, otherwise
    * returns false.
    */
   bool pieceComplete() const;
-  int32_t countBlock() const { return bitfield->countBlock(); }
-  int32_t getBlockLength(int32_t index) const {
-    return bitfield->getBlockLength(index);
-  }
-  int32_t getBlockLength() const { return bitfield->getBlockLength(); }
+
+  int32_t countBlock() const;
+
+  int32_t getBlockLength(int32_t index) const;
+
+  int32_t getBlockLength() const;
+
   int32_t getIndex() const { return index; }
+
   void setIndex(int32_t index) { this->index = index; }
+
   int32_t getLength() const { return length; }
+
   void setLength(int32_t index) { this->length = length; }
 
-  const unsigned char* getBitfield() const { return bitfield->getBitfield(); }
+  const unsigned char* getBitfield() const;
+
   void setBitfield(const unsigned char* bitfield, int32_t len);
 
-  int32_t getBitfieldLength() const {
-    return bitfield->getBitfieldLength();
-  }
+  int32_t getBitfieldLength() const;
 
   void clearAllBlock();
   void setAllBlock();
 
-  string toString() const;
+  std::string toString() const;
 
-  bool isBlockUsed(int32_t index) const {
-    return bitfield->isUseBitSet(index);
-  }
+  bool isBlockUsed(int32_t index) const;
 
-  void addSubPiece(const PieceHandle& subPiece);
+  void addSubPiece(const SharedHandle<Piece>& subPiece);
 
-  PieceHandle getSubPiece(int32_t blockIndex);
+  SharedHandle<Piece> getSubPiece(int32_t blockIndex);
   
   void removeSubPiece(int32_t blockIndex);
 
-  Pieces::iterator getSubPieceIterator(int32_t blockIndex);
+  std::deque<SharedHandle<Piece> >::iterator
+  getSubPieceIterator(int32_t blockIndex);
 
   bool isRangeComplete(int32_t offset, int32_t length);
 
@@ -147,6 +134,8 @@ public:
 };
 
 typedef SharedHandle<Piece> PieceHandle;
-typedef deque<PieceHandle> Pieces;
+typedef std::deque<PieceHandle> Pieces;
+
+} // namespace aria2
 
 #endif // _D_PIECE_H_
diff --git a/src/PieceHashCheckIntegrityEntry.cc b/src/PieceHashCheckIntegrityEntry.cc
index 1fdb07c6..466eb8d2 100644
--- a/src/PieceHashCheckIntegrityEntry.cc
+++ b/src/PieceHashCheckIntegrityEntry.cc
@@ -33,12 +33,13 @@
  */
 /* copyright --> */
 #include "PieceHashCheckIntegrityEntry.h"
-#include "Command.h"
 #include "RequestGroup.h"
 #include "IteratableChunkChecksumValidator.h"
 #include "DownloadContext.h"
 #include "PieceStorage.h"
 
+namespace aria2 {
+
 PieceHashCheckIntegrityEntry::PieceHashCheckIntegrityEntry(RequestGroup* requestGroup,
 							   Command* nextCommand):
   CheckIntegrityEntry(requestGroup, nextCommand) {}
@@ -62,3 +63,5 @@ void PieceHashCheckIntegrityEntry::initValidator()
   _validator = validator;
 #endif // ENABLE_MESSAGE_DIGEST
 }
+
+} // namespace aria2
diff --git a/src/PieceHashCheckIntegrityEntry.h b/src/PieceHashCheckIntegrityEntry.h
index 44313cc4..e6462221 100644
--- a/src/PieceHashCheckIntegrityEntry.h
+++ b/src/PieceHashCheckIntegrityEntry.h
@@ -37,6 +37,8 @@
 
 #include "CheckIntegrityEntry.h"
 
+namespace aria2 {
+
 class PieceHashCheckIntegrityEntry : public CheckIntegrityEntry
 {
 public:
@@ -49,4 +51,6 @@ public:
   virtual void initValidator();
 };
 
+} // namespace aria2
+
 #endif // _D_PIECE_HASH_CHECK_INTEGRITY_ENTRY_H_
diff --git a/src/PieceHashMetalinkParserState.cc b/src/PieceHashMetalinkParserState.cc
index cf64a67e..c9d3e2db 100644
--- a/src/PieceHashMetalinkParserState.cc
+++ b/src/PieceHashMetalinkParserState.cc
@@ -35,18 +35,22 @@
 #include "PieceHashMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void PieceHashMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-						const string& name,
-						const map<string, string>& attrs)
+						const std::string& name,
+						const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void PieceHashMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					      const string& name,
-					      const string& characters)
+					      const std::string& name,
+					      const std::string& characters)
 {
   stm->setMessageDigestOfChunkChecksum(characters);
   stm->addHashOfChunkChecksum();
   stm->setPiecesState();
 }
+
+} // namespace aria2
diff --git a/src/PieceHashMetalinkParserState.h b/src/PieceHashMetalinkParserState.h
index d0d0e5fe..28bf3094 100644
--- a/src/PieceHashMetalinkParserState.h
+++ b/src/PieceHashMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class PieceHashMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_PIECE_HASH_METALINK_PARSER_STATE_H_
diff --git a/src/PieceStorage.h b/src/PieceStorage.h
index 72aeb4d4..2ed354f8 100644
--- a/src/PieceStorage.h
+++ b/src/PieceStorage.h
@@ -36,16 +36,17 @@
 #define _D_PIECE_STORAGE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "TimeA2.h"
 #include "IntSequence.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class Piece;
-typedef SharedHandle<Piece> PieceHandle;
-typedef deque<PieceHandle> Pieces;
 class Peer;
-typedef SharedHandle<Peer> PeerHandle;
 class DiskAdaptor;
-typedef SharedHandle<DiskAdaptor> DiskAdaptorHandle;
 
 class PieceStorage {
 public:
@@ -55,7 +56,7 @@ public:
    * Returns true if the peer has a piece that localhost doesn't have.
    * Otherwise returns false.
    */
-  virtual bool hasMissingPiece(const PeerHandle& peer) = 0;
+  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer) = 0;
 
   /**
    * Returns a piece that the peer has but localhost doesn't.
@@ -63,7 +64,9 @@ public:
    * from get the same piece. But in end game mode, same piece may be returned
    * to several commands.
    */
-  virtual PieceHandle getMissingPiece(const PeerHandle& peer) = 0;
+  virtual SharedHandle<Piece>
+  getMissingPiece(const SharedHandle<Peer>& peer) = 0;
+
   /**
    * Returns a piece that the peer has but localhost doesn't.
    * Only pieces that declared as "fast" are returned.
@@ -71,12 +74,13 @@ public:
    * from get the same piece. But in end game mode, same piece may be returned
    * to several commands.
    */
-  virtual PieceHandle getMissingFastPiece(const PeerHandle& peer) = 0;
+  virtual SharedHandle<Piece>
+  getMissingFastPiece(const SharedHandle<Peer>& peer) = 0;
 
   /**
    * Returns a missing piece if available. Otherwise returns 0;
    */
-  virtual PieceHandle getMissingPiece() = 0;
+  virtual SharedHandle<Piece> getMissingPiece() = 0;
 
   /**
    * Returns a missing piece whose index is index.
@@ -84,13 +88,13 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual PieceHandle getMissingPiece(int32_t index) = 0;
+  virtual SharedHandle<Piece> getMissingPiece(int32_t index) = 0;
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual PieceHandle getPiece(int32_t index) = 0;
+  virtual SharedHandle<Piece> getPiece(int32_t index) = 0;
 
   /**
    * Marks the piece whose index is index as missing.
@@ -100,12 +104,12 @@ public:
   /**
    * Tells that the download of the specfied piece completes.
    */
-  virtual void completePiece(const PieceHandle& piece) = 0;
+  virtual void completePiece(const SharedHandle<Piece>& piece) = 0;
 
   /**
    * Tells that the download of the specified piece is canceled.
    */
-  virtual void cancelPiece(const PieceHandle& piece) = 0;
+  virtual void cancelPiece(const SharedHandle<Piece>& piece) = 0;
 
   /**
    * Returns true if the specified piece is already downloaded.
@@ -123,7 +127,7 @@ public:
 
   virtual int64_t getFilteredCompletedLength() = 0;
   
-  virtual void setFileFilter(const Strings& filePaths) = 0;
+  virtual void setFileFilter(const std::deque<std::string>& filePaths) = 0;
 
   virtual void setFileFilter(IntSequence seq) = 0;
 
@@ -161,7 +165,7 @@ public:
 
   virtual bool isEndGame() = 0;
 
-  virtual DiskAdaptorHandle getDiskAdaptor() = 0;
+  virtual SharedHandle<DiskAdaptor> getDiskAdaptor() = 0;
   
   virtual int32_t getPieceLength(int32_t index) = 0;
 
@@ -175,8 +179,8 @@ public:
    * Returns piece index which is not advertised by the caller command and
    * newer than lastCheckTime.
    */
-  virtual Integers getAdvertisedPieceIndexes(int32_t myCuid,
-					     const Time& lastCheckTime) = 0;
+  virtual std::deque<int32_t>
+  getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0;
 
   /**
    * Removes have entry if specified seconds have elapsed since its
@@ -194,13 +198,16 @@ public:
    */
   virtual void markPiecesDone(int64_t length) = 0;
 
-  virtual void addInFlightPiece(const Pieces& pieces) = 0;
+  virtual void
+  addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) = 0;
 
   virtual int32_t countInFlightPiece() = 0;
 
-  virtual Pieces getInFlightPieces() = 0;
+  virtual std::deque<SharedHandle<Piece> > getInFlightPieces() = 0;
 };
 
 typedef SharedHandle<PieceStorage> PieceStorageHandle;
 
+} // namespace aria2
+
 #endif // _D_PIECE_STORAGE_H_
diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc
index 31b3ad2d..e6932437 100644
--- a/src/PiecedSegment.cc
+++ b/src/PiecedSegment.cc
@@ -35,11 +35,11 @@
 #include "PiecedSegment.h"
 #include "Piece.h"
 
+namespace aria2 {
+
 PiecedSegment::PiecedSegment(int32_t pieceLength, const PieceHandle& piece):
-  _pieceLength(pieceLength), _overflowLength(0), _piece(piece)
-{
-  _writtenLength = _piece->getFirstMissingBlockIndexWithoutLock()*_piece->getBlockLength();
-}
+  _pieceLength(pieceLength), _overflowLength(0), _piece(piece),
+  _writtenLength(_piece->getFirstMissingBlockIndexWithoutLock()*_piece->getBlockLength()) {}
 
 PiecedSegment::~PiecedSegment() {}
 
@@ -95,3 +95,5 @@ PieceHandle PiecedSegment::getPiece() const
 {
   return _piece;
 }
+
+} // namespace aria2
diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h
index 2fb7e5f1..73217a23 100644
--- a/src/PiecedSegment.h
+++ b/src/PiecedSegment.h
@@ -37,6 +37,8 @@
 
 #include "Segment.h"
 
+namespace aria2 {
+
 class PiecedSegment:public Segment {
 private:
   /**
@@ -44,12 +46,12 @@ private:
    * The last piece likely have shorter length than the other length.
    */
   int32_t _pieceLength;
-  int32_t _writtenLength;
   int32_t _overflowLength;
-  PieceHandle _piece;
+  SharedHandle<Piece> _piece;
+  int32_t _writtenLength;
 
 public:
-  PiecedSegment(int32_t pieceLength, const PieceHandle& piece);
+  PiecedSegment(int32_t pieceLength, const SharedHandle<Piece>& piece);
 
   virtual ~PiecedSegment();
 
@@ -82,10 +84,12 @@ public:
 
   virtual void clear();
 
-  virtual PieceHandle getPiece() const;
+  virtual SharedHandle<Piece> getPiece() const;
 };
 
 typedef SharedHandle<PiecedSegment> PiecedSegmentHandle;
 
+} // namespace aria2
+
 #endif // _D_PIECED_SEGMENT_H_
 
diff --git a/src/PiecesMetalinkParserState.cc b/src/PiecesMetalinkParserState.cc
index 43dbba4d..5fa51d79 100644
--- a/src/PiecesMetalinkParserState.cc
+++ b/src/PiecesMetalinkParserState.cc
@@ -37,13 +37,15 @@
 #include "RecoverableException.h"
 #include "Util.h"
 
+namespace aria2 {
+
 void PiecesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					     const string& name,
-					     const map<string, string>& attrs)
+					     const std::string& name,
+					     const std::map<std::string, std::string>& attrs)
 {
   if(name == "hash") {
     stm->setPieceHashState();
-    map<string, string>::const_iterator itr = attrs.find("piece");
+    std::map<std::string, std::string>::const_iterator itr = attrs.find("piece");
     if(itr == attrs.end()) {
       stm->cancelChunkChecksumTransaction();
     } else {
@@ -60,9 +62,11 @@ void PiecesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void PiecesMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					   const string& name,
-					   const string& characters)
+					   const std::string& name,
+					   const std::string& characters)
 {
   stm->commitChunkChecksumTransaction();
   stm->setVerificationState();
 }
+
+} // namespace aria2
diff --git a/src/PiecesMetalinkParserState.h b/src/PiecesMetalinkParserState.h
index 548275b4..68e16e30 100644
--- a/src/PiecesMetalinkParserState.h
+++ b/src/PiecesMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class PiecesMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_PIECES_METALINK_PARSER_STATE_H_
diff --git a/src/PostDownloadHandler.h b/src/PostDownloadHandler.h
index 824f7379..7e6c8fb5 100644
--- a/src/PostDownloadHandler.h
+++ b/src/PostDownloadHandler.h
@@ -37,8 +37,7 @@
 
 #include "DownloadHandler.h"
 
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
+namespace aria2 {
 
 class PostDownloadHandler:public DownloadHandler
 {
@@ -47,9 +46,13 @@ public:
 
   virtual ~PostDownloadHandler() {}
 
-  virtual RequestGroups getNextRequestGroups(RequestGroup* requestGroup) = 0;
+  virtual std::deque<SharedHandle<RequestGroup> >
+  getNextRequestGroups(RequestGroup* requestGroup) = 0;
 };
 
 typedef SharedHandle<PostDownloadHandler> PostDownloadHandlerHandle;
-typedef deque<PostDownloadHandlerHandle> PostDownloadHandlers;
+typedef std::deque<PostDownloadHandlerHandle> PostDownloadHandlers;
+
+} // namespace aria2
+
 #endif // _D_POST_DOWNLOAD_HANDLER_H_
diff --git a/src/PreDownloadHandler.h b/src/PreDownloadHandler.h
index 082a59e6..636ac5e9 100644
--- a/src/PreDownloadHandler.h
+++ b/src/PreDownloadHandler.h
@@ -37,6 +37,8 @@
 
 #include "DownloadHandler.h"
 
+namespace aria2 {
+
 class PreDownloadHandler:public DownloadHandler
 {
 public:
@@ -48,5 +50,8 @@ public:
 };
 
 typedef SharedHandle<PreDownloadHandler> PreDownloadHandlerHandle;
-typedef deque<PreDownloadHandlerHandle> PreDownloadHandlers;
+typedef std::deque<PreDownloadHandlerHandle> PreDownloadHandlers;
+
+} // namespace aria2
+
 #endif // _D_PRE_DOWNLOAD_HANDLER_H_
diff --git a/src/ProgressAwareEntry.h b/src/ProgressAwareEntry.h
index af306ae6..ea2d257e 100644
--- a/src/ProgressAwareEntry.h
+++ b/src/ProgressAwareEntry.h
@@ -36,6 +36,10 @@
 #define _D_PROGRESS_AWARE_ENTRY_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+
+namespace aria2 {
 
 class ProgressAwareEntry {
 public:
@@ -50,4 +54,6 @@ public:
 
 typedef SharedHandle<ProgressAwareEntry> ProgressAwareEntryHandle;
 
+} // namespace aria2
+
 #endif // _D_PROGRESS_AWARE_ENTRY_H_
diff --git a/src/Randomizer.h b/src/Randomizer.h
index f4c37f42..88d4953a 100644
--- a/src/Randomizer.h
+++ b/src/Randomizer.h
@@ -36,6 +36,9 @@
 #define _D_RANDOMIZER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class Randomizer {
 public:
@@ -52,4 +55,7 @@ public:
 };
 
 typedef SharedHandle<Randomizer> RandomizerHandle;
+
+} // namespace aria2
+
 #endif // _D_RANDOMIZER_H_
diff --git a/src/Range.h b/src/Range.h
index ccc6cc39..5c828834 100644
--- a/src/Range.h
+++ b/src/Range.h
@@ -36,6 +36,10 @@
 #define _D_RANGE_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+
+namespace aria2 {
 
 class Range {
 private:
@@ -87,4 +91,6 @@ public:
 
 typedef SharedHandle<Range> RangeHandle;
 
+} // namespace aria2
+
 #endif // _D_RANGE_H_
diff --git a/src/RealtimeCommand.cc b/src/RealtimeCommand.cc
index 850b2cfe..2cdecbe4 100644
--- a/src/RealtimeCommand.cc
+++ b/src/RealtimeCommand.cc
@@ -33,6 +33,10 @@
  */
 /* copyright --> */
 #include "RealtimeCommand.h"
+#include "DownloadEngine.h"
+#include "Exception.h"
+
+namespace aria2 {
 
 bool RealtimeCommand::execute()
 {
@@ -46,3 +50,5 @@ bool RealtimeCommand::execute()
     return r;
   }
 }
+
+} // namespace aria2
diff --git a/src/RealtimeCommand.h b/src/RealtimeCommand.h
index 203c0eeb..fd9269ad 100644
--- a/src/RealtimeCommand.h
+++ b/src/RealtimeCommand.h
@@ -35,12 +35,14 @@
 #ifndef _D_REALTIME_COMMAND_H_
 #define _D_REALTIME_COMMAND_H_
 
-#include "common.h"
-#include "RequestGroup.h"
-#include "DownloadEngine.h"
-#include "Exception.h"
+#include "Command.h"
 #include "RequestGroupAware.h"
 
+namespace aria2 {
+
+class DownloadEngine;
+class Exception;
+
 class RealtimeCommand : public Command, public RequestGroupAware {
 protected:
   DownloadEngine* _e;
@@ -60,4 +62,6 @@ public:
   virtual bool handleException(Exception* e) = 0;
 };
 
+} // namespace aria2
+
 #endif // _D_REALTIME_COMMAND_H_
diff --git a/src/RecoverableException.h b/src/RecoverableException.h
index ed644b85..5345d691 100644
--- a/src/RecoverableException.h
+++ b/src/RecoverableException.h
@@ -36,6 +36,8 @@
 #define _D_RECOVERABLE_EXCEPTION_H_
 #include "Exception.h"
 
+namespace aria2 {
+
 class RecoverableException : public Exception {
 public:
   RecoverableException(Exception* cause = 0):Exception(cause) {}
@@ -43,16 +45,18 @@ public:
   RecoverableException(const char* msg, ...):Exception() {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 
   RecoverableException(Exception* cause, const char* msg, ...):Exception(cause) {
     va_list ap;
     va_start(ap, msg);
-    setMsg(string(msg), ap);
+    setMsg(msg, ap);
     va_end(ap);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_RECOVERABLE_EXCEPTION_EX_H_
diff --git a/src/Request.cc b/src/Request.cc
index c913ea90..eb07b8f8 100644
--- a/src/Request.cc
+++ b/src/Request.cc
@@ -36,18 +36,22 @@
 #include "Util.h"
 #include "FeatureConfig.h"
 #include "CookieBoxFactory.h"
+#include "CookieBox.h"
 #include "RecoverableException.h"
+#include <utility>
 
-const string Request::METHOD_GET = "get";
+namespace aria2 {
 
-const string Request::METHOD_HEAD = "head";
+const std::string Request::METHOD_GET = "get";
+
+const std::string Request::METHOD_HEAD = "head";
 
 Request::Request():port(0), tryCount(0), keepAlive(false), method(METHOD_GET),
 		   cookieBox(CookieBoxFactorySingletonHolder::instance()->createNewInstance()) {}
 
 Request::~Request() {}
 
-bool Request::setUrl(const string& url) {
+bool Request::setUrl(const std::string& url) {
   this->url = url;
   return parseUrl(url);
 }
@@ -57,22 +61,22 @@ bool Request::resetUrl() {
   return setUrl(url);
 }
 
-bool Request::redirectUrl(const string& url) {
+bool Request::redirectUrl(const std::string& url) {
   previousUrl = "";
   keepAlive = false;
   return parseUrl(url);
 }
 
-bool Request::parseUrl(const string& url) {
-  string tempUrl;
-  string::size_type sharpIndex = url.find("#");
-  if(sharpIndex != string::npos) {
+bool Request::parseUrl(const std::string& url) {
+  std::string tempUrl;
+  std::string::size_type sharpIndex = url.find("#");
+  if(sharpIndex != std::string::npos) {
     tempUrl = urlencode(url.substr(0, sharpIndex));
   } else {
     tempUrl = urlencode(url);
   }
   currentUrl = tempUrl;
-  string query;
+  std::string query;
   host = "";
   port = 0;
   dir = "";
@@ -80,14 +84,14 @@ bool Request::parseUrl(const string& url) {
   _username = "";
   _password = "";
   // find query part
-  string::size_type startQueryIndex = tempUrl.find("?");
-  if(startQueryIndex != string::npos) {
+  std::string::size_type startQueryIndex = tempUrl.find("?");
+  if(startQueryIndex != std::string::npos) {
     query = tempUrl.substr(startQueryIndex);
     tempUrl.erase(startQueryIndex);
   }
   // find protocol
-  string::size_type hp = tempUrl.find("://");
-  if(hp == string::npos) return false;
+  std::string::size_type hp = tempUrl.find("://");
+  if(hp == std::string::npos) return false;
   protocol = tempUrl.substr(0, hp);
   int32_t defPort;
   if((defPort = FeatureConfig::getInstance()->getDefaultPort(protocol)) == 0) {
@@ -96,21 +100,21 @@ bool Request::parseUrl(const string& url) {
   hp += 3;
   // find host part
   if(tempUrl.size() <= hp) return false;
-  string::size_type hep = tempUrl.find("/", hp);
-  if(hep == string::npos) {
+  std::string::size_type hep = tempUrl.find("/", hp);
+  if(hep == std::string::npos) {
     hep = tempUrl.size();
   }
-  string hostPart = tempUrl.substr(hp, hep-hp);
+  std::string hostPart = tempUrl.substr(hp, hep-hp);
   //   find username and password in host part if they exist
-  string::size_type atmarkp =  hostPart.find_last_of("@");
-  if(atmarkp != string::npos) {
-    string authPart = hostPart.substr(0, atmarkp);
-    pair<string, string> userPass = Util::split(authPart, ":");
+  std::string::size_type atmarkp =  hostPart.find_last_of("@");
+  if(atmarkp != std::string::npos) {
+    std::string authPart = hostPart.substr(0, atmarkp);
+    std::pair<std::string, std::string> userPass = Util::split(authPart, ":");
     _username = Util::urldecode(userPass.first);
     _password = Util::urldecode(userPass.second);
     hostPart.erase(0, atmarkp+1);
   }
-  pair<string, string> hostAndPort;
+  std::pair<std::string, std::string> hostAndPort;
   Util::split(hostAndPort, hostPart, ':');
   host = hostAndPort.first;
   if(hostAndPort.second != "") {
@@ -128,18 +132,18 @@ bool Request::parseUrl(const string& url) {
     port = defPort;
   }
   // find directory and file part
-  string::size_type direp = tempUrl.find_last_of("/");
-  if(direp == string::npos || direp <= hep) {
+  std::string::size_type direp = tempUrl.find_last_of("/");
+  if(direp == std::string::npos || direp <= hep) {
     dir = "/";
     direp = hep;
   } else {
-    string rawDir = tempUrl.substr(hep, direp-hep);
-    string::size_type p = rawDir.find_first_not_of("/");
-    if(p != string::npos) {
+    std::string rawDir = tempUrl.substr(hep, direp-hep);
+    std::string::size_type p = rawDir.find_first_not_of("/");
+    if(p != std::string::npos) {
       rawDir.erase(0, p-1);
     }
     p = rawDir.find_last_not_of("/");
-    if(p != string::npos) {
+    if(p != std::string::npos) {
       rawDir.erase(p+1);
     }
     dir = rawDir;
@@ -156,10 +160,10 @@ bool Request::isHexNumber(const char c) const
   return '0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f';
 }
 
-string Request::urlencode(const string& src) const
+std::string Request::urlencode(const std::string& src) const
 {
   int32_t lastIndex = src.size()-1;
-  string result = src+"  ";
+  std::string result = src+"  ";
   for(int32_t index = lastIndex; index >= 0; --index) {
     const char c = result[index];
     // '/' is not urlencoded because src is expected to be a path.
@@ -178,3 +182,5 @@ string Request::urlencode(const string& src) const
   }
   return result.substr(0, result.size()-2);
 }
+
+} // namespace aria2
diff --git a/src/Request.h b/src/Request.h
index facbc022..2576420a 100644
--- a/src/Request.h
+++ b/src/Request.h
@@ -35,7 +35,9 @@
 #ifndef _D_REQUEST_H_
 #define _D_REQUEST_H_
 #include "common.h"
-#include "CookieBox.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
 
 #define SAFE_CHARS "abcdefghijklmnopqrstuvwxyz"\
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"\
@@ -46,6 +48,10 @@
 "%"\
 "#"
 
+namespace aria2 {
+
+class CookieBox;
+
 class Request {
 public:
   enum TRACKER_EVENT {
@@ -56,95 +62,97 @@ public:
     AFTER_COMPLETED
   };
 private:
-  string url;
-  string currentUrl;
+  std::string url;
+  std::string currentUrl;
   /**
    * URL previously requested to the server. This is used as Referer
    */
-  string previousUrl;
+  std::string previousUrl;
   /**
    * URL used as Referer in the initial request
    */
-  string referer;
-  string protocol;
-  string host;
+  std::string referer;
+  std::string protocol;
+  std::string host;
   int32_t port;
-  string dir;
-  string file;
+  std::string dir;
+  std::string file;
   int32_t tryCount;
   TRACKER_EVENT trackerEvent;
   bool keepAlive;
-  string method;
+  std::string method;
 
-  string _username;
+  std::string _username;
 
-  string _password;
+  std::string _password;
 
-  bool parseUrl(const string& url);
+  bool parseUrl(const std::string& url);
 
   bool isHexNumber(const char c) const;
 
-  string urlencode(const string& src) const;
+  std::string urlencode(const std::string& src) const;
 
 public:
-  CookieBoxHandle cookieBox;
+  SharedHandle<CookieBox> cookieBox;
 public:
   Request();
   virtual ~Request();
 
   // Parses URL and sets url, host, port, dir, file fields.
   // Returns true if parsing goes successful, otherwise returns false.
-  bool setUrl(const string& url);
+  bool setUrl(const std::string& url);
   // Parses URL and sets host, port, dir, file fields.
   // url field are not altered by this method.
   // Returns true if parsing goes successful, otherwise returns false.
-  bool redirectUrl(const string& url);
+  bool redirectUrl(const std::string& url);
   bool resetUrl();
   void resetTryCount() { tryCount = 0; }
   void addTryCount() { tryCount++; }
   int32_t getTryCount() const { return tryCount; }
   //bool noMoreTry() const { return tryCount >= PREF_MAX_TRY; }
 
-  string getUrl() const { return url; }
-  string getCurrentUrl() const { return currentUrl; }
-  string getPreviousUrl() const { return previousUrl; }
-  string getReferer() const { return referer; }
-  void setReferer(const string& url) { referer = previousUrl = url; }
-  string getProtocol() const { return protocol; }
-  string getHost() const { return host; }
+  std::string getUrl() const { return url; }
+  std::string getCurrentUrl() const { return currentUrl; }
+  std::string getPreviousUrl() const { return previousUrl; }
+  std::string getReferer() const { return referer; }
+  void setReferer(const std::string& url) { referer = previousUrl = url; }
+  std::string getProtocol() const { return protocol; }
+  std::string getHost() const { return host; }
   int32_t getPort() const { return port; }
-  string getDir() const { return dir; }
-  string getFile() const { return file;}
+  std::string getDir() const { return dir; }
+  std::string getFile() const { return file;}
   bool isKeepAlive() const { return keepAlive; }
   void setKeepAlive(bool keepAlive) { this->keepAlive = keepAlive; }
   void setTrackerEvent(TRACKER_EVENT event) { trackerEvent = event; }
   TRACKER_EVENT getTrackerEvent() const { return trackerEvent; }
 
-  void setMethod(const string& method) {
+  void setMethod(const std::string& method) {
     this->method = method;
   }
 
-  const string& getUsername() const
+  const std::string& getUsername() const
   {
     return _username;
   }
 
-  const string& getPassword() const
+  const std::string& getPassword() const
   {
     return _password;
   }
 
-  const string& getMethod() const {
+  const std::string& getMethod() const {
     return method;
   }
 
-  static const string METHOD_GET;
-  static const string METHOD_HEAD;
+  static const std::string METHOD_GET;
+  static const std::string METHOD_HEAD;
 
 };
 
 typedef SharedHandle<Request> RequestHandle;
-typedef deque<RequestHandle> Requests;
 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 ae3d80f7..c352c714 100644
--- a/src/RequestGroup.cc
+++ b/src/RequestGroup.cc
@@ -36,8 +36,8 @@
 #include "PostDownloadHandler.h"
 #include "DownloadEngine.h"
 #include "DefaultSegmentManFactory.h"
+#include "SegmentMan.h"
 #include "NullProgressInfoFile.h"
-#include "SegmentManFactory.h"
 #include "Dependency.h"
 #include "prefs.h"
 #include "InitiateConnectionCommandFactory.h"
@@ -47,12 +47,14 @@
 #include "Util.h"
 #include "BtRegistry.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "DiskAdaptor.h"
 #include "DiskWriterFactory.h"
 #include "RecoverableException.h"
 #include "StreamCheckIntegrityEntry.h"
 #include "CheckIntegrityCommand.h"
 #include "UnknownLengthPieceStorage.h"
+#include "BtContext.h"
 #include "SingleFileDownloadContext.h"
 #include "DlAbortEx.h"
 #include "DownloadFailureException.h"
@@ -64,6 +66,10 @@
 #include "MemoryBufferPreDownloadHandler.h"
 #include "DownloadHandlerConstants.h"
 #include "ServerHost.h"
+#include "Option.h"
+#include "FileEntry.h"
+#include "Request.h"
+#include "FileAllocationIterator.h"
 #ifdef ENABLE_MESSAGE_DIGEST
 # include "CheckIntegrityCommand.h"
 #endif // ENABLE_MESSAGE_DIGEST
@@ -71,21 +77,33 @@
 # include "BtCheckIntegrityEntry.h"
 # include "DefaultPeerStorage.h"
 # include "DefaultBtAnnounce.h"
+# include "BtRuntime.h"
 # include "BtSetup.h"
 # include "BtFileAllocationEntry.h"
 # include "BtPostDownloadHandler.h"
 # include "DHTSetup.h"
 # include "DHTRegistry.h"
+# include "PeerObject.h"
+# include "BtMessageFactory.h"
+# include "BtRequestFactory.h"
+# include "BtMessageDispatcher.h"
+# include "BtMessageReceiver.h"
+# include "PeerConnection.h"
+# include "ExtensionMessageFactory.h"
 # include "DHTPeerAnnounceStorage.h"
 #endif // ENABLE_BITTORRENT
 #ifdef ENABLE_METALINK
 # include "MetalinkPostDownloadHandler.h"
 #endif // ENABLE_METALINK
+#include <cassert>
+#include <algorithm>
+
+namespace aria2 {
 
 int32_t RequestGroup::_gidCounter = 0;
 
 RequestGroup::RequestGroup(const Option* option,
-			   const Strings& uris):
+			   const std::deque<std::string>& uris):
   _gid(++_gidCounter),
   _uris(uris),
   _numConcurrentCommand(0),
@@ -381,7 +399,7 @@ void RequestGroup::shouldCancelDownloadForSafety()
 
 bool RequestGroup::tryAutoFileRenaming()
 {
-  string filepath = getFilePath();
+  std::string filepath = getFilePath();
   if(filepath.empty()) {
     return false;
   }
@@ -401,12 +419,12 @@ Commands RequestGroup::createNextCommandWithAdj(DownloadEngine* e, int32_t numAd
   return createNextCommand(e, numCommand, "GET");
 }
 
-Commands RequestGroup::createNextCommand(DownloadEngine* e, int32_t numCommand, const string& method)
+Commands RequestGroup::createNextCommand(DownloadEngine* e, int32_t numCommand, const std::string& method)
 {
   Commands commands;
-  Strings pendingURIs;
+  std::deque<std::string> pendingURIs;
   for(;!_uris.empty() && numCommand--; _uris.pop_front()) {
-    string uri = _uris.front();
+    std::string uri = _uris.front();
     RequestHandle req = new Request();
     if(req->setUrl(uri)) {
       ServerHostHandle sv = _singleHostMultiConnectionEnabled ? 0 : searchServerHost(req->getHost());
@@ -429,7 +447,7 @@ Commands RequestGroup::createNextCommand(DownloadEngine* e, int32_t numCommand,
   return commands;
 }
 
-string RequestGroup::getFilePath() const
+std::string RequestGroup::getFilePath() const
 {
   assert(!_downloadContext.isNull());
   if(_downloadContext.isNull()) {
@@ -465,8 +483,8 @@ int64_t RequestGroup::getCompletedLength() const
   }
 }
 
-void RequestGroup::validateFilename(const string& expectedFilename,
-				    const string& actualFilename) const
+void RequestGroup::validateFilename(const std::string& expectedFilename,
+				    const std::string& actualFilename) const
 {
   if(expectedFilename.empty()) {
     return;
@@ -491,7 +509,7 @@ void RequestGroup::validateTotalLength(int64_t expectedTotalLength,
   }
 }
 
-void RequestGroup::validateFilename(const string& actualFilename) const
+void RequestGroup::validateFilename(const std::string& actualFilename) const
 {
   validateFilename(_downloadContext->getFileEntries().front()->getBasename(), actualFilename);
 }
@@ -669,9 +687,9 @@ void RequestGroup::initializePostDownloadHandler()
 #endif // ENABLE_METALINK
 }
 
-Strings RequestGroup::getUris() const
+std::deque<std::string> RequestGroup::getUris() const
 {
-  Strings temp(_spentUris.begin(), _spentUris.end());
+  std::deque<std::string> temp(_spentUris.begin(), _spentUris.end());
   temp.insert(temp.end(), _uris.begin(), _uris.end());
   return temp;
 }
@@ -768,7 +786,7 @@ bool RequestGroup::needsFileAllocation() const
 
 DownloadResultHandle RequestGroup::createDownloadResult() const
 {
-  Strings uris = getUris();
+  std::deque<std::string> uris = getUris();
   return new DownloadResult(_gid,
 			    getFilePath(),
 			    getTotalLength(),
@@ -799,9 +817,8 @@ public:
 
 ServerHostHandle RequestGroup::searchServerHost(int32_t cuid) const
 {
-  ServerHosts::const_iterator itr = find_if(_serverHosts.begin(),
-					    _serverHosts.end(),
-					    FindServerHostByCUID(cuid));
+  std::deque<SharedHandle<ServerHost> >::const_iterator itr =
+    std::find_if(_serverHosts.begin(), _serverHosts.end(), FindServerHostByCUID(cuid));
   if(itr == _serverHosts.end()) {
     return 0;
   } else {
@@ -812,9 +829,9 @@ ServerHostHandle RequestGroup::searchServerHost(int32_t cuid) const
 class FindServerHostByHostname
 {
 private:
-  const string& _hostname;
+  const std::string& _hostname;
 public:
-  FindServerHostByHostname(const string& hostname):_hostname(hostname) {}
+  FindServerHostByHostname(const std::string& hostname):_hostname(hostname) {}
 
   bool operator()(const ServerHostHandle& sv) const
   {
@@ -822,11 +839,10 @@ public:
   }
 };
 
-ServerHostHandle RequestGroup::searchServerHost(const string& hostname) const
+ServerHostHandle RequestGroup::searchServerHost(const std::string& hostname) const
 {
-  ServerHosts::const_iterator itr = find_if(_serverHosts.begin(),
-					    _serverHosts.end(),
-					    FindServerHostByHostname(hostname));
+  std::deque<SharedHandle<ServerHost> >::const_iterator itr =
+    std::find_if(_serverHosts.begin(), _serverHosts.end(), FindServerHostByHostname(hostname));
   if(itr == _serverHosts.end()) {
     return 0;
   } else {
@@ -836,15 +852,15 @@ ServerHostHandle RequestGroup::searchServerHost(const string& hostname) const
 
 void RequestGroup::removeServerHost(int32_t cuid)
 {
-  _serverHosts.erase(remove_if(_serverHosts.begin(), _serverHosts.end(), FindServerHostByCUID(cuid)), _serverHosts.end());
+  _serverHosts.erase(std::remove_if(_serverHosts.begin(), _serverHosts.end(), FindServerHostByCUID(cuid)), _serverHosts.end());
 }
   
-void RequestGroup::removeURIWhoseHostnameIs(const string& hostname)
+void RequestGroup::removeURIWhoseHostnameIs(const std::string& hostname)
 {
-  Strings newURIs;
+  std::deque<std::string> newURIs;
   Request req;
-  for(Strings::const_iterator itr = _uris.begin(); itr != _uris.end(); ++itr) {
-    if((*itr).find(hostname) == string::npos ||
+  for(std::deque<std::string>::const_iterator itr = _uris.begin(); itr != _uris.end(); ++itr) {
+    if((*itr).find(hostname) == std::string::npos ||
        req.setUrl(*itr) && req.getHost() != hostname) {
       newURIs.push_back(*itr);
     }
@@ -869,3 +885,5 @@ void RequestGroup::reportDownloadFinished()
   }
 #endif // ENABLE_BITTORRENT
 }
+
+} // namespace aria2
diff --git a/src/RequestGroup.h b/src/RequestGroup.h
index 7b4451cb..72f3e5ed 100644
--- a/src/RequestGroup.h
+++ b/src/RequestGroup.h
@@ -36,44 +36,30 @@
 #define _D_REQUEST_GROUP_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "TransferStat.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class DownloadEngine;
 class SegmentMan;
-typedef SharedHandle<SegmentMan> SegmentManHandle;
 class SegmentManFactory;
-typedef SharedHandle<SegmentManFactory> SegmentManFactoryHandle;
 class Command;
-typedef deque<Command*> Commands;
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class PieceStorage;
-typedef SharedHandle<PieceStorage> PieceStorageHandle;
 class BtProgressInfoFile;
-typedef SharedHandle<BtProgressInfoFile> BtProgressInfoFileHandle;
 class Dependency;
-typedef SharedHandle<Dependency> DependencyHandle;
-class DlAbortEx;
 class PreDownloadHandler;
-typedef SharedHandle<PreDownloadHandler> PreDownloadHandlerHandle;
-typedef deque<PreDownloadHandlerHandle> PreDownloadHandlers;
 class PostDownloadHandler;
-typedef SharedHandle<PostDownloadHandler> PostDownloadHandlerHandle;
-typedef deque<PostDownloadHandlerHandle> PostDownloadHandlers;
 class DiskWriterFactory;
-typedef SharedHandle<DiskWriterFactory> DiskWriterFactoryHandle;
 class Option;
 class Logger;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class CheckIntegrityEntry;
-typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
 class DownloadResult;
-typedef SharedHandle<DownloadResult> DownloadResultHandle;
 class ServerHost;
-typedef SharedHandle<ServerHost> ServerHostHandle;
-typedef deque<ServerHostHandle> ServerHosts;
 
 class RequestGroup {
 private:
@@ -81,8 +67,8 @@ private:
 
   int32_t _gid;
 
-  Strings _uris;
-  Strings _spentUris;
+  std::deque<std::string> _uris;
+  std::deque<std::string> _spentUris;
 
   int32_t _numConcurrentCommand;
 
@@ -93,20 +79,20 @@ private:
 
   int32_t _numCommand;
 
-  SegmentManHandle _segmentMan;
-  SegmentManFactoryHandle _segmentManFactory;
+  SharedHandle<SegmentMan> _segmentMan;
+  SharedHandle<SegmentManFactory> _segmentManFactory;
 
-  DownloadContextHandle _downloadContext;
+  SharedHandle<DownloadContext> _downloadContext;
 
-  PieceStorageHandle _pieceStorage;
+  SharedHandle<PieceStorage> _pieceStorage;
 
-  BtProgressInfoFileHandle _progressInfoFile;
+  SharedHandle<BtProgressInfoFile> _progressInfoFile;
 
-  DiskWriterFactoryHandle _diskWriterFactory;
+  SharedHandle<DiskWriterFactory> _diskWriterFactory;
 
-  DependencyHandle _dependency;
+  SharedHandle<Dependency> _dependency;
 
-  ServerHosts _serverHosts;
+  std::deque<SharedHandle<ServerHost> > _serverHosts;
 
   bool _fileAllocationEnabled;
 
@@ -118,16 +104,16 @@ private:
 
   bool _singleHostMultiConnectionEnabled;
 
-  PreDownloadHandlers _preDownloadHandlers;
+  std::deque<SharedHandle<PreDownloadHandler> > _preDownloadHandlers;
 
-  PostDownloadHandlers _postDownloadHandlers;
+  std::deque<SharedHandle<PostDownloadHandler> > _postDownloadHandlers;
 
   const Option* _option;
 
   const Logger* _logger;
 
-  void validateFilename(const string& expectedFilename,
-			const string& actualFilename) const;
+  void validateFilename(const std::string& expectedFilename,
+			const std::string& actualFilename) const;
 
   void validateTotalLength(int64_t expectedTotalLength,
 			   int64_t actualTotalLength) const;
@@ -139,24 +125,24 @@ private:
   bool tryAutoFileRenaming();
 
 public:
-  RequestGroup(const Option* option, const Strings& uris);
+  RequestGroup(const Option* option, const std::deque<std::string>& uris);
 
   ~RequestGroup();
   /**
    * Reinitializes SegmentMan based on current property values and
    * returns new one.
    */
-  SegmentManHandle initSegmentMan();
+  SharedHandle<SegmentMan> initSegmentMan();
 
-  SegmentManHandle getSegmentMan() const;
+  SharedHandle<SegmentMan> getSegmentMan() const;
 
-  Commands createInitialCommand(DownloadEngine* e);
+  std::deque<Command*> createInitialCommand(DownloadEngine* e);
 
-  Commands createNextCommandWithAdj(DownloadEngine* e, int32_t numAdj);
+  std::deque<Command*> createNextCommandWithAdj(DownloadEngine* e, int32_t numAdj);
 
-  Commands createNextCommand(DownloadEngine* e, int32_t numCommand, const string& method = "GET");
+  std::deque<Command*> createNextCommand(DownloadEngine* e, int32_t numCommand, const std::string& method = "GET");
   
-  void addURI(const string& uri)
+  void addURI(const std::string& uri)
   {
     _uris.push_back(uri);
   }
@@ -167,36 +153,36 @@ public:
 
   void closeFile();
 
-  string getFilePath() const;
+  std::string getFilePath() const;
 
-  string getDir() const;
+  std::string getDir() const;
 
   int64_t getTotalLength() const;
 
   int64_t getCompletedLength() const;
 
-  const Strings& getRemainingUris() const
+  const std::deque<std::string>& getRemainingUris() const
   {
     return _uris;
   }
 
-  const Strings& getSpentUris() const
+  const std::deque<std::string>& getSpentUris() const
   {
     return _spentUris;
   }
 
-  Strings getUris() const;
+  std::deque<std::string> getUris() const;
 
   /**
    * Compares expected filename with specified actualFilename.
    * The expected filename refers to FileEntry::getBasename() of the first
    * element of DownloadContext::getFileEntries()
    */
-  void validateFilename(const string& actualFilename) const;
+  void validateFilename(const std::string& actualFilename) const;
 
   void validateTotalLength(int64_t actualTotalLength) const;
 
-  void setSegmentManFactory(const SegmentManFactoryHandle& segmentManFactory);
+  void setSegmentManFactory(const SharedHandle<SegmentManFactory>& segmentManFactory);
 
   void setNumConcurrentCommand(int32_t num)
   {
@@ -210,17 +196,17 @@ public:
 
   TransferStat calculateStat();
 
-  DownloadContextHandle getDownloadContext() const;
+  SharedHandle<DownloadContext> getDownloadContext() const;
 
-  void setDownloadContext(const DownloadContextHandle& downloadContext);
+  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
 
-  PieceStorageHandle getPieceStorage() const;
+  SharedHandle<PieceStorage> getPieceStorage() const;
 
-  void setPieceStorage(const PieceStorageHandle& pieceStorage);
+  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
 
-  BtProgressInfoFileHandle getProgressInfoFile() const;
+  SharedHandle<BtProgressInfoFile> getProgressInfoFile() const;
 
-  void setProgressInfoFile(const BtProgressInfoFileHandle& progressInfoFile);
+  void setProgressInfoFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
 
   void increaseStreamConnection();
 
@@ -238,9 +224,9 @@ public:
   }
 
   // TODO is it better to move the following 2 methods to SingleFileDownloadContext?
-  void setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory);
+  void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
 
-  DiskWriterFactoryHandle getDiskWriterFactory() const;
+  SharedHandle<DiskWriterFactory> getDiskWriterFactory() const;
 
   void setFileAllocationEnabled(bool f)
   {
@@ -283,35 +269,37 @@ public:
     return _forceHaltRequested;
   }
 
-  void dependsOn(const DependencyHandle& dep);
+  void dependsOn(const SharedHandle<Dependency>& dep);
 
   bool isDependencyResolved();
 
   void releaseRuntimeResource();
 
-  RequestGroups postDownloadProcessing();
+  std::deque<SharedHandle<RequestGroup> > postDownloadProcessing();
 
-  void addPostDownloadHandler(const PostDownloadHandlerHandle& handler);
+  void addPostDownloadHandler(const SharedHandle<PostDownloadHandler>& handler);
 
   void clearPostDowloadHandler();
 
   void preDownloadProcessing();
 
-  void addPreDownloadHandler(const PreDownloadHandlerHandle& handler);
+  void addPreDownloadHandler(const SharedHandle<PreDownloadHandler>& handler);
 
   void clearPreDowloadHandler();
 
-  Commands processCheckIntegrityEntry(const CheckIntegrityEntryHandle& entry, DownloadEngine* e);
+  std::deque<Command*>
+  processCheckIntegrityEntry(const SharedHandle<CheckIntegrityEntry>& entry,
+			     DownloadEngine* e);
 
   void initPieceStorage();
 
   bool downloadFinishedByFileLength();
 
-  void loadAndOpenFile(const BtProgressInfoFileHandle& progressInfoFile);
+  void loadAndOpenFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
 
   void shouldCancelDownloadForSafety();
 
-  DownloadResultHandle createDownloadResult() const;
+  SharedHandle<DownloadResult> createDownloadResult() const;
 
   const Option* getOption() const
   {
@@ -331,25 +319,27 @@ public:
   /**
    * Registers given ServerHost.
    */
-  void registerServerHost(const ServerHostHandle& serverHost);
+  void registerServerHost(const SharedHandle<ServerHost>& serverHost);
 
   /**
    * Returns ServerHost whose cuid is given cuid. If it is not found, returns
    * 0.
    */
-  ServerHostHandle searchServerHost(int32_t cuid) const;
+  SharedHandle<ServerHost> searchServerHost(int32_t cuid) const;
 
-  ServerHostHandle searchServerHost(const string& hostname) const;
+  SharedHandle<ServerHost> searchServerHost(const std::string& hostname) const;
 
   void removeServerHost(int32_t cuid);
   
-  void removeURIWhoseHostnameIs(const string& hostname);
+  void removeURIWhoseHostnameIs(const std::string& hostname);
 
   void reportDownloadFinished();
 };
 
 typedef SharedHandle<RequestGroup> RequestGroupHandle;
 typedef WeakHandle<RequestGroup> RequestGroupWeakHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
+typedef std::deque<RequestGroupHandle> RequestGroups;
+
+} // namespace aria2
 
 #endif // _D_REQUEST_GROUP_H_
diff --git a/src/RequestGroupAware.cc b/src/RequestGroupAware.cc
index 940adf0e..4ac77d24 100644
--- a/src/RequestGroupAware.cc
+++ b/src/RequestGroupAware.cc
@@ -35,6 +35,8 @@
 #include "RequestGroupAware.h"
 #include "RequestGroup.h"
 
+namespace aria2 {
+
 RequestGroupAware::RequestGroupAware(RequestGroup* requestGroup):
   _requestGroup(requestGroup)
 {
@@ -50,3 +52,5 @@ RequestGroup* RequestGroupAware::getRequestGroup() const
 {
   return _requestGroup;
 }
+
+} // namespace aria2
diff --git a/src/RequestGroupAware.h b/src/RequestGroupAware.h
index 580a4fc9..67c407f2 100644
--- a/src/RequestGroupAware.h
+++ b/src/RequestGroupAware.h
@@ -37,6 +37,8 @@
 
 #include "common.h"
 
+namespace aria2 {
+
 class RequestGroup;
 
 class RequestGroupAware {
@@ -50,4 +52,6 @@ public:
   RequestGroup* getRequestGroup() const;
 };
 
+} // namespace aria2
+
 #endif // _D_REQUEST_GROUP_AWARE_H_
diff --git a/src/RequestGroupCriteria.h b/src/RequestGroupCriteria.h
index 5e193fef..ba7c52ff 100644
--- a/src/RequestGroupCriteria.h
+++ b/src/RequestGroupCriteria.h
@@ -36,6 +36,9 @@
 #define _D_REQUEST_GROUP_CRITERIA_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class RequestGroup;
 
@@ -49,4 +52,6 @@ public:
 
 typedef SharedHandle<RequestGroupCriteria> RequestGroupCriteriaHandle;
 
+} // namespace aria2
+
 #endif // _D_REQUEST_GROUP_CRITERIA_H_
diff --git a/src/RequestGroupEntry.cc b/src/RequestGroupEntry.cc
index cd17e043..01dd9b15 100644
--- a/src/RequestGroupEntry.cc
+++ b/src/RequestGroupEntry.cc
@@ -36,6 +36,8 @@
 #include "RequestGroup.h"
 #include "Command.h"
 
+namespace aria2 {
+
 RequestGroupEntry::RequestGroupEntry(RequestGroup* requestGroup,
 				     Command* nextCommand):
   _requestGroup(requestGroup),
@@ -56,3 +58,5 @@ Command* RequestGroupEntry::popNextCommand()
   _nextCommand = 0;
   return temp;
 }
+
+} // namespace aria2
diff --git a/src/RequestGroupEntry.h b/src/RequestGroupEntry.h
index 812720f7..8396da09 100644
--- a/src/RequestGroupEntry.h
+++ b/src/RequestGroupEntry.h
@@ -35,11 +35,13 @@
 #ifndef _D_REQUEST_GROUP_ENTRY_H_
 #define _D_REQUEST_GROUP_ENTRY_H_
 
-#include "ProgressAwareEntry.h"
+#include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class RequestGroup;
 class Command;
-class DownloadCommand;
 
 class RequestGroupEntry {
 protected:
@@ -70,4 +72,7 @@ public:
 };
 
 typedef SharedHandle<RequestGroupEntry> RequestGroupEntryHandle;
+
+} // namespace aria2
+
 #endif // _D_REQUEST_GROUP_ENTRY_H_
diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc
index a52e8bdf..c49b2168 100644
--- a/src/RequestGroupMan.cc
+++ b/src/RequestGroupMan.cc
@@ -37,6 +37,7 @@
 #include "RecoverableException.h"
 #include "RequestGroup.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "DownloadEngine.h"
 #include "message.h"
 #include "a2functional.h"
@@ -45,6 +46,8 @@
 #include <sstream>
 #include <numeric>
 
+namespace aria2 {
+
 RequestGroupMan::RequestGroupMan(const RequestGroups& requestGroups,
 				 int32_t maxSimultaneousDownloads):
   _requestGroups(requestGroups),
@@ -215,7 +218,7 @@ void RequestGroupMan::closeFile()
   }
 }
 
-void RequestGroupMan::showDownloadResults(ostream& o) const
+void RequestGroupMan::showDownloadResults(std::ostream& o) const
 {
   // Download Results:
   // idx|stat|path/length
@@ -224,15 +227,15 @@ void RequestGroupMan::showDownloadResults(ostream& o) const
     <<_("Download Results:") << "\n"
     << "gid|stat|path/URI" << "\n"
     << "===+====+======================================================================" << "\n";
-  for(DownloadResults::const_iterator itr = _downloadResults.begin();
+  for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr = _downloadResults.begin();
       itr != _downloadResults.end(); ++itr) {
-    string status = (*itr)->result == DownloadResult::FINISHED ? "OK" : "ERR";
+    std::string status = (*itr)->result == DownloadResult::FINISHED ? "OK" : "ERR";
     o << formatDownloadResult(status, *itr) << "\n";
   }
   for(RequestGroups::const_iterator itr = _requestGroups.begin();
       itr != _requestGroups.end(); ++itr) {
     DownloadResultHandle result = (*itr)->createDownloadResult();
-    string status = result->result == DownloadResult::FINISHED ? "OK" : "INPR";
+    std::string status = result->result == DownloadResult::FINISHED ? "OK" : "INPR";
     o << formatDownloadResult(status, result) << "\n";
   }
   o << "\n"
@@ -240,11 +243,11 @@ void RequestGroupMan::showDownloadResults(ostream& o) const
     << " (OK):download completed.(ERR):error occurred.(INPR):download in-progress." << "\n";
 }
 
-string RequestGroupMan::formatDownloadResult(const string& status, const DownloadResultHandle& downloadResult) const
+std::string RequestGroupMan::formatDownloadResult(const std::string& status, const DownloadResultHandle& downloadResult) const
 {
-  stringstream o;
-  o << setw(3) << downloadResult->gid << "|"
-    << setw(4) << status << "|";
+  std::stringstream o;
+  o << std::setw(3) << downloadResult->gid << "|"
+    << std::setw(4) << status << "|";
   if(downloadResult->result == DownloadResult::FINISHED) {
     o << downloadResult->filePath;
   } else {
@@ -298,6 +301,8 @@ void RequestGroupMan::forceHalt()
 
 TransferStat RequestGroupMan::calculateStat()
 {
-  return accumulate(_requestGroups.begin(), _requestGroups.end(), TransferStat(),
-		    adopt2nd(plus<TransferStat>(), mem_fun_sh(&RequestGroup::calculateStat)));
+  return std::accumulate(_requestGroups.begin(), _requestGroups.end(), TransferStat(),
+			 adopt2nd(std::plus<TransferStat>(), mem_fun_sh(&RequestGroup::calculateStat)));
 }
+
+} // namespace aria2
diff --git a/src/RequestGroupMan.h b/src/RequestGroupMan.h
index 3b8e2662..a58ca909 100644
--- a/src/RequestGroupMan.h
+++ b/src/RequestGroupMan.h
@@ -36,33 +36,36 @@
 #define _D_REQUEST_GROUP_MAN_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "TransferStat.h"
+#include <string>
+#include <deque>
+#include <iosfwd>
+
+namespace aria2 {
 
 class DownloadEngine;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
-typedef deque<RequestGroupHandle> RequestGroups;
 class Command;
-typedef deque<Command*> Commands;
 class Logger;
 class DownloadResult;
-typedef SharedHandle<DownloadResult> DownloadResultHandle;
-typedef deque<DownloadResultHandle> DownloadResults;
 
 class RequestGroupMan {
 private:
-  RequestGroups _requestGroups;
-  RequestGroups _reservedGroups;
-  DownloadResults _downloadResults;
+  std::deque<SharedHandle<RequestGroup> > _requestGroups;
+  std::deque<SharedHandle<RequestGroup> > _reservedGroups;
+  std::deque<SharedHandle<DownloadResult> > _downloadResults;
   const Logger* _logger;
   int32_t _maxSimultaneousDownloads;
   int32_t _gidCounter;
 
-  string formatDownloadResult(const string& status,
-			      const DownloadResultHandle& downloadResult) const;
+  std::string
+  formatDownloadResult(const std::string& status,
+		       const SharedHandle<DownloadResult>& downloadResult) const;
 
 public:
-  RequestGroupMan(const RequestGroups& requestGroups, int32_t maxSimultaneousDownloads = 1);
+  RequestGroupMan(const std::deque<SharedHandle<RequestGroup> >& requestGroups,
+		  int32_t maxSimultaneousDownloads = 1);
 
   bool downloadFinished();
 
@@ -74,23 +77,23 @@ public:
 
   void forceHalt();
 
-  Commands getInitialCommands(DownloadEngine* e);
+  std::deque<Command*> getInitialCommands(DownloadEngine* e);
 
   void removeStoppedGroup();
 
   void fillRequestGroupFromReserver(DownloadEngine* e);
 
-  void addRequestGroup(const RequestGroupHandle& group);
+  void addRequestGroup(const SharedHandle<RequestGroup>& group);
 
-  void addReservedGroup(const RequestGroups& groups);
+  void addReservedGroup(const std::deque<SharedHandle<RequestGroup> >& groups);
 
-  void addReservedGroup(const RequestGroupHandle& group);
+  void addReservedGroup(const SharedHandle<RequestGroup>& group);
 
   int32_t countRequestGroup() const;
 		  
-  RequestGroupHandle getRequestGroup(int32_t index) const;
+  SharedHandle<RequestGroup> getRequestGroup(int32_t index) const;
 		  
-  void showDownloadResults(ostream& o) const;
+  void showDownloadResults(std::ostream& o) const;
 
   bool isSameFileBeingDownloaded(RequestGroup* requestGroup) const;
 
@@ -99,4 +102,6 @@ public:
 
 typedef SharedHandle<RequestGroupMan> RequestGroupManHandle;
 
+} // namespace aria2
+
 #endif // _D_REQUEST_GROUP_MAN_H_
diff --git a/src/RequestSlot.cc b/src/RequestSlot.cc
index bba41f5a..2ec1437b 100644
--- a/src/RequestSlot.cc
+++ b/src/RequestSlot.cc
@@ -35,6 +35,10 @@
 #include "RequestSlot.h"
 #include "Util.h"
 
+namespace aria2 {
+
+RequestSlot RequestSlot::nullSlot(0, 0, 0, 0);
+
 RequestSlot::RequestSlot(int32_t index, int32_t begin, int32_t length, int32_t blockIndex)
   :index(index), begin(begin), length(length), blockIndex(blockIndex) {}
 
@@ -50,7 +54,20 @@ void RequestSlot::copy(const RequestSlot& requestSlot) {
   dispatchedTime = requestSlot.dispatchedTime;
 }
 
-RequestSlot RequestSlot::nullSlot(0, 0, 0, 0);
+RequestSlot& RequestSlot::operator=(const RequestSlot& requestSlot)
+{
+  if(this != &requestSlot) {
+    copy(requestSlot);
+  }
+  return *this;
+}
+
+bool RequestSlot::operator==(const RequestSlot& requestSlot) const
+{
+  return index == requestSlot.index &&
+    begin == requestSlot.begin &&
+    length == requestSlot.length;
+}
 
 void RequestSlot::setDispatchedTime() {
   dispatchedTime.reset();
@@ -72,3 +89,5 @@ bool RequestSlot::isNull(const RequestSlot& requestSlot) {
   return requestSlot.index == 0 && requestSlot.begin == 0&&
     requestSlot.length == 0;
 }
+
+} // namespace aria2
diff --git a/src/RequestSlot.h b/src/RequestSlot.h
index aaa2c307..5a3b6a0e 100644
--- a/src/RequestSlot.h
+++ b/src/RequestSlot.h
@@ -37,6 +37,9 @@
 
 #include "common.h"
 #include "TimeA2.h"
+#include <deque>
+
+namespace aria2 {
 
 class RequestSlot {
 private:
@@ -49,20 +52,12 @@ private:
 public:
   RequestSlot(int32_t index, int32_t begin, int32_t length, int32_t blockIndex);
   RequestSlot(const RequestSlot& requestSlot);
+
   ~RequestSlot() {}
 
-  RequestSlot& operator=(const RequestSlot& requestSlot) {
-    if(this != &requestSlot) {
-      copy(requestSlot);
-    }
-    return *this;
-  }
+  RequestSlot& operator=(const RequestSlot& requestSlot);
 
-  bool operator==(const RequestSlot& requestSlot) const {
-    return index == requestSlot.index &&
-      begin == requestSlot.begin &&
-      length == requestSlot.length;
-  }
+  bool operator==(const RequestSlot& requestSlot) const;
 
   void setDispatchedTime();
   void setDispatchedTime(time_t secFromEpoch);
@@ -87,6 +82,8 @@ public:
   static bool isNull(const RequestSlot& requestSlot);
 };
 
-typedef deque<RequestSlot> RequestSlots;
+typedef std::deque<RequestSlot> RequestSlots;
+
+} // namespace aria2
 
 #endif // _D_REQUEST_SLOT_H_
diff --git a/src/ResourcesMetalinkParserState.cc b/src/ResourcesMetalinkParserState.cc
index 1a7f363d..05e78eac 100644
--- a/src/ResourcesMetalinkParserState.cc
+++ b/src/ResourcesMetalinkParserState.cc
@@ -37,31 +37,33 @@
 #include "Util.h"
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 void ResourcesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-						const string& name,
-						const map<string, string>& attrs)
+						const std::string& name,
+						const std::map<std::string, std::string>& attrs)
 {
   if(name == "url") {
     stm->setURLState();
-    string type;
+    std::string type;
     {
-      map<string, string>::const_iterator itr = attrs.find("type");
+      std::map<std::string, std::string>::const_iterator itr = attrs.find("type");
       if(itr == attrs.end()) {
 	return;
       } else {
 	type = (*itr).second;
       }
     }
-    string location;
+    std::string location;
     {
-      map<string, string>::const_iterator itr = attrs.find("location");
+      std::map<std::string, std::string>::const_iterator itr = attrs.find("location");
       if(itr != attrs.end()) {
 	location = Util::toUpper((*itr).second);
       }
     }
     int32_t preference;
     {
-      map<string, string>::const_iterator itr = attrs.find("preference");
+      std::map<std::string, std::string>::const_iterator itr = attrs.find("preference");
       if(itr == attrs.end()) {
 	preference = 0;
       } else {
@@ -75,7 +77,7 @@ void ResourcesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
     }
     int32_t maxConnections;
     {
-      map<string, string>::const_iterator itr = attrs.find("maxconnections");
+      std::map<std::string, std::string>::const_iterator itr = attrs.find("maxconnections");
       if(itr == attrs.end()) {
 	maxConnections = -1;
       } else {
@@ -98,8 +100,10 @@ void ResourcesMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
 }
 
 void ResourcesMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					      const string& name,
-					      const string& characters)
+					      const std::string& name,
+					      const std::string& characters)
 {
   stm->setFileState();
 }
+
+} // namespace aria2
diff --git a/src/ResourcesMetalinkParserState.h b/src/ResourcesMetalinkParserState.h
index 5ed9d4eb..13372472 100644
--- a/src/ResourcesMetalinkParserState.h
+++ b/src/ResourcesMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class ResourcesMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_RESOURCES_METALINK_PARSER_STATE_H_
diff --git a/src/SeedCheckCommand.cc b/src/SeedCheckCommand.cc
index 07ac79ee..7b1bbe6e 100644
--- a/src/SeedCheckCommand.cc
+++ b/src/SeedCheckCommand.cc
@@ -33,13 +33,21 @@
  */
 /* copyright --> */
 #include "SeedCheckCommand.h"
+#include "DownloadEngine.h"
+#include "BtRuntime.h"
+#include "PieceStorage.h"
+#include "BtContext.h"
+#include "Logger.h"
+#include "SeedCriteria.h"
 #include "message.h"
 
+namespace aria2 {
+
 SeedCheckCommand::SeedCheckCommand(int cuid,
 				   RequestGroup* requestGroup,
 				   DownloadEngine* e,
 				   const BtContextHandle& btContext,
-				   SeedCriteriaHandle seedCriteria)
+				   const SeedCriteriaHandle& seedCriteria)
   :Command(cuid),
    BtContextAwareCommand(btContext),
    RequestGroupAware(requestGroup),
@@ -71,3 +79,10 @@ bool SeedCheckCommand::execute() {
   e->commands.push_back(this);
   return false;
 }
+
+void SeedCheckCommand::setSeedCriteria(const SharedHandle<SeedCriteria>& seedCriteria)
+{
+  this->seedCriteria = seedCriteria;
+}
+
+} // namespace aria2
diff --git a/src/SeedCheckCommand.h b/src/SeedCheckCommand.h
index 8716dad0..843c31c2 100644
--- a/src/SeedCheckCommand.h
+++ b/src/SeedCheckCommand.h
@@ -37,10 +37,13 @@
 
 #include "Command.h"
 #include "BtContextAwareCommand.h"
-#include "DownloadEngine.h"
-#include "TimeA2.h"
-#include "SeedCriteria.h"
 #include "RequestGroupAware.h"
+#include "TimeA2.h"
+
+namespace aria2 {
+
+class DownloadEngine;
+class SeedCriteria;
 
 class SeedCheckCommand : public Command,
 			 public BtContextAwareCommand,
@@ -49,22 +52,22 @@ class SeedCheckCommand : public Command,
 private:
   DownloadEngine* e;
   Time checkPoint;
-  SeedCriteriaHandle seedCriteria;
+  SharedHandle<SeedCriteria> seedCriteria;
   bool checkStarted;
 public:
   SeedCheckCommand(int cuid,
 		   RequestGroup* requestGroup,
 		   DownloadEngine* e,
-		   const BtContextHandle& btContext,
-		   SeedCriteriaHandle seedCriteria);
+		   const SharedHandle<BtContext>& btContext,
+		   const SharedHandle<SeedCriteria>& seedCriteria);
 
   virtual ~SeedCheckCommand() {}
 
   virtual bool execute();
 
-  void setSeedCriteria(SeedCriteriaHandle seedCriteria) {
-    this->seedCriteria = seedCriteria;
-  }
+  void setSeedCriteria(const SharedHandle<SeedCriteria>& seedCriteria);
 };
 
+} // namespace aria2
+
 #endif // _D_SEED_CHECK_COMMAND_H_
diff --git a/src/SeedCriteria.h b/src/SeedCriteria.h
index e7547baa..d30ee910 100644
--- a/src/SeedCriteria.h
+++ b/src/SeedCriteria.h
@@ -37,6 +37,9 @@
 
 #include "common.h"
 #include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class SeedCriteria {
 public:
@@ -55,6 +58,8 @@ public:
 
 typedef SharedHandle<SeedCriteria> SeedCriteriaHandle;
 
-typedef deque<SeedCriteriaHandle> SeedCriterion;
+typedef std::deque<SeedCriteriaHandle> SeedCriterion;
+
+} // namespace aria2
 
 #endif // _D_SEED_CRITERIA_H_
diff --git a/src/Segment.h b/src/Segment.h
index 156f94c2..acf0d9c2 100644
--- a/src/Segment.h
+++ b/src/Segment.h
@@ -36,9 +36,13 @@
 #define _D_SEGMENT_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+#include <deque>
+
+namespace aria2 {
 
 class Piece;
-typedef SharedHandle<Piece> PieceHandle;
 
 class Segment {
 public:
@@ -64,7 +68,7 @@ public:
 
   virtual void clear() = 0;
 
-  virtual PieceHandle getPiece() const = 0;
+  virtual SharedHandle<Piece> getPiece() const = 0;
 
   bool operator==(const Segment& segment) const
   {
@@ -73,7 +77,9 @@ public:
 };
 
 typedef SharedHandle<Segment> SegmentHandle;
-typedef deque<SegmentHandle> Segments;
+typedef std::deque<SegmentHandle> Segments;
+
+} // namespace aria2
 
 #endif // _D_SEGMENT_H_
 
diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc
index 763ae924..d6b1a62b 100644
--- a/src/SegmentMan.cc
+++ b/src/SegmentMan.cc
@@ -33,21 +33,20 @@
  */
 /* copyright --> */
 #include "SegmentMan.h"
-#include "DlAbortEx.h"
 #include "Util.h"
-#include "File.h"
 #include "message.h"
 #include "prefs.h"
 #include "PiecedSegment.h"
 #include "GrowSegment.h"
-#include "DiskAdaptor.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "PieceStorage.h"
 #include "PeerStat.h"
 #include "Option.h"
 #include "DownloadContext.h"
 #include "Piece.h"
-#include "a2io.h"
+
+namespace aria2 {
 
 SegmentEntry::SegmentEntry(int32_t cuid, const SegmentHandle& segment):
   cuid(cuid), segment(segment) {}
@@ -219,9 +218,9 @@ public:
 bool SegmentMan::completeSegment(int32_t cuid, const SegmentHandle& segment) {
   _pieceStorage->completePiece(segment->getPiece());
   _pieceStorage->advertisePiece(cuid, segment->getPiece()->getIndex());
-  SegmentEntries::iterator itr = find_if(usedSegmentEntries.begin(),
-					 usedSegmentEntries.end(),
-					 FindSegmentEntry(segment));
+  SegmentEntries::iterator itr = std::find_if(usedSegmentEntries.begin(),
+					      usedSegmentEntries.end(),
+					      FindSegmentEntry(segment));
   if(itr == usedSegmentEntries.end()) {
     return false;
   } else {
@@ -282,3 +281,4 @@ int32_t SegmentMan::countFreePieceFrom(int32_t index) const
   return _downloadContext->getNumPieces()-index;
 }
 
+} // namespace aria2
diff --git a/src/SegmentMan.h b/src/SegmentMan.h
index b06e6ea0..3e4cc03e 100644
--- a/src/SegmentMan.h
+++ b/src/SegmentMan.h
@@ -36,36 +36,31 @@
 #define _D_SEGMENT_MAN_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class Segment;
-typedef SharedHandle<Segment> SegmentHandle;
-typedef deque<SegmentHandle> Segments;
 class Logger;
 class Option;
 class PeerStat;
-typedef SharedHandle<PeerStat> PeerStatHandle;
-typedef deque<PeerStatHandle> PeerStats;
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class PieceStorage;
-typedef SharedHandle<PieceStorage> PieceStorageHandle;
 class Piece;
-typedef SharedHandle<Piece> PieceHandle;
-
-#define SEGMENT_FILE_EXTENSION ".aria2"
 
 class SegmentEntry {
 public:
   int32_t cuid;
-  SegmentHandle segment;
+  SharedHandle<Segment> segment;
 public:
-  SegmentEntry(int32_t cuid, const SegmentHandle& segment);
+  SegmentEntry(int32_t cuid, const SharedHandle<Segment>& segment);
 
   ~SegmentEntry();
 };
 
 typedef SharedHandle<SegmentEntry> SegmentEntryHandle;
-typedef deque<SegmentEntryHandle> SegmentEntries;
+typedef std::deque<SegmentEntryHandle> SegmentEntries;
 
 /**
  * This class holds the download progress of the one download entry.
@@ -76,21 +71,22 @@ private:
 
   const Logger* logger;
 
-  DownloadContextHandle _downloadContext;
+  SharedHandle<DownloadContext> _downloadContext;
 
-  PieceStorageHandle _pieceStorage;
+  SharedHandle<PieceStorage> _pieceStorage;
 
   SegmentEntries usedSegmentEntries;
 
-  PeerStats peerStats;
+  std::deque<SharedHandle<PeerStat> > peerStats;
 
-  SegmentHandle checkoutSegment(int32_t cuid, const PieceHandle& piece);
+  SharedHandle<Segment> checkoutSegment(int32_t cuid,
+					const SharedHandle<Piece>& piece);
 
-  SegmentEntryHandle findSlowerSegmentEntry(const PeerStatHandle& peerStat) const;
+  SegmentEntryHandle findSlowerSegmentEntry(const SharedHandle<PeerStat>& peerStat) const;
 public:
   SegmentMan(const Option* option,
-	     const DownloadContextHandle& downloadContext = 0,
-	     const PieceStorageHandle& pieceStorage = 0);
+	     const SharedHandle<DownloadContext>& downloadContext = 0,
+	     const SharedHandle<PieceStorage>& pieceStorage = 0);
 
   ~SegmentMan();
 
@@ -118,15 +114,17 @@ public:
    * If there is no vacant segment, then returns a segment instance whose
    * isNull call is true.
    */
-  Segments getInFlightSegment(int32_t cuid);
-  SegmentHandle getSegment(int32_t cuid);
+  std::deque<SharedHandle<Segment> > getInFlightSegment(int32_t cuid);
+
+  SharedHandle<Segment> getSegment(int32_t cuid);
+
   /**
    * Returns a segment whose index is index. 
    * If it has already assigned
    * to another cuid or has been downloaded, then returns a segment instance
    * whose isNull call is true.
    */
-  SegmentHandle getSegment(int32_t cuid, int32_t index);
+  SharedHandle<Segment> getSegment(int32_t cuid, int32_t index);
   /**
    * Updates download status.
    */
@@ -139,17 +137,17 @@ public:
   /**
    * Tells SegmentMan that the segment has been downloaded successfully.
    */
-  bool completeSegment(int32_t cuid, const SegmentHandle& segment);
+  bool completeSegment(int32_t cuid, const SharedHandle<Segment>& segment);
 
   /**
    * Injects PieceStorage.
    */
-  void setPieceStorage(const PieceStorageHandle& pieceStorage);
+  void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
 
   /**
    * Injects DownloadContext.
    */
-  void setDownloadContext(const DownloadContextHandle& downloadContext);
+  void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
 
   /**
    * Returns true if the segment whose index is index has been downloaded.
@@ -164,13 +162,13 @@ public:
    * Registers given peerStat if it has not been registerd.
    * Otherwise does nothing.
    */
-  void registerPeerStat(const PeerStatHandle& peerStat);
+  void registerPeerStat(const SharedHandle<PeerStat>& peerStat);
 
   /**
    * Returns peerStat whose cuid is given cuid. If it is not found, returns
    * 0.
    */
-  PeerStatHandle getPeerStat(int32_t cuid) const;
+  SharedHandle<PeerStat> getPeerStat(int32_t cuid) const;
 
   /**
    * Returns current download speed in bytes per sec. 
@@ -181,4 +179,7 @@ public:
 };
 
 typedef SharedHandle<SegmentMan> SegmentManHandle;
+
+} // namespace aria2
+
 #endif // _D_SEGMENT_MAN_H_
diff --git a/src/SegmentManFactory.h b/src/SegmentManFactory.h
index 75754a86..b06f1640 100644
--- a/src/SegmentManFactory.h
+++ b/src/SegmentManFactory.h
@@ -36,16 +36,25 @@
 #define _D_SEGMENT_MAN_FACTORY_H_
 
 #include "common.h"
-#include "SegmentMan.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
+
+class SegmentMan;
+class DownloadContext;
+class PieceStorage;
 
 class SegmentManFactory {
 public:
   virtual ~SegmentManFactory() {}
 
-  virtual SegmentManHandle createNewInstance(const DownloadContextHandle& dc,
-					     const PieceStorageHandle& ps) = 0;
+  virtual SharedHandle<SegmentMan>
+  createNewInstance(const SharedHandle<DownloadContext>& dc,
+		    const SharedHandle<PieceStorage>& ps) = 0;
 };
 
 typedef SharedHandle<SegmentManFactory> SegmentManFactoryHandle;
 
+} // namespace aria2
+
 #endif // _D_SEGMENT_MAN_FACTORY_H_
diff --git a/src/Sequence.h b/src/Sequence.h
index c8ce1462..d3efc3bf 100644
--- a/src/Sequence.h
+++ b/src/Sequence.h
@@ -37,7 +37,7 @@
 
 #include <deque>
 
-using namespace std;
+namespace aria2 {
 
 template<typename T>
 class Sequence
@@ -62,7 +62,7 @@ public:
     }
   };
 
-  typedef deque<Value> Values;
+  typedef std::deque<Value> Values;
 private:
   Values _values;
 public:
@@ -86,9 +86,9 @@ public:
     return !_values.empty();
   }
 
-  deque<T> flush()
+  std::deque<T> flush()
   {
-    deque<T> r;
+    std::deque<T> r;
     while(hasNext()) {
       r.push_back(next());
     }
@@ -96,4 +96,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_SEQUENCE_H_
diff --git a/src/ServerHost.cc b/src/ServerHost.cc
index 38393060..21ef2a0d 100644
--- a/src/ServerHost.cc
+++ b/src/ServerHost.cc
@@ -34,7 +34,11 @@
 /* copyright --> */
 #include "ServerHost.h"
 
-ServerHost::ServerHost(int32_t cuid, const string& hostname):
+namespace aria2 {
+
+ServerHost::ServerHost(int32_t cuid, const std::string& hostname):
   _cuid(cuid), _hostname(hostname) {}
 
 ServerHost::~ServerHost() {}
+
+} // namespace aria2
diff --git a/src/ServerHost.h b/src/ServerHost.h
index aff750be..5611ebba 100644
--- a/src/ServerHost.h
+++ b/src/ServerHost.h
@@ -36,15 +36,19 @@
 #define _D_SERVER_HOST_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+
+namespace aria2 {
 
 class ServerHost {
 private:
   int32_t _cuid;
 
-  string _hostname;
+  std::string _hostname;
   
 public:
-  ServerHost(int32_t cuid, const string& hostname);
+  ServerHost(int32_t cuid, const std::string& hostname);
 
   ~ServerHost();
 
@@ -53,7 +57,7 @@ public:
     return _cuid;
   }
 
-  const string& getHostname() const
+  const std::string& getHostname() const
   {
     return _hostname;
   }
@@ -66,4 +70,6 @@ public:
 
 typedef SharedHandle<ServerHost> ServerHostHandle;
 
+} // namespace aria2
+
 #endif // _D_SERVER_HOST_H_
diff --git a/src/ShaVisitor.cc b/src/ShaVisitor.cc
deleted file mode 100644
index 3aae84bd..00000000
--- a/src/ShaVisitor.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#include "ShaVisitor.h"
-#include "Util.h"
-
-ShaVisitor::ShaVisitor()
-{
-  ctx.trySetAlgo("sha1");
-  ctx.digestInit();
-}
-
-ShaVisitor::~ShaVisitor() {}
-
-
-void ShaVisitor::visit(const Data* d) {
-  if(d->isNumber()) {
-    ctx.digestUpdate("i", 1);
-  } else {
-    string lenStr = Util::llitos(d->getLen());
-    ctx.digestUpdate(lenStr.c_str(), lenStr.size());
-    ctx.digestUpdate(":", 1);
-  }
-  ctx.digestUpdate(d->getData(), d->getLen());
-  if(d->isNumber()) {
-    ctx.digestUpdate("e", 1);
-  }
-}
-
-void ShaVisitor::visit(const Dictionary* d) {
-  ctx.digestUpdate("d", 1);
-  const Order& v = d->getOrder();
-  for(Order::const_iterator itr = v.begin(); itr != v.end(); itr++) {
-    string lenStr = Util::llitos(itr->size());
-    ctx.digestUpdate(lenStr.c_str(), lenStr.size());
-    ctx.digestUpdate(":", 1);
-    ctx.digestUpdate(itr->c_str(), itr->size());
-    const MetaEntry* e = d->get(*itr);
-    this->visit(e);
-  }
-  ctx.digestUpdate("e", 1);
-}
-
-void ShaVisitor::visit(const List* l) {
-  ctx.digestUpdate("l", 1);
-  for(MetaList::const_iterator itr = l->getList().begin(); itr != l->getList().end(); itr++) {
-    this->visit(*itr);
-  }
-  ctx.digestUpdate("e", 1);
-}
-
-void ShaVisitor::visit(const MetaEntry* e) {
-  if(dynamic_cast<const Data*>(e) != NULL) {
-    visit((const Data*)e);
-  } else if(dynamic_cast<const Dictionary*>(e) != NULL) {
-    visit((const Dictionary*)e);
-  } else if(dynamic_cast<const List*>(e) != NULL) {
-    visit((const List*)e);
-  }
-}
-
-void ShaVisitor::getHash(unsigned char* hashValue, int& len) {
-  len = ctx.digestLength();
-  ctx.digestFinal(hashValue);
-}
diff --git a/src/ShaVisitor.h b/src/ShaVisitor.h
deleted file mode 100644
index ea5ef33e..00000000
--- a/src/ShaVisitor.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_SHA_VISITOR_H_
-#define _D_SHA_VISITOR_H_
-
-#include "MetaEntryVisitor.h"
-#include "Data.h"
-#include "Dictionary.h"
-#include "List.h"
-#include "common.h"
-#include "messageDigest.h"
-
-class ShaVisitor : public MetaEntryVisitor {
-private:
-  MessageDigestContext ctx;
-public:
-  ShaVisitor();
-  ~ShaVisitor();
-
-  void visit(const Data* d);
-  void visit(const Dictionary* d);
-  void visit(const List* l);
-  void visit(const MetaEntry* e);
-
-  void getHash(unsigned char* md, int& s);
-};
-
-#endif // _D_SHA_VISITOR_H_
diff --git a/src/ShareRatioSeedCriteria.h b/src/ShareRatioSeedCriteria.h
index 0b5b9f55..5fd5d196 100644
--- a/src/ShareRatioSeedCriteria.h
+++ b/src/ShareRatioSeedCriteria.h
@@ -42,15 +42,17 @@
 #include "BtRuntime.h"
 #include "BtRegistry.h"
 
+namespace aria2 {
+
 class ShareRatioSeedCriteria : public SeedCriteria {
 private:
   double ratio;
-  BtContextHandle btContext;
-  PeerStorageHandle peerStorage;
-  PieceStorageHandle pieceStorage;
-  BtRuntimeHandle btRuntime;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<PeerStorage> peerStorage;
+  SharedHandle<PieceStorage> pieceStorage;
+  SharedHandle<BtRuntime> btRuntime;
 public:
-  ShareRatioSeedCriteria(double ratio, const BtContextHandle& btContext)
+  ShareRatioSeedCriteria(double ratio, const SharedHandle<BtContext>& btContext)
     :ratio(ratio),
      btContext(btContext),
      peerStorage(PEER_STORAGE(btContext)),
@@ -81,4 +83,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_SHARE_RATIO_SEED_CRITERIA_H_
diff --git a/src/SharedHandle.h b/src/SharedHandle.h
index 1b9838d3..fa875ebe 100644
--- a/src/SharedHandle.h
+++ b/src/SharedHandle.h
@@ -35,7 +35,9 @@
 #ifndef _D_SHARED_HANDLE_H_
 #define _D_SHARED_HANDLE_H_
 
-#include <ostream>
+#include <iosfwd>
+
+namespace aria2 {
 
 class RefCount {
 public:
@@ -320,4 +322,6 @@ bool operator<(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
   return *t1.obj < *t2.obj;
 }
 
+} // namespace aria2
+
 #endif // _D_SHARED_HANDLE_H_
diff --git a/src/SimpleBtMessage.cc b/src/SimpleBtMessage.cc
index d9b24195..3a8b989f 100644
--- a/src/SimpleBtMessage.cc
+++ b/src/SimpleBtMessage.cc
@@ -35,6 +35,11 @@
 #include "SimpleBtMessage.h"
 #include "message.h"
 #include "BtRegistry.h"
+#include "Peer.h"
+#include "PeerConnection.h"
+#include "Logger.h"
+
+namespace aria2 {
 
 SimpleBtMessage::SimpleBtMessage():leftDataLength(0) {}
 
@@ -62,3 +67,5 @@ void SimpleBtMessage::send() {
     }
   }
 }
+
+} // namespace aria2
diff --git a/src/SimpleBtMessage.h b/src/SimpleBtMessage.h
index 6747d95b..60f8a7ea 100644
--- a/src/SimpleBtMessage.h
+++ b/src/SimpleBtMessage.h
@@ -37,6 +37,8 @@
 
 #include "AbstractBtMessage.h"
 
+namespace aria2 {
+
 class SimpleBtMessage : public AbstractBtMessage {
 private:
   int32_t leftDataLength;
@@ -57,4 +59,6 @@ public:
 
 };
 
+} // namespace aria2
+
 #endif // _D_SIMPLE_BT_MESSAGE_H_
diff --git a/src/SimpleLogger.cc b/src/SimpleLogger.cc
index cc8068ff..f3a7ceb0 100644
--- a/src/SimpleLogger.cc
+++ b/src/SimpleLogger.cc
@@ -38,8 +38,10 @@
 #include "message.h"
 #include "a2io.h"
 #include "a2time.h"
-#include <stdarg.h>
-#include <errno.h>
+#include <cstdarg>
+#include <cerrno>
+
+namespace aria2 {
 
 #if !defined(va_copy)
 # if defined(__va_copy)
@@ -67,7 +69,7 @@ SimpleLogger::~SimpleLogger() {
   closeFile();
 }
 
-void SimpleLogger::openFile(const string& filename) {
+void SimpleLogger::openFile(const std::string& filename) {
   file = fopen(filename.c_str(), "ab");
   if(file == NULL) {
     throw new DlAbortEx(EX_FILE_OPEN, filename.c_str(), strerror(errno));
@@ -88,7 +90,9 @@ void SimpleLogger::setStdout(Logger::LEVEL level, bool enabled) {
   }
 }
 
-void SimpleLogger::writeHeader(FILE* file, string date, string level) const {
+void SimpleLogger::writeHeader(FILE* file,
+			       const std::string& date, const std::string& level) const
+{
   fprintf(file, "%s %s - ", date.c_str(), level.c_str());
 }
 
@@ -96,7 +100,7 @@ void SimpleLogger::writeLog(FILE* file, Logger::LEVEL level, const char* msg, va
 {
   va_list apCopy;
   va_copy(apCopy, ap);
-  string levelStr;
+  std::string levelStr;
   switch(level) {
   case Logger::DEBUG:
     levelStr = "DEBUG";
@@ -124,7 +128,7 @@ void SimpleLogger::writeLog(FILE* file, Logger::LEVEL level, const char* msg, va
   if(printHeader) {
     writeHeader(file, datestr, levelStr);
   }
-  vfprintf(file, string(Util::replace(msg, "\r", "")+"\n").c_str(), apCopy);
+  vfprintf(file, std::string(Util::replace(msg, "\r", "")+"\n").c_str(), apCopy);
   for(Exception* nestedEx = e; nestedEx; nestedEx = nestedEx->getCause()) {
     // TODO a quick hack not to print header in console
     if(printHeader) {
@@ -184,4 +188,4 @@ void SimpleLogger::error(const char* msg, Exception* e, ...) const {
   WRITE_LOG_EX(ERROR, msg, e);
 }
 
-  
+} // namespace aria2
diff --git a/src/SimpleLogger.h b/src/SimpleLogger.h
index 1773a79e..6063939e 100644
--- a/src/SimpleLogger.h
+++ b/src/SimpleLogger.h
@@ -36,19 +36,26 @@
 #define _D_SIMPLE_LOGGER_H_
 
 #include "Logger.h"
+#include <cstdio>
+#include <string>
+
+namespace aria2 {
 
 class SimpleLogger:public Logger {
 private:
   void writeFile(Logger::LEVEL level, const char* msg, va_list ap, Exception* e = 0) const;
-  void writeHeader(FILE* file, string date, string level) const;
-  void writeLog(FILE* file, Logger::LEVEL level, const char* msg, va_list ap, Exception* e = 0, bool printHeader = true) const;
+  void writeHeader(FILE* file,
+		   const std::string& date, const std::string& level) const;
+  void writeLog(FILE* file, Logger::LEVEL level,
+		const char* msg, va_list ap,
+		Exception* e = 0, bool printHeader = true) const;
   FILE* file;
   int32_t stdoutField;
 public:
   SimpleLogger(FILE* logfile = 0);
   ~SimpleLogger();
 
-  void openFile(const string& filename);
+  void openFile(const std::string& filename);
   void closeFile();
   virtual void debug(const char* msg, ...) const;
   virtual void debug(const char* msg, Exception* ex, ...) const;
@@ -64,5 +71,7 @@ public:
   void setStdout(Logger::LEVEL level, bool enabled);
 };
 
+} // namespace aria2
+
 #endif // _D_SIMPLE_LOGGER_H_
 
diff --git a/src/SimpleRandomizer.cc b/src/SimpleRandomizer.cc
index c13a5f7b..93f1b0b0 100644
--- a/src/SimpleRandomizer.cc
+++ b/src/SimpleRandomizer.cc
@@ -34,4 +34,8 @@
 /* copyright --> */
 #include "SimpleRandomizer.h"
 
+namespace aria2 {
+
 RandomizerHandle SimpleRandomizer::randomizer = 0;
+
+} // namespace aria2
diff --git a/src/SimpleRandomizer.h b/src/SimpleRandomizer.h
index 9a593c87..125018d1 100644
--- a/src/SimpleRandomizer.h
+++ b/src/SimpleRandomizer.h
@@ -39,6 +39,8 @@
 #include "a2time.h"
 #include <stdlib.h>
 
+namespace aria2 {
+
 class SimpleRandomizer : public Randomizer {
 private:
   static RandomizerHandle randomizer;
@@ -76,4 +78,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_SIMPLE_RANDOMIZER_H_
diff --git a/src/SingleFileAllocationIterator.cc b/src/SingleFileAllocationIterator.cc
index e71e16eb..53030b16 100644
--- a/src/SingleFileAllocationIterator.cc
+++ b/src/SingleFileAllocationIterator.cc
@@ -37,6 +37,8 @@
 #include "Util.h"
 #include "a2io.h"
 
+namespace aria2 {
+
 #define BUFSIZE (256*1024)
 #define ALIGNMENT 512
 
@@ -77,3 +79,5 @@ bool SingleFileAllocationIterator::finished()
 {
   return _offset >= _totalLength;
 }
+
+} // namespace aria2
diff --git a/src/SingleFileAllocationIterator.h b/src/SingleFileAllocationIterator.h
index 3690df88..624ab11d 100644
--- a/src/SingleFileAllocationIterator.h
+++ b/src/SingleFileAllocationIterator.h
@@ -37,6 +37,8 @@
 
 #include "FileAllocationIterator.h"
 
+namespace aria2 {
+
 class BinaryStream;
 
 class SingleFileAllocationIterator:public FileAllocationIterator
@@ -76,4 +78,6 @@ public:
 
 typedef SharedHandle<SingleFileAllocationIterator> SingleFileAllocationIteratorHandle;
 
+} // namespace aria2
+
 #endif // _D_SINGLE_FILE_ALLOCATION_ITERATOR_H_
diff --git a/src/Directory.cc b/src/SingleFileDownloadContext.cc
similarity index 54%
rename from src/Directory.cc
rename to src/SingleFileDownloadContext.cc
index 4fade277..4eae5b63 100644
--- a/src/Directory.cc
+++ b/src/SingleFileDownloadContext.cc
@@ -32,48 +32,66 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
-#include "Directory.h"
-#include "File.h"
-#include "DlAbortEx.h"
-#include "message.h"
-#include "a2io.h"
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
 
-Directory::Directory(const string& name):name(name) {}
+namespace aria2 {
 
-Directory::Directory() {}
-
-Directory::~Directory() {
-  for(Files::iterator itr = files.begin(); itr != files.end(); itr++) {
-    delete *itr;
-  }
+SingleFileDownloadContext::SingleFileDownloadContext(int32_t pieceLength,
+						     int64_t totalLength,
+						     const std::string& filename,
+						     const std::string& ufilename):
+  _pieceLength(pieceLength),
+  _fileEntry(new FileEntry(filename, totalLength, 0)),
+  _filename(filename),
+  _ufilename(ufilename)
+{
+  updateFileEntry();
 }
 
-void Directory::createDir(const string& parentDir, bool recursive) const {
-  if(name.size() == 0) {
-    return;
-  }
-  string path = parentDir+"/"+name;
-  File f(path);
-  if(f.exists()) {
-    if(!f.isDir()) {
-      throw new DlAbortEx(EX_NOT_DIRECTORY, path.c_str());
-    }
+void SingleFileDownloadContext::updateFileEntry()
+{
+  if(_ufilename != "") {
+    _fileEntry->setPath(_ufilename);
+  } else if(_filename != "") {
+    _fileEntry->setPath(_filename);
   } else {
-    if(a2mkdir(path.c_str(), OPEN_MODE) == -1) {
-      throw new DlAbortEx(EX_MAKE_DIR, path.c_str(), strerror(errno));
-    }
-  }
-  if(recursive) {
-    for(Files::const_iterator itr = files.begin(); itr != files.end(); itr++) {
-      (*itr)->createDir(path, true);
-    }
+    _fileEntry->setPath("index.html");
   }
 }
 
-void Directory::addFile(Directory* directory) {
-  files.push_back(directory);
+const std::deque<std::string>&
+SingleFileDownloadContext::getPieceHashes() const
+{
+  return _pieceHashes;
 }
+
+int64_t SingleFileDownloadContext::getTotalLength() const
+{
+  return _fileEntry->getLength();
+}
+
+FileEntries
+SingleFileDownloadContext::getFileEntries() const
+{
+  FileEntries fs;
+  fs.push_back(_fileEntry);
+  return fs;
+}
+
+int32_t SingleFileDownloadContext::getNumPieces() const
+{
+  return (_fileEntry->getLength()+_pieceLength-1)/_pieceLength;
+}
+
+std::string SingleFileDownloadContext::getActualBasePath() const
+{
+  return _dir+"/"+_fileEntry->getPath();
+}
+
+void SingleFileDownloadContext::setTotalLength(int64_t totalLength)
+{
+  _fileEntry->setLength(totalLength);
+}
+
+} // namespace aria2
diff --git a/src/SingleFileDownloadContext.h b/src/SingleFileDownloadContext.h
index 32520b92..d02a4f9f 100644
--- a/src/SingleFileDownloadContext.h
+++ b/src/SingleFileDownloadContext.h
@@ -36,6 +36,10 @@
 #define _D_SINGLE_FILE_DOWNLOAD_CONTEXT_H_
 
 #include "DownloadContext.h"
+#include <string>
+#include <deque>
+
+namespace aria2 {
 
 class SingleFileDownloadContext:public DownloadContext
 {
@@ -45,48 +49,32 @@ private:
    * Actual file path is _dir + _filename.
    * If _ufilename is not zero-length string, then _dir + _ufilename.
    */
-  FileEntryHandle _fileEntry;
+  SharedHandle<FileEntry> _fileEntry;
   /**
    * _filename and _ufilename may contains directory path name.
    * So usr/local/aria2c is acceptable here.
    */
-  string _filename;
-  string _ufilename;
+  std::string _filename;
+  std::string _ufilename;
 
-  string _contentType;
+  std::string _contentType;
 
-  Strings _pieceHashes;
-  string _pieceHashAlgo;
+  std::deque<std::string> _pieceHashes;
+  std::string _pieceHashAlgo;
 
-  string _checksum;
-  string _checksumHashAlgo;
+  std::string _checksum;
+  std::string _checksumHashAlgo;
 
-  void updateFileEntry()
-  {
-    if(_ufilename != "") {
-      _fileEntry->setPath(_ufilename);
-    } else if(_filename != "") {
-      _fileEntry->setPath(_filename);
-    } else {
-      _fileEntry->setPath("index.html");
-    }
-  }
+  void updateFileEntry();
 public:
   SingleFileDownloadContext(int32_t pieceLength,
 			    int64_t totalLength,
-			    const string& filename,
-			    const string& ufilename = ""):
-    _pieceLength(pieceLength),
-    _fileEntry(new FileEntry(filename, totalLength, 0)),
-    _filename(filename),
-    _ufilename(ufilename)
-  {
-    updateFileEntry();
-  }
+			    const std::string& filename,
+			    const std::string& ufilename = "");
 
   virtual ~SingleFileDownloadContext() {}
 
-  virtual string getPieceHash(int32_t index) const
+  virtual std::string getPieceHash(int32_t index) const
   {
     if(index < 0 || _pieceHashes.size() <= (size_t)index) {
       return "";
@@ -94,29 +82,18 @@ public:
     return _pieceHashes[index];
   }
   
-  virtual const Strings& getPieceHashes() const
-  {
-    return _pieceHashes;
-  }
+  virtual const std::deque<std::string>& getPieceHashes() const;
 
-  virtual int64_t getTotalLength() const
-  {
-    return _fileEntry->getLength();
-  }
+  virtual int64_t getTotalLength() const;
 
   virtual FILE_MODE getFileMode() const
   {
     return SINGLE;
   }
 
-  virtual FileEntries getFileEntries() const
-  {
-    FileEntries fs;
-    fs.push_back(_fileEntry);
-    return fs;
-  }
+  virtual std::deque<SharedHandle<FileEntry> > getFileEntries() const;
 
-  virtual string getName() const
+  virtual std::string getName() const
   {
     return _filename;
   }
@@ -126,74 +103,65 @@ public:
     return _pieceLength;
   }
 
-  virtual int32_t getNumPieces() const
-  {
-    return (_fileEntry->getLength()+_pieceLength-1)/_pieceLength;
-  }
+  virtual int32_t getNumPieces() const;
 
-  virtual string getActualBasePath() const
-  {
-    return _dir+"/"+_fileEntry->getPath();
-  }
+  virtual std::string getActualBasePath() const;
 
-  virtual string getPieceHashAlgo() const
+  virtual std::string getPieceHashAlgo() const
   {
     return _pieceHashAlgo;
   }
 
-  const string& getChecksumHashAlgo() const
+  const std::string& getChecksumHashAlgo() const
   {
     return _checksumHashAlgo;
   }
 
-  const string& getChecksum() const
+  const std::string& getChecksum() const
   {
     return _checksum;
   }
 
-  void setPieceHashes(const Strings& pieceHashes)
+  void setPieceHashes(const std::deque<std::string>& pieceHashes)
   {
     _pieceHashes = pieceHashes;
   }
   
-  void setChecksumHashAlgo(const string& algo)
+  void setChecksumHashAlgo(const std::string& algo)
   {
     _checksumHashAlgo = algo;
   }
 
-  void setChecksum(const string& checksum)
+  void setChecksum(const std::string& checksum)
   {
     _checksum = checksum;
   }
 
-  void setFilename(const string& filename)
+  void setFilename(const std::string& filename)
   {
     _filename = filename;
     updateFileEntry();
   }
 
-  void setUFilename(const string& ufilename)
+  void setUFilename(const std::string& ufilename)
   {
     _ufilename = ufilename;
     updateFileEntry();
   }
 
-  void setTotalLength(int64_t totalLength)
-  {
-    _fileEntry->setLength(totalLength);
-  }
+  void setTotalLength(int64_t totalLength);
 
-  void setPieceHashAlgo(const string& algo)
+  void setPieceHashAlgo(const std::string& algo)
   {
     _pieceHashAlgo = algo;
   }
 
-  void setContentType(const string& contentType)
+  void setContentType(const std::string& contentType)
   {
     _contentType = contentType;
   }
 
-  const string& getContentType()
+  const std::string& getContentType()
   {
     return _contentType;
   }
@@ -201,4 +169,6 @@ public:
 
 typedef SharedHandle<SingleFileDownloadContext> SingleFileDownloadContextHandle;
 
+} // namespace aria2
+
 #endif // _D_SINGLE_FILE_DOWNLOAD_CONTEXT_H_
diff --git a/src/SingletonHolder.h b/src/SingletonHolder.h
index d6d2eebf..ba69e838 100644
--- a/src/SingletonHolder.h
+++ b/src/SingletonHolder.h
@@ -35,6 +35,8 @@
 #ifndef _D_SINGLETON_HOLDER_H_
 #define _D_SINGLETON_HOLDER_H_
 
+namespace aria2 {
+
 template<typename T>
 class SingletonHolder {
 private:
@@ -58,4 +60,6 @@ public:
 template<typename T>
 T SingletonHolder<T>::_instance = 0;
 
+} // namespace aria2
+
 #endif // _D_SINGLETON_HOLDER_H_
diff --git a/src/SizeMetalinkParserState.cc b/src/SizeMetalinkParserState.cc
index de57d031..7a7c0b9e 100644
--- a/src/SizeMetalinkParserState.cc
+++ b/src/SizeMetalinkParserState.cc
@@ -37,16 +37,18 @@
 #include "Util.h"
 #include "RecoverableException.h"
 
+namespace aria2 {
+
 void SizeMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					   const string& name,
-					   const map<string, string>& attrs)
+					   const std::string& name,
+					   const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void SizeMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					  const string& name,
-					  const string& characters)
+					 const std::string& name,
+					 const std::string& characters)
 {
   try {
     stm->setFileLengthOfEntry(Util::parseInt(characters));
@@ -56,3 +58,5 @@ void SizeMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
   }
   stm->setFileState();
 }
+
+} // namespace aria2
diff --git a/src/SizeMetalinkParserState.h b/src/SizeMetalinkParserState.h
index 83ac24fb..f9820b02 100644
--- a/src/SizeMetalinkParserState.h
+++ b/src/SizeMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class SizeMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_SIZE_METALINK_PARSER_STATE_H_
diff --git a/src/SkipTagMetalinkParserState.cc b/src/SkipTagMetalinkParserState.cc
index 4552193b..473cfd66 100644
--- a/src/SkipTagMetalinkParserState.cc
+++ b/src/SkipTagMetalinkParserState.cc
@@ -35,21 +35,25 @@
 #include "SkipTagMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 SkipTagMetalinkParserState::SkipTagMetalinkParserState(MetalinkParserState* prevState):
   _prevState(prevState), _depth(1) {}
 
 void SkipTagMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					      const string& name,
-					      const map<string, string>& attrs)
+					      const std::string& name,
+					      const std::map<std::string, std::string>& attrs)
 {
   ++_depth;
 }
 
 void SkipTagMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					    const string& name,
-					    const string& characters)
+					    const std::string& name,
+					    const std::string& characters)
 {
   if(--_depth == 0) {
     stm->restoreSavedState();
   }
 }
+
+} // namespace aria2
diff --git a/src/SkipTagMetalinkParserState.h b/src/SkipTagMetalinkParserState.h
index b3dd8d2a..3c9d74c0 100644
--- a/src/SkipTagMetalinkParserState.h
+++ b/src/SkipTagMetalinkParserState.h
@@ -37,6 +37,8 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class SkipTagMetalinkParserState:public MetalinkParserState
 {
 private:
@@ -46,10 +48,10 @@ public:
   SkipTagMetalinkParserState(MetalinkParserState* prevState);
 
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 
   MetalinkParserState* getPreviousState() const
   {
@@ -57,4 +59,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_SKIP_TAG_METALINK_PARSER_STATE_H_
diff --git a/src/SleepCommand.cc b/src/SleepCommand.cc
index 0cf82b54..1a710b72 100644
--- a/src/SleepCommand.cc
+++ b/src/SleepCommand.cc
@@ -33,9 +33,11 @@
  */
 /* copyright --> */
 #include "SleepCommand.h"
-#include "Util.h"
 #include "RequestGroupAware.h"
 #include "RequestGroup.h"
+#include "DownloadEngine.h"
+
+namespace aria2 {
 
 SleepCommand::SleepCommand(int32_t cuid, DownloadEngine* e, Command* nextCommand, int32_t wait):
   Command(cuid), engine(e), nextCommand(nextCommand), wait(wait) {}
@@ -70,3 +72,5 @@ bool SleepCommand::isHaltRequested() const
   }
   return false;
 }
+
+} // namespace aria2
diff --git a/src/SleepCommand.h b/src/SleepCommand.h
index b2edff94..3bbf4d1e 100644
--- a/src/SleepCommand.h
+++ b/src/SleepCommand.h
@@ -35,10 +35,13 @@
 #ifndef _D_SLEEP_COMMAND_H_
 #define _D_SLEEP_COMMAND_H_
 
-#include "DownloadEngine.h"
 #include "Command.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
+class DownloadEngine;
+
 class SleepCommand:public Command {
 private:
   DownloadEngine* engine;
@@ -54,4 +57,6 @@ public:
   bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_SLEEP_COMMAND_H_
diff --git a/src/Socket.h b/src/Socket.h
index f14b6f32..603f7db7 100644
--- a/src/Socket.h
+++ b/src/Socket.h
@@ -38,6 +38,10 @@
 #include "SocketCore.h"
 #include "SharedHandle.h"
 
+namespace aria2 {
+
 typedef SharedHandle<SocketCore> SocketHandle;
 
+} // namespace aria2
+
 #endif // _D_SOCKET_H_
diff --git a/src/SocketCore.cc b/src/SocketCore.cc
index 7dba735e..8bbaf394 100644
--- a/src/SocketCore.cc
+++ b/src/SocketCore.cc
@@ -39,15 +39,16 @@
 #include "DlRetryEx.h"
 #include "DlAbortEx.h"
 #include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-
+#include <cerrno>
+#include <cstring>
 #ifndef __MINGW32__
 # define SOCKET_ERRNO (errno)
 #else
 # define SOCKET_ERRNO (WSAGetLastError())
 #endif // __MINGW32__
 
+namespace aria2 {
+
 SocketCore::SocketCore(int sockType):_sockType(sockType), sockfd(-1) {
   init();
 }
@@ -133,7 +134,7 @@ SocketCore* SocketCore::acceptConnection() const
   return s;
 }
 
-void SocketCore::getAddrInfo(pair<string, int32_t>& addrinfo) const
+void SocketCore::getAddrInfo(std::pair<std::string, int32_t>& addrinfo) const
 {
   struct sockaddr_in listenaddr;
   memset((char*)&listenaddr, 0, sizeof(listenaddr));
@@ -145,7 +146,7 @@ void SocketCore::getAddrInfo(pair<string, int32_t>& addrinfo) const
   addrinfo.second = ntohs(listenaddr.sin_port);
 }
 
-void SocketCore::getPeerInfo(pair<string, int32_t>& peerinfo) const
+void SocketCore::getPeerInfo(std::pair<std::string, int32_t>& peerinfo) const
 {
   struct sockaddr_in peerin;
   memset(&peerin, 0, sizeof(peerin));
@@ -157,7 +158,7 @@ void SocketCore::getPeerInfo(pair<string, int32_t>& peerinfo) const
   peerinfo.second = ntohs(peerin.sin_port);
 }
 
-void SocketCore::establishConnection(const string& host, int32_t port)
+void SocketCore::establishConnection(const std::string& host, int32_t port)
 {
   closeConnection();
   sockfd = socket(AF_INET, _sockType, 0);
@@ -578,9 +579,9 @@ void SocketCore::initiateSecureConnection()
 }
 
 template<typename T>
-string uitos(T value)
+std::string uitos(T value)
 {
-  string str;
+  std::string str;
   if(value == 0) {
     str = "0";
     return str;
@@ -595,7 +596,7 @@ string uitos(T value)
   return str;
 }
 
-void fillSockaddr(sockaddr* addr, int sockType, const string& host, uint16_t port)
+void fillSockaddr(sockaddr* addr, int sockType, const std::string& host, uint16_t port)
 {
   struct addrinfo hints;
   struct addrinfo* result;
@@ -615,7 +616,7 @@ void fillSockaddr(sockaddr* addr, int sockType, const string& host, uint16_t por
   freeaddrinfo(result);
 }
 
-void SocketCore::writeData(const char* data, size_t len, const string& host, uint16_t port)
+void SocketCore::writeData(const char* data, size_t len, const std::string& host, uint16_t port)
 {
   struct sockaddr_storage addrPeer;
   fillSockaddr((struct sockaddr*)&addrPeer, _sockType, host, port);
@@ -644,7 +645,7 @@ ssize_t SocketCore::readDataFrom(char* data, size_t len)
 }
 
 ssize_t SocketCore::readDataFrom(char* data, size_t len,
-				 pair<string /* numerichost */,
+				 std::pair<std::string /* numerichost */,
 				 uint16_t /* port */>& sender)
 {
   struct sockaddr_storage addrSender;
@@ -667,3 +668,4 @@ ssize_t SocketCore::readDataFrom(char* data, size_t len,
   return rlength;
 }
 
+} // namespace aria2
diff --git a/src/SocketCore.h b/src/SocketCore.h
index 262e0d70..992b5bb3 100644
--- a/src/SocketCore.h
+++ b/src/SocketCore.h
@@ -36,9 +36,9 @@
 #define _D_SOCKET_CORE_H_
 
 #include "common.h"
+#include <sys/socket.h>
 #include <string>
 #include <utility>
-#include <sys/socket.h>
 
 #ifdef HAVE_LIBSSL
 // for SSL
@@ -49,7 +49,7 @@
 # include <gnutls/gnutls.h>
 #endif // HAVE_LIBGNUTLS
 
-using namespace std;
+namespace aria2 {
 
 class SocketCore {
   friend bool operator==(const SocketCore& s1, const SocketCore& s2);
@@ -112,13 +112,13 @@ public:
    * Stores host address and port of this socket to addrinfo.
    * @param addrinfo placeholder to store host address and port.
    */
-  void getAddrInfo(pair<string, int32_t>& addrinfo) const;
+  void getAddrInfo(std::pair<std::string, int32_t>& addrinfo) const;
   
   /**
    * Stores peer's address and port to peerinfo.
    * @param peerinfo placeholder to store peer's address and port.
    */
-  void getPeerInfo(pair<string, int32_t>& peerinfo) const;
+  void getPeerInfo(std::pair<std::string, int32_t>& peerinfo) const;
 
   /**
    * Accepts incoming connection on this socket.
@@ -135,7 +135,7 @@ public:
    * @param host hostname or ip address to connect to
    * @param port service port number to connect to
    */
-  void establishConnection(const string& host, int32_t port);
+  void establishConnection(const std::string& host, int32_t port);
 
   void setNonBlockingMode();
 
@@ -176,12 +176,12 @@ public:
    * @param len length of data
    */
   void writeData(const char* data, int32_t len);
-  void writeData(const string& msg)
+  void writeData(const std::string& msg)
   {
     writeData(msg.c_str(), msg.size());
   }
 
-  void writeData(const char* data, size_t len, const string& host, uint16_t port);
+  void writeData(const char* data, size_t len, const std::string& host, uint16_t port);
 
   /**
    * Reads up to len bytes from this socket.
@@ -201,7 +201,7 @@ public:
 		       socklen_t* senderLength);
 
   ssize_t readDataFrom(char*, size_t len,
-		       pair<string /* numerichost */,
+		       std::pair<std::string /* numerichost */,
 		       uint16_t /* port */>& sender);
 
   ssize_t readDataFrom(char* data, size_t len);
@@ -236,4 +236,7 @@ public:
     return sockfd < s.sockfd;
   }
 };
+
+} // namespace aria2
+
 #endif // _D_SOCKET_CORE_H_
diff --git a/src/SpeedCalc.cc b/src/SpeedCalc.cc
index 629d7d2d..9bdb92b5 100644
--- a/src/SpeedCalc.cc
+++ b/src/SpeedCalc.cc
@@ -34,8 +34,8 @@
 /* copyright --> */
 #include "SpeedCalc.h"
 #include <algorithm>
-#include <ostream>
-#include <iterator>
+
+namespace aria2 {
 
 #define CHANGE_INTERVAL_SEC 15
 
@@ -47,8 +47,8 @@ public:
 };
 
 void SpeedCalc::reset() {
-  fill(&lengthArray[0], &lengthArray[2], 0);
-  for_each(&cpArray[0], &cpArray[2], Reset());
+  std::fill(&lengthArray[0], &lengthArray[2], 0);
+  std::for_each(&cpArray[0], &cpArray[2], Reset());
   sw = 0;
   maxSpeed = 0;
   prevSpeed = 0;
@@ -62,7 +62,7 @@ int32_t SpeedCalc::calculateSpeed() {
   if(milliElapsed) {
     int32_t speed = lengthArray[sw]*1000/milliElapsed;
     prevSpeed = speed;
-    maxSpeed = max<int32_t>(speed, maxSpeed);
+    maxSpeed = std::max(speed, maxSpeed);
     return speed;
   } else {
     return prevSpeed;
@@ -74,7 +74,7 @@ int32_t SpeedCalc::calculateSpeed(const struct timeval& now) {
   if(milliElapsed) {
     int32_t speed = lengthArray[sw]*1000/milliElapsed;
     prevSpeed = speed;
-    maxSpeed = max<int32_t>(speed, maxSpeed);
+    maxSpeed = std::max(speed, maxSpeed);
     return speed;
   } else {
     return prevSpeed;
@@ -94,7 +94,7 @@ public:
 
 void SpeedCalc::update(int bytes) {
   accumulatedLength += bytes;
-  for_each(&lengthArray[0], &lengthArray[2], Plus(bytes));
+  std::for_each(&lengthArray[0], &lengthArray[2], Plus(bytes));
   if(isIntervalOver()) {
     changeSw();
   }
@@ -120,3 +120,5 @@ int32_t SpeedCalc::getAvgSpeed() const {
     return 0;
   }
 }
+
+} // namespace aria2
diff --git a/src/SpeedCalc.h b/src/SpeedCalc.h
index 25a8b93d..28e6c59a 100644
--- a/src/SpeedCalc.h
+++ b/src/SpeedCalc.h
@@ -38,6 +38,8 @@
 #include "common.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class SpeedCalc {
 private:
   int64_t lengthArray[2];
@@ -76,4 +78,6 @@ public:
   void reset();
 };
 
+} // namespace aria2
+
 #endif // _D_SPEED_CALC_H_
diff --git a/src/StatCalc.h b/src/StatCalc.h
index 2a5dbc9f..bfe00561 100644
--- a/src/StatCalc.h
+++ b/src/StatCalc.h
@@ -36,23 +36,26 @@
 #define _D_STAT_CALC_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+
+namespace aria2 {
 
 class RequestGroupMan;
-typedef SharedHandle<RequestGroupMan> RequestGroupManHandle;
 class FileAllocationMan;
-typedef SharedHandle<FileAllocationMan> FileAllocationManHandle;
 class CheckIntegrityMan;
-typedef SharedHandle<CheckIntegrityMan> CheckIntegrityManHandle;
 
 class StatCalc {
 public:
   virtual ~StatCalc() {}
 
-  virtual void calculateStat(const RequestGroupManHandle& requestGroupMan,
-			     const FileAllocationManHandle& fileAllocationMan,
-			     const CheckIntegrityManHandle& checkIntegrityMan) = 0;
+  virtual void 
+  calculateStat(const SharedHandle<RequestGroupMan>& requestGroupMan,
+		const SharedHandle<FileAllocationMan>& fileAllocationMan,
+		const SharedHandle<CheckIntegrityMan>& checkIntegrityMan) = 0;
 };
 
 typedef SharedHandle<StatCalc> StatCalcHandle;
 
+} // namespace aria2
+
 #endif // _D_STAT_CALC_H_
diff --git a/src/StreamCheckIntegrityEntry.cc b/src/StreamCheckIntegrityEntry.cc
index 6760f99a..46249125 100644
--- a/src/StreamCheckIntegrityEntry.cc
+++ b/src/StreamCheckIntegrityEntry.cc
@@ -36,10 +36,10 @@
 #include "RequestGroup.h"
 #include "DownloadEngine.h"
 #include "StreamFileAllocationEntry.h"
-#include "InitiateConnectionCommandFactory.h"
-#include "CUIDCounter.h"
-#include "PieceStorage.h"
 #include "FileAllocationMan.h"
+#include "Request.h"
+
+namespace aria2 {
 
 StreamCheckIntegrityEntry::StreamCheckIntegrityEntry(const RequestHandle& currentRequest,
 						     RequestGroup* requestGroup,
@@ -68,3 +68,5 @@ Commands StreamCheckIntegrityEntry::onDownloadFinished(DownloadEngine* e)
 {
   return Commands();
 }
+
+} // namespace aria2
diff --git a/src/StreamCheckIntegrityEntry.h b/src/StreamCheckIntegrityEntry.h
index 55ee06d3..6c1ff7d5 100644
--- a/src/StreamCheckIntegrityEntry.h
+++ b/src/StreamCheckIntegrityEntry.h
@@ -38,26 +38,29 @@
 #include "PieceHashCheckIntegrityEntry.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class Request;
-typedef SharedHandle<Request> RequestHandle;
 
 class StreamCheckIntegrityEntry:public PieceHashCheckIntegrityEntry
 {
 private:
-  RequestHandle _currentRequest;
+  SharedHandle<Request> _currentRequest;
   Time _timer;
 public:
-  StreamCheckIntegrityEntry(const RequestHandle& currentRequest,
+  StreamCheckIntegrityEntry(const SharedHandle<Request>& currentRequest,
 			    RequestGroup* requestGroup,
 			    Command* nextCommand = 0);
 
   virtual ~StreamCheckIntegrityEntry();
 
-  virtual Commands onDownloadFinished(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadFinished(DownloadEngine* e);
 
-  virtual Commands onDownloadIncomplete(DownloadEngine* e);
+  virtual std::deque<Command*> onDownloadIncomplete(DownloadEngine* e);
 };
 
 typedef SharedHandle<StreamCheckIntegrityEntry> StreamCheckIntegrityEntryHandle;
 
+} // namespace aria2
+
 #endif // _D_STREAM_CHECK_INTEGRITY_ENTRY_H_
diff --git a/src/StreamFileAllocationEntry.cc b/src/StreamFileAllocationEntry.cc
index 0e89aa86..20a161cb 100644
--- a/src/StreamFileAllocationEntry.cc
+++ b/src/StreamFileAllocationEntry.cc
@@ -34,7 +34,6 @@
 /* copyright --> */
 #include "StreamFileAllocationEntry.h"
 #include "CUIDCounter.h"
-#include "Command.h"
 #include "DownloadEngine.h"
 #include "Option.h"
 #include "Request.h"
@@ -42,6 +41,8 @@
 #include "RequestGroup.h"
 #include "InitiateConnectionCommandFactory.h"
 
+namespace aria2 {
+
 StreamFileAllocationEntry::StreamFileAllocationEntry(const RequestHandle& currentRequest,
 						     RequestGroup* requestGroup,
 						     Command* nextCommand):
@@ -73,3 +74,5 @@ Commands StreamFileAllocationEntry::prepareForNextAction(DownloadEngine* e)
   }
   return commands;
 }
+
+} // namespace aria2
diff --git a/src/StreamFileAllocationEntry.h b/src/StreamFileAllocationEntry.h
index 96afc1e1..158c135b 100644
--- a/src/StreamFileAllocationEntry.h
+++ b/src/StreamFileAllocationEntry.h
@@ -38,24 +38,27 @@
 #include "FileAllocationEntry.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class Request;
-typedef SharedHandle<Request> RequestHandle;
 
 class StreamFileAllocationEntry : public FileAllocationEntry {
 private:
-  RequestHandle _currentRequest;
+  SharedHandle<Request> _currentRequest;
   Time _timer;
 public:
-  StreamFileAllocationEntry(const RequestHandle& currentRequest,
+  StreamFileAllocationEntry(const SharedHandle<Request>& currentRequest,
 			    RequestGroup* requestGroup,
 			    Command* nextCommand = 0);
 
   virtual ~StreamFileAllocationEntry();
 
-  virtual Commands prepareForNextAction(DownloadEngine* e);
+  virtual std::deque<Command*> prepareForNextAction(DownloadEngine* e);
 };
 
 typedef SharedHandle<StreamFileAllocationEntry> StreamFileAllocationEntryHandle;
-typedef deque<StreamFileAllocationEntryHandle> StreamFileAllocationEntries;
+typedef std::deque<StreamFileAllocationEntryHandle> StreamFileAllocationEntries;
+
+} // namespace aria2
 
 #endif // _D_STREAM_FILE_ALLOCATION_ENTRY_H_
diff --git a/src/StreamUriListParser.h b/src/StreamUriListParser.h
deleted file mode 100644
index f169f445..00000000
--- a/src/StreamUriListParser.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* <!-- copyright */
-/*
- * aria2 - The high speed download utility
- *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * In addition, as a special exception, the copyright holders give
- * permission to link the code of portions of this program with the
- * OpenSSL library under certain conditions as described in each
- * individual source file, and distribute linked combinations
- * including the two.
- * You must obey the GNU General Public License in all respects
- * for all of the code used other than OpenSSL.  If you modify
- * file(s) with this exception, you may extend this exception to your
- * version of the file(s), but you are not obligated to do so.  If you
- * do not wish to do so, delete this exception statement from your
- * version.  If you delete this exception statement from all source
- * files in the program, then also delete it here.
- */
-/* copyright --> */
-#ifndef _D_STREAM_URI_LIST_PARSER_H_
-#define _D_STREAM_URI_LIST_PARSER_H_
-
-#include "UriListParser.h"
-
-class StreamUriListParser : public UriListParser {
-private:
-  istream* _ifs;
-protected:
-  virtual istream& getInputStream()
-  {
-    return *_ifs;
-  }
-
-  virtual const istream& getInputStream() const
-  {
-    return *_ifs;
-  }
-public:
-  StreamUriListParser(istream& ifs):_ifs(&ifs) {}
-  
-  virtual ~StreamUriListParser() {}
-};
-
-#endif // _D_STREAM_URI_LIST_PARSER_H_
diff --git a/src/TagContainer.cc b/src/TagContainer.cc
index b21797d9..0dc41777 100644
--- a/src/TagContainer.cc
+++ b/src/TagContainer.cc
@@ -35,6 +35,9 @@
 #include "TagContainer.h"
 #include "TaggedItem.h"
 #include "Util.h"
+#include <algorithm>
+
+namespace aria2 {
 
 TagContainer::TagContainer() {}
 
@@ -45,11 +48,11 @@ TagContainer::~TagContainer() {}
 
 class SingleTagSearch {
 private:
-  string _tag;
+  std::string _tag;
 
   TaggedItems _result;
 public:
-  SingleTagSearch(const string& tag):_tag(tag) {}
+  SingleTagSearch(const std::string& tag):_tag(tag) {}
 
   void operator()(const TaggedItemHandle& item)
   {
@@ -64,18 +67,18 @@ public:
   }
 };
 
-TaggedItems TagContainer::search(const string& tag) const
+TaggedItems TagContainer::search(const std::string& tag) const
 {
-  return for_each(_taggedItems.begin(), _taggedItems.end(), SingleTagSearch(tag)).getResult();
+  return std::for_each(_taggedItems.begin(), _taggedItems.end(), SingleTagSearch(tag)).getResult();
 }
 
 class NameMatchForward {
 private:
-  string _name;
+  std::string _name;
 
   TaggedItems _result;
 public:
-  NameMatchForward(const string& name):_name(name) {}
+  NameMatchForward(const std::string& name):_name(name) {}
 
   void operator()(const TaggedItemHandle& item)
   {
@@ -90,14 +93,14 @@ public:
   }
 };
 
-TaggedItems TagContainer::nameMatchForward(const string& name) const
+TaggedItems TagContainer::nameMatchForward(const std::string& name) const
 {
-  return for_each(_taggedItems.begin(), _taggedItems.end(), NameMatchForward(name)).getResult();
+  return std::for_each(_taggedItems.begin(), _taggedItems.end(), NameMatchForward(name)).getResult();
 }
 
-TaggedItemHandle TagContainer::nameMatch(const string& name) const
+TaggedItemHandle TagContainer::nameMatch(const std::string& name) const
 {
-  TaggedItems::const_iterator itr = find(_taggedItems.begin(), _taggedItems.end(), TaggedItemHandle(new TaggedItem(name)));
+  TaggedItems::const_iterator itr = std::find(_taggedItems.begin(), _taggedItems.end(), TaggedItemHandle(new TaggedItem(name)));
   if(itr == _taggedItems.end()) {
     return 0;
   } else {
@@ -114,3 +117,5 @@ void TagContainer::addItem(const TaggedItemHandle& item)
 {
   _taggedItems.push_back(item);
 }
+
+} // namespace aria2
diff --git a/src/TagContainer.h b/src/TagContainer.h
index e454aea1..2720b451 100644
--- a/src/TagContainer.h
+++ b/src/TagContainer.h
@@ -36,31 +36,36 @@
 #define _D_TAG_CONTAINER_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <deque>
+
+namespace aria2 {
 
 class TaggedItem;
-typedef SharedHandle<TaggedItem> TaggedItemHandle;
-typedef deque<TaggedItemHandle> TaggedItems;
 
 class TagContainer {
 private:
-  TaggedItems _taggedItems;
+  std::deque<SharedHandle<TaggedItem> > _taggedItems;
 public:
   TagContainer();
 
-  TagContainer(const TaggedItems& items);
+  TagContainer(const std::deque<SharedHandle<TaggedItem> >& items);
 
   ~TagContainer();
   
-  void addItem(const TaggedItemHandle& item);
+  void addItem(const SharedHandle<TaggedItem>& item);
 
-  TaggedItems search(const string& tag) const;
+  std::deque<SharedHandle<TaggedItem> > search(const std::string& tag) const;
 
-  TaggedItems nameMatchForward(const string& name) const;
+  std::deque<SharedHandle<TaggedItem> > nameMatchForward(const std::string& name) const;
 
-  TaggedItemHandle nameMatch(const string& name) const;
+  SharedHandle<TaggedItem> nameMatch(const std::string& name) const;
 
-  const TaggedItems& getAllItems() const;
+  const std::deque<SharedHandle<TaggedItem> >& getAllItems() const;
 };
 
 typedef SharedHandle<TagContainer> TagContainerHandle;
+
+} // namespace aria2
+
 #endif // _D_TAG_CONTAINER_H_
diff --git a/src/TaggedItem.cc b/src/TaggedItem.cc
index 19a0bd49..4accb514 100644
--- a/src/TaggedItem.cc
+++ b/src/TaggedItem.cc
@@ -34,31 +34,34 @@
 /* copyright --> */
 #include "TaggedItem.h"
 #include <numeric>
+#include <algorithm>
+
+namespace aria2 {
 
 class Concat {
 private:
-  string _delim;
+  std::string _delim;
 public:
-  Concat(const string& delim = ""):_delim(delim) {}
+  Concat(const std::string& delim = ""):_delim(delim) {}
 
-  string operator()(const string& s1, const string& s2) const
+  std::string operator()(const std::string& s1, const std::string& s2) const
   {
     return s1+_delim+s2;
   }
 };
 
-string TaggedItem::toTagString() const
+std::string TaggedItem::toTagString() const
 {
   if(_tags.size()) {
-    return accumulate(_tags.begin()+1, _tags.end(), _tags.front(), Concat(","));
+    return std::accumulate(_tags.begin()+1, _tags.end(), _tags.front(), Concat(","));
   } else {
     return "";
   }
 }
 
-bool TaggedItem::hasTag(const string& tag) const
+bool TaggedItem::hasTag(const std::string& tag) const
 {
-  return find(_tags.begin(), _tags.end(), tag) != _tags.end();
+  return std::find(_tags.begin(), _tags.end(), tag) != _tags.end();
 }
 
 bool TaggedItem::operator<(const TaggedItem& item) const
@@ -70,3 +73,5 @@ bool TaggedItem::operator==(const TaggedItem& item) const
 {
   return _name == item._name;
 }
+
+} // namespace aria2
diff --git a/src/TaggedItem.h b/src/TaggedItem.h
index 4dca3ef6..bcfa4d87 100644
--- a/src/TaggedItem.h
+++ b/src/TaggedItem.h
@@ -36,30 +36,32 @@
 #define _D_TAGGED_ITEM_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <string>
+#include <deque>
 
-class TaggedItem;
-typedef SharedHandle<TaggedItem> TaggedItemHandle;
+namespace aria2 {
 
 class TaggedItem {
 private:
-  string _name;
+  std::string _name;
 
-  Strings _tags;
+  std::deque<std::string> _tags;
 public:
-  TaggedItem(const string& name):_name(name) {}
+  TaggedItem(const std::string& name):_name(name) {}
 
   virtual ~TaggedItem() {}
 
-  void addTag(const string& tag)
+  void addTag(const std::string& tag)
   {
     _tags.push_back(tag);
   }
 
-  string toTagString() const;
+  std::string toTagString() const;
 
-  bool hasTag(const string& tag) const;
+  bool hasTag(const std::string& tag) const;
 
-  const string& getName() const
+  const std::string& getName() const
   {
     return _name;
   }
@@ -69,5 +71,9 @@ public:
   bool operator==(const TaggedItem& item) const;
 };
 
-typedef deque<TaggedItemHandle> TaggedItems;
+typedef SharedHandle<TaggedItem> TaggedItemHandle;
+typedef std::deque<TaggedItemHandle> TaggedItems;
+
+} // namespace aria2
+
 #endif // _D_TAGGED_ITEM_H_
diff --git a/src/TimeA2.cc b/src/TimeA2.cc
index 68be1f62..4f029ddf 100644
--- a/src/TimeA2.cc
+++ b/src/TimeA2.cc
@@ -36,6 +36,8 @@
 #include "TimeA2.h"
 #include "Util.h"
 
+namespace aria2 {
+
 Time::Time() {
   reset();
 }
@@ -50,6 +52,14 @@ Time::Time(int32_t sec) {
 
 Time::~Time() {}
 
+Time& Time::operator=(const Time& time)
+{
+  if(this != &time) {
+    tv = time.tv;
+  }
+  return *this;
+}
+
 void Time::reset() {
   gettimeofday(&tv, 0);
 }
@@ -85,7 +95,29 @@ int64_t Time::differenceInMillis(const struct timeval& now) const
   return Util::difftv(now, tv)/1000;
 }
 
+bool Time::isZero() const
+{
+  return tv.tv_sec == 0 && tv.tv_usec == 0;
+}
+
+int64_t Time::getTimeInMicros() const
+{
+  return (int64_t)tv.tv_sec*1000*1000+tv.tv_usec;
+}
+
+int64_t Time::getTimeInMillis() const
+{
+  return (int64_t)tv.tv_sec*1000+tv.tv_usec/1000;
+}
+
+int32_t Time::getTime() const
+{
+  return tv.tv_sec;
+}
+
 void Time::setTimeInSec(int32_t sec) {
   tv.tv_sec = sec;
   tv.tv_usec = 0;
 }
+
+} // namespace aria2
diff --git a/src/TimeA2.h b/src/TimeA2.h
index 4310472f..3f64caa2 100644
--- a/src/TimeA2.h
+++ b/src/TimeA2.h
@@ -37,6 +37,9 @@
 
 #include "common.h"
 #include "a2time.h"
+#include <stdint.h>
+
+namespace aria2 {
 
 class Time {
 private:
@@ -50,12 +53,7 @@ public:
   Time(const Time& time);
   Time(int32_t sec);
 
-  Time& operator=(const Time& time) {
-    if(this != &time) {
-      tv = time.tv;
-    }
-    return *this;
-  }
+  Time& operator=(const Time& time);
 
   ~Time();
 
@@ -72,24 +70,20 @@ public:
   int64_t differenceInMillis(const struct timeval& now) const;
 
   // Returns true if this object's time value is zero.
-  bool isZero() const { return tv.tv_sec == 0 && tv.tv_usec == 0; }
+  bool isZero() const;
 
-  int64_t getTimeInMicros() const {
-    return (int64_t)tv.tv_sec*1000*1000+tv.tv_usec;
-  }
+  int64_t getTimeInMicros() const;
 
-  int64_t getTimeInMillis() const {
-    return (int64_t)tv.tv_sec*1000+tv.tv_usec/1000;
-  }
+  int64_t getTimeInMillis() const;
 
   // Returns this object's time value in seconds.
-  int32_t getTime() const {
-    return tv.tv_sec;
-  }
+  int32_t getTime() const;
 
   void setTimeInSec(int32_t sec);
 
   bool isNewer(const Time& time) const;
 };
 
+} // namespace aria2
+
 #endif // _D_TIME_H_
diff --git a/src/TimeBasedCommand.cc b/src/TimeBasedCommand.cc
index ac26bb2d..e2669e5d 100644
--- a/src/TimeBasedCommand.cc
+++ b/src/TimeBasedCommand.cc
@@ -35,6 +35,8 @@
 #include "TimeBasedCommand.h"
 #include "DownloadEngine.h"
 
+namespace aria2 {
+
 TimeBasedCommand::TimeBasedCommand(int32_t cuid, DownloadEngine* e, int32_t interval):
   Command(cuid), _e(e),_exit(false), _interval(interval) {}
 
@@ -60,3 +62,5 @@ bool TimeBasedCommand::execute()
   _e->commands.push_back(this);
   return false;
 }
+
+} // namespace aria2
diff --git a/src/TimeBasedCommand.h b/src/TimeBasedCommand.h
index b4829e5c..a2f95a0e 100644
--- a/src/TimeBasedCommand.h
+++ b/src/TimeBasedCommand.h
@@ -38,6 +38,8 @@
 #include "Command.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class DownloadEngine;
 
 class TimeBasedCommand : public Command
@@ -81,4 +83,6 @@ public:
   virtual bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_TIME_BASED_COMMAND_H_
diff --git a/src/TimeSeedCriteria.h b/src/TimeSeedCriteria.h
index 84eb63d8..b8561a3a 100644
--- a/src/TimeSeedCriteria.h
+++ b/src/TimeSeedCriteria.h
@@ -38,6 +38,8 @@
 #include "SeedCriteria.h"
 #include "TimeA2.h"
 
+namespace aria2 {
+
 class TimeSeedCriteria : public SeedCriteria {
 private:
   // How much time the client does seeding in seconds.
@@ -64,4 +66,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_TIME_SEED_CRITERIA_H_
diff --git a/src/TrackerWatcherCommand.cc b/src/TrackerWatcherCommand.cc
index 181c5a2b..f6ff1e4d 100644
--- a/src/TrackerWatcherCommand.cc
+++ b/src/TrackerWatcherCommand.cc
@@ -34,7 +34,12 @@
 /* copyright --> */
 #include "TrackerWatcherCommand.h"
 #include "DownloadEngine.h"
-#include "Util.h"
+#include "BtContext.h"
+#include "BtAnnounce.h"
+#include "BtRuntime.h"
+#include "PieceStorage.h"
+#include "PeerStorage.h"
+#include "Peer.h"
 #include "prefs.h"
 #include "message.h"
 #include "SingleFileDownloadContext.h"
@@ -43,10 +48,14 @@
 #include "CUIDCounter.h"
 #include "PeerInitiateConnectionCommand.h"
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include "RequestGroup.h"
 #include "Option.h"
-#include "DlRetryEx.h"
 #include "DlAbortEx.h"
+#include "Logger.h"
+#include <sstream>
+
+namespace aria2 {
 
 TrackerWatcherCommand::TrackerWatcherCommand(int32_t cuid,
 					     RequestGroup* requestGroup,
@@ -87,7 +96,7 @@ bool TrackerWatcherCommand::execute() {
     }
   } else if(_trackerRequestGroup->downloadFinished()){
     try {
-      string trackerResponse = getTrackerResponse(_trackerRequestGroup);
+      std::string trackerResponse = getTrackerResponse(_trackerRequestGroup);
 
       processTrackerResponse(trackerResponse);
       btAnnounce->announceSuccess();
@@ -113,9 +122,9 @@ bool TrackerWatcherCommand::execute() {
   return false;
 }
 
-string TrackerWatcherCommand::getTrackerResponse(const RequestGroupHandle& requestGroup)
+std::string TrackerWatcherCommand::getTrackerResponse(const RequestGroupHandle& requestGroup)
 {
-  stringstream strm;
+  std::stringstream strm;
   char data[2048];
   requestGroup->getPieceStorage()->getDiskAdaptor()->openFile();
   while(1) {
@@ -129,7 +138,7 @@ string TrackerWatcherCommand::getTrackerResponse(const RequestGroupHandle& reque
 }
 
 // TODO we have to deal with the exception thrown By BtAnnounce
-void TrackerWatcherCommand::processTrackerResponse(const string& trackerResponse)
+void TrackerWatcherCommand::processTrackerResponse(const std::string& trackerResponse)
 {
   btAnnounce->processAnnounceResponse(trackerResponse.c_str(),
 				      trackerResponse.size());
@@ -160,9 +169,9 @@ RequestGroupHandle TrackerWatcherCommand::createAnnounce() {
 }
 
 RequestGroupHandle
-TrackerWatcherCommand::createRequestGroup(const string& uri)
+TrackerWatcherCommand::createRequestGroup(const std::string& uri)
 {
-  Strings uris;
+  std::deque<std::string> uris;
   uris.push_back(uri);
   RequestGroupHandle rg = new RequestGroup(e->option, uris);
 
@@ -179,3 +188,5 @@ TrackerWatcherCommand::createRequestGroup(const string& uri)
   logger->info("Creating tracker request group GID#%d", rg->getGID());
   return rg;
 }
+
+} // namespace aria2
diff --git a/src/TrackerWatcherCommand.h b/src/TrackerWatcherCommand.h
index 7fbcf7f8..f5c59de8 100644
--- a/src/TrackerWatcherCommand.h
+++ b/src/TrackerWatcherCommand.h
@@ -39,9 +39,10 @@
 #include "BtContextAwareCommand.h"
 #include "RequestGroupAware.h"
 
+namespace aria2 {
+
 class DownloadEngine;
 class RequestGroup;
-typedef SharedHandle<RequestGroup> RequestGroupHandle;
 
 class TrackerWatcherCommand : public Command,
 			      public BtContextAwareCommand,
@@ -50,28 +51,30 @@ class TrackerWatcherCommand : public Command,
 private:
   DownloadEngine* e;
 
-  RequestGroupHandle _trackerRequestGroup;
+  SharedHandle<RequestGroup> _trackerRequestGroup;
   /**
    * Returns a command for announce request. Returns 0 if no announce request
    * is needed.
    */
-  RequestGroupHandle createRequestGroup(const string& url);
+  SharedHandle<RequestGroup> createRequestGroup(const std::string& url);
 
-  string getTrackerResponse(const RequestGroupHandle& requestGroup);
+  std::string getTrackerResponse(const SharedHandle<RequestGroup>& requestGroup);
 
-  void processTrackerResponse(const string& response);
+  void processTrackerResponse(const std::string& response);
 
 public:
   TrackerWatcherCommand(int32_t cuid,
 			RequestGroup* requestGroup,
 			DownloadEngine* e,
-			const BtContextHandle& btContext);
+			const SharedHandle<BtContext>& btContext);
 
   virtual ~TrackerWatcherCommand();
 
-  RequestGroupHandle createAnnounce();
+  SharedHandle<RequestGroup> createAnnounce();
 
   virtual bool execute();
 };
 
+} // namespace aria2
+
 #endif // _D_TRACKER_WATCHER_COMMAND_H_
diff --git a/src/TransferEncoding.h b/src/TransferEncoding.h
index 04d3056d..8a644029 100644
--- a/src/TransferEncoding.h
+++ b/src/TransferEncoding.h
@@ -36,6 +36,10 @@
 #define _D_TRANSFER_ENCODING_H_
 
 #include "common.h"
+#include "SharedHandle.h"
+#include <stdint.h>
+
+namespace aria2 {
 
 class TransferEncoding {
 public:
@@ -48,5 +52,7 @@ public:
 
 typedef SharedHandle<TransferEncoding> TransferEncodingHandle;
 
+} // namespace aria2
+
 #endif // _D_TRANSFER_ENCODING_H_
 
diff --git a/src/TransferStat.cc b/src/TransferStat.cc
index 95cef7b9..8ae54ee9 100644
--- a/src/TransferStat.cc
+++ b/src/TransferStat.cc
@@ -34,6 +34,8 @@
 /* copyright --> */
 #include "TransferStat.h"
 
+namespace aria2 {
+
 TransferStat operator+(const TransferStat& a, const TransferStat& b)
 {
   TransferStat c;
@@ -43,3 +45,5 @@ TransferStat operator+(const TransferStat& a, const TransferStat& b)
   c.sessionDownloadLength = a.sessionDownloadLength+b.sessionDownloadLength;
   return c;
 }
+
+} // namespace aria2
diff --git a/src/TransferStat.h b/src/TransferStat.h
index ac782d74..5761eaab 100644
--- a/src/TransferStat.h
+++ b/src/TransferStat.h
@@ -36,6 +36,9 @@
 #define _D_TRANSFER_STAT_H_
 
 #include "common.h"
+#include <stdint.h>
+
+namespace aria2 {
 
 class TransferStat {
 public:
@@ -118,4 +121,6 @@ public:
 
 TransferStat operator+(const TransferStat& a, const TransferStat& b);
 
+} // namespace aria2
+
 #endif // _D_TRANSFER_STAT_H_
diff --git a/src/TrueRequestGroupCriteria.h b/src/TrueRequestGroupCriteria.h
index 28ea8911..af9c8c8f 100644
--- a/src/TrueRequestGroupCriteria.h
+++ b/src/TrueRequestGroupCriteria.h
@@ -37,6 +37,8 @@
 
 #include "RequestGroupCriteria.h"
 
+namespace aria2 {
+
 class TrueRequestGroupCriteria:public RequestGroupCriteria
 {
 public:
@@ -50,4 +52,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_TRUE_REQUEST_GROUP_CRITERIA_H_
diff --git a/src/URLMetalinkParserState.cc b/src/URLMetalinkParserState.cc
index 8999bd3e..ce6e66d0 100644
--- a/src/URLMetalinkParserState.cc
+++ b/src/URLMetalinkParserState.cc
@@ -35,19 +35,23 @@
 #include "URLMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void URLMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					  const string& name,
-					  const map<string, string>& attrs)
+					  const std::string& name,
+					  const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 
 }
 
 void URLMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					const string& name,
-					const string& characters)
+					const std::string& name,
+					const std::string& characters)
 {
   stm->setURLOfResource(characters);
   stm->commitResourceTransaction();
   stm->setResourcesState();
 }
+
+} // namespace aria2
diff --git a/src/URLMetalinkParserState.h b/src/URLMetalinkParserState.h
index c1c9d77c..4c35261a 100644
--- a/src/URLMetalinkParserState.h
+++ b/src/URLMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class URLMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_URL_METALINK_PARSER_STATE_H_
diff --git a/src/UTPexExtensionMessage.cc b/src/UTPexExtensionMessage.cc
index c8395ed8..f1e9ffcd 100644
--- a/src/UTPexExtensionMessage.cc
+++ b/src/UTPexExtensionMessage.cc
@@ -38,16 +38,18 @@
 #include "Dictionary.h"
 #include "Data.h"
 #include "BencodeVisitor.h"
-#include "a2netcompat.h"
 #include "Util.h"
 #include "PeerMessageUtil.h"
 #include "BtRegistry.h"
+#include "PeerStorage.h"
 #include "CompactPeerListProcessor.h"
 #include "MetaFileUtil.h"
 #include "DlAbortEx.h"
 #include "message.h"
 
-const string UTPexExtensionMessage::EXTENSION_NAME = "ut_pex";
+namespace aria2 {
+
+const std::string UTPexExtensionMessage::EXTENSION_NAME = "ut_pex";
 
 UTPexExtensionMessage::UTPexExtensionMessage(uint8_t extensionMessageID):
   _extensionMessageID(extensionMessageID),
@@ -55,11 +57,11 @@ UTPexExtensionMessage::UTPexExtensionMessage(uint8_t extensionMessageID):
 
 UTPexExtensionMessage::~UTPexExtensionMessage() {}
 
-string UTPexExtensionMessage::getBencodedData()
+std::string UTPexExtensionMessage::getBencodedData()
 {
   SharedHandle<Dictionary> d = new Dictionary();
-  pair<string, string> freshPeerPair = createCompactPeerListAndFlag(_freshPeers);
-  pair<string, string> droppedPeerPair = createCompactPeerListAndFlag(_droppedPeers);
+  std::pair<std::string, std::string> freshPeerPair = createCompactPeerListAndFlag(_freshPeers);
+  std::pair<std::string, std::string> droppedPeerPair = createCompactPeerListAndFlag(_droppedPeers);
   d->put("added", new Data(freshPeerPair.first));
   d->put("added.f", new Data(freshPeerPair.second));
   d->put("dropped", new Data(droppedPeerPair.first));
@@ -69,10 +71,10 @@ string UTPexExtensionMessage::getBencodedData()
   return v.getBencodedData();
 }
 
-pair<string, string> UTPexExtensionMessage::createCompactPeerListAndFlag(const Peers& peers)
+std::pair<std::string, std::string> UTPexExtensionMessage::createCompactPeerListAndFlag(const Peers& peers)
 {
-  string addrstring;
-  string flagstring;
+  std::string addrstring;
+  std::string flagstring;
   for(Peers::const_iterator itr = peers.begin(); itr != peers.end(); ++itr) {
     char compact[6];
     if(PeerMessageUtil::createcompact(compact, (*itr)->ipaddr, (*itr)->port)) {
@@ -80,10 +82,10 @@ pair<string, string> UTPexExtensionMessage::createCompactPeerListAndFlag(const P
       flagstring += (*itr)->isSeeder() ? "2" : "0";
     }
   }
-  return pair<string, string>(addrstring, flagstring);
+  return std::pair<std::string, std::string>(addrstring, flagstring);
 }
 
-string UTPexExtensionMessage::toString() const
+std::string UTPexExtensionMessage::toString() const
 {
   return "ut_pex added="+Util::uitos(_freshPeers.size())+", dropped="+
     Util::uitos(_droppedPeers.size());
@@ -147,3 +149,5 @@ UTPexExtensionMessage::create(const BtContextHandle& btContext,
   }
   return msg;
 }
+
+} // namespace aria2
diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h
index ec7df1ee..4d670d8e 100644
--- a/src/UTPexExtensionMessage.h
+++ b/src/UTPexExtensionMessage.h
@@ -36,12 +36,13 @@
 #define _D_UT_PEX_EXTENSION_MESSAGE_H_
 
 #include "ExtensionMessage.h"
+#include <utility>
+#include <deque>
+
+namespace aria2 {
 
 class BtContext;
-typedef SharedHandle<BtContext> BtContextHandle;
 class Peer;
-typedef SharedHandle<Peer> PeerHandle;
-typedef deque<PeerHandle> Peers;
 class UTPexExtensionMessage;
 typedef SharedHandle<UTPexExtensionMessage> UTPexExtensionMessageHandle;
 
@@ -49,51 +50,54 @@ class UTPexExtensionMessage:public ExtensionMessage {
 private:
   uint8_t _extensionMessageID;
 
-  Peers _freshPeers;
+  std::deque<SharedHandle<Peer> > _freshPeers;
 
-  Peers _droppedPeers;
+  std::deque<SharedHandle<Peer> > _droppedPeers;
 
-  BtContextHandle _btContext;
+  SharedHandle<BtContext> _btContext;
 
-  pair<string, string> createCompactPeerListAndFlag(const Peers& peers);
+  std::pair<std::string, std::string>
+  createCompactPeerListAndFlag(const std::deque<SharedHandle<Peer> >& peers);
 
 public:
   UTPexExtensionMessage(uint8_t extensionMessageID);
 
   virtual ~UTPexExtensionMessage();
 
-  virtual string getBencodedData();
+  virtual std::string getBencodedData();
 
   virtual uint8_t getExtensionMessageID()
   {
     return _extensionMessageID;
   }
   
-  virtual const string& getExtensionName() const
+  virtual const std::string& getExtensionName() const
   {
     return EXTENSION_NAME;
   }
 
-  static const string EXTENSION_NAME;
+  static const std::string EXTENSION_NAME;
 
-  virtual string toString() const;
+  virtual std::string toString() const;
 
   virtual void doReceivedAction();
 
-  void addFreshPeer(const PeerHandle& peer);
+  void addFreshPeer(const SharedHandle<Peer>& peer);
 
-  const Peers& getFreshPeers() const;
+  const std::deque<SharedHandle<Peer> >& getFreshPeers() const;
 
-  void addDroppedPeer(const PeerHandle& peer);
+  void addDroppedPeer(const SharedHandle<Peer>& peer);
 
-  const Peers& getDroppedPeers() const;
+  const std::deque<SharedHandle<Peer> >& getDroppedPeers() const;
 
-  void setBtContext(const BtContextHandle& btContext);
+  void setBtContext(const SharedHandle<BtContext>& btContext);
 
-  static UTPexExtensionMessageHandle create(const BtContextHandle& btContext,
+  static UTPexExtensionMessageHandle create(const SharedHandle<BtContext>& btContext,
 					    const char* data, size_t len);
 };
 
 typedef SharedHandle<UTPexExtensionMessage> UTPexExtensionMessageHandle;
 
+} // namespace aria2
+
 #endif // _D_UT_PEX_EXTENSION_MESSAGE_H_
diff --git a/src/UnionSeedCriteria.h b/src/UnionSeedCriteria.h
index 68f88d4b..1246f26b 100644
--- a/src/UnionSeedCriteria.h
+++ b/src/UnionSeedCriteria.h
@@ -36,6 +36,9 @@
 #define _D_UNION_SEED_CRITERIA_H_
 
 #include "SeedCriteria.h"
+#include <algorithm>
+
+namespace aria2 {
 
 class UnionSeedCriteria : public SeedCriteria {
 private:
@@ -60,13 +63,13 @@ public:
 
     
   virtual void reset() {
-    for_each(criterion.begin(), criterion.end(), Reset());
+    std::for_each(criterion.begin(), criterion.end(), Reset());
   }
 
   virtual bool evaluate() {
-    SeedCriterion::iterator itr = find_if(criterion.begin(),
-					  criterion.end(),
-					  Eval());
+    SeedCriterion::iterator itr = std::find_if(criterion.begin(),
+					       criterion.end(),
+					       Eval());
     return itr != criterion.end();
   }
 
@@ -78,5 +81,7 @@ public:
     return criterion;
   }
 };
+
+} // namespace aria2
       
 #endif // _D_UNION_SEED_CRITERIA_H_
diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc
index 853cb648..d972aea6 100644
--- a/src/UnknownLengthPieceStorage.cc
+++ b/src/UnknownLengthPieceStorage.cc
@@ -38,8 +38,10 @@
 #include "prefs.h"
 #include "DefaultDiskWriterFactory.h"
 #include "DownloadContext.h"
-#include "PieceStorage.h"
 #include "Piece.h"
+#include "FileEntry.h"
+
+namespace aria2 {
 
 UnknownLengthPieceStorage::UnknownLengthPieceStorage(const DownloadContextHandle& downloadContext,
 						     const Option* option):
@@ -60,7 +62,7 @@ void UnknownLengthPieceStorage::initStorage()
   directDiskAdaptor->setDiskWriter(writer);
   directDiskAdaptor->setTotalLength(_downloadContext->getTotalLength());
   _diskAdaptor = directDiskAdaptor;
-  string storeDir = _downloadContext->getDir();
+  std::string storeDir = _downloadContext->getDir();
 //   if(storeDir == "") {
 //     storeDir = ".";
 //   }
@@ -170,3 +172,5 @@ void UnknownLengthPieceStorage::setDiskWriterFactory(const DiskWriterFactoryHand
 {
   _diskWriterFactory = diskWriterFactory;
 }
+
+} // namespace aria2
diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h
index bea423ba..f548cedf 100644
--- a/src/UnknownLengthPieceStorage.h
+++ b/src/UnknownLengthPieceStorage.h
@@ -37,31 +37,30 @@
 
 #include "PieceStorage.h"
 
+namespace aria2 {
+
 class Option;
 class DownloadContext;
-typedef SharedHandle<DownloadContext> DownloadContextHandle;
 class DiskWriterFactory;
-typedef SharedHandle<DiskWriterFactory> DiskWriterFactoryHandle;
 class DirectDiskAdaptor;
-typedef SharedHandle<DirectDiskAdaptor> DirectDiskAdaptorHandle;
 
 class UnknownLengthPieceStorage:public PieceStorage {
 private:
-  DownloadContextHandle _downloadContext;
+  SharedHandle<DownloadContext> _downloadContext;
 
   const Option* _option;
   
-  DirectDiskAdaptorHandle _diskAdaptor;
+  SharedHandle<DirectDiskAdaptor> _diskAdaptor;
 
-  DiskWriterFactoryHandle _diskWriterFactory;
+  SharedHandle<DiskWriterFactory> _diskWriterFactory;
 
   int64_t _totalLength;
 
   bool _downloadFinished;
 
-  PieceHandle _piece;
+  SharedHandle<Piece> _piece;
 public:
-  UnknownLengthPieceStorage(const DownloadContextHandle& downloadContext,
+  UnknownLengthPieceStorage(const SharedHandle<DownloadContext>& downloadContext,
 			    const Option* option);
 
   virtual ~UnknownLengthPieceStorage();
@@ -70,7 +69,7 @@ public:
    * Returns true if the peer has a piece that localhost doesn't have.
    * Otherwise returns false.
    */
-  virtual bool hasMissingPiece(const PeerHandle& peer)
+  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer)
   {
     abort();
   }
@@ -81,7 +80,7 @@ public:
    * from get the same piece. But in end game mode, same piece may be returned
    * to several commands.
    */
-  virtual PieceHandle getMissingPiece(const PeerHandle& peer)
+  virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer)
   {
     abort();
   }
@@ -92,14 +91,14 @@ public:
    * from get the same piece. But in end game mode, same piece may be returned
    * to several commands.
    */
-  virtual PieceHandle getMissingFastPiece(const PeerHandle& peer)
+  virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer)
   {
     abort();
   }
   /**
    * Returns a missing piece if available. Otherwise returns 0;
    */
-  virtual PieceHandle getMissingPiece();
+  virtual SharedHandle<Piece> getMissingPiece();
 
   /**
    * Returns a missing piece whose index is index.
@@ -107,23 +106,23 @@ public:
    * then returns 0.
    * Also returns 0 if any of missing piece is not available.
    */
-  virtual PieceHandle getMissingPiece(int32_t index);
+  virtual SharedHandle<Piece> getMissingPiece(int32_t index);
 
   /**
    * Returns the piece denoted by index.
    * No status of the piece is changed in this method.
    */
-  virtual PieceHandle getPiece(int32_t index);
+  virtual SharedHandle<Piece> getPiece(int32_t index);
 
   /**
    * Tells that the download of the specfied piece completes.
    */
-  virtual void completePiece(const PieceHandle& piece);
+  virtual void completePiece(const SharedHandle<Piece>& piece);
 
   /**
    * Tells that the download of the specified piece is canceled.
    */
-  virtual void cancelPiece(const PieceHandle& piece);
+  virtual void cancelPiece(const SharedHandle<Piece>& piece);
 
   /**
    * Returns true if the specified piece is already downloaded.
@@ -154,7 +153,7 @@ public:
     return getCompletedLength();
   }
   
-  virtual void setFileFilter(const Strings& filePaths) {}
+  virtual void setFileFilter(const std::deque<std::string>& filePaths) {}
 
   virtual void setFileFilter(IntSequence seq) {}
 
@@ -210,7 +209,7 @@ public:
     return false;
   }
 
-  virtual DiskAdaptorHandle getDiskAdaptor();
+  virtual SharedHandle<DiskAdaptor> getDiskAdaptor();
   
   virtual int32_t getPieceLength(int32_t index);
 
@@ -224,10 +223,10 @@ public:
    * Returns piece index which is not advertised by the caller command and
    * newer than lastCheckTime.
    */
-  virtual Integers getAdvertisedPieceIndexes(int32_t myCuid,
-					     const Time& lastCheckTime)
+  virtual std::deque<int32_t>
+  getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime)
   {
-    return Integers();
+    return std::deque<int32_t>();
   }
 
   /**
@@ -257,18 +256,20 @@ public:
    * Do nothing because loading in-flight piece is not supported for this
    * class.
    */
-  virtual void addInFlightPiece(const Pieces& pieces) {}
+  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces) {}
 
   virtual int32_t countInFlightPiece()
   {
     return 0;
   }
 
-  virtual Pieces getInFlightPieces();
+  virtual std::deque<SharedHandle<Piece> > getInFlightPieces();
 
-  void setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory);
+  void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
 };
 
 typedef SharedHandle<UnknownLengthPieceStorage> UnknownLengthPieceStorageHandle;
 
+} // namespace aria2
+
 #endif // _D_UNKNOWN_LENGTH_PIECE_STORAGE_H_
diff --git a/src/UriListParser.cc b/src/UriListParser.cc
index b5a06ebb..1b79070f 100644
--- a/src/UriListParser.cc
+++ b/src/UriListParser.cc
@@ -34,21 +34,25 @@
 /* copyright --> */
 #include "UriListParser.h"
 #include "Util.h"
+#include <istream>
 
-bool UriListParser::hasNext() const
-{
-  return getInputStream();
-}
+namespace aria2 {
 
-Strings UriListParser::next()
+UriListParser::UriListParser() {}
+
+UriListParser::~UriListParser() {}
+
+std::deque<std::string> UriListParser::parseNext(std::istream& in)
 {
-  string line;
-  while(getline(getInputStream(), line)) {
+  std::deque<std::string> uris;
+  std::string line;
+  while(getline(in, line)) {
     if(Util::trim(line) != "") {
-      Strings uris;
       Util::slice(uris, line, '\t', true);
       return uris;
     }
   }
-  return Strings();
+  return uris;
 }
+
+} // namespace aria2
diff --git a/src/UriListParser.h b/src/UriListParser.h
index 5356c728..3e4e5a47 100644
--- a/src/UriListParser.h
+++ b/src/UriListParser.h
@@ -36,21 +36,21 @@
 #define _D_URI_LIST_PARSER_H_
 
 #include "common.h"
-#include <istream>
+#include <string>
+#include <deque>
+#include <iosfwd>
+
+namespace aria2 {
 
 class UriListParser {
-protected:
-  virtual istream& getInputStream() = 0;
-  virtual const istream& getInputStream() const = 0;
-
 public:
-  UriListParser() {}
+  UriListParser();
 
-  virtual ~UriListParser() {}
+  ~UriListParser();
 
-  bool hasNext() const;
-
-  Strings next();
+  std::deque<std::string> parseNext(std::istream& in);
 };
 
+} // namespace aria2
+
 #endif // _D_URI_LIST_PARSER_H_
diff --git a/src/Util.cc b/src/Util.cc
index 186f012b..99890511 100644
--- a/src/Util.cc
+++ b/src/Util.cc
@@ -41,16 +41,15 @@
 #include "DlAbortEx.h"
 #include "BitfieldMan.h"
 #include "DefaultDiskWriter.h"
-#include "BinaryStream.h"
 #include "FatalException.h"
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
+#include "FileEntry.h"
 #include <signal.h>
+#include <cerrno>
+#include <cassert>
+#include <cstring>
 #include <iomanip>
 #include <sstream>
-
+#include <algorithm>
 #ifndef HAVE_SLEEP
 # ifdef HAVE_WINSOCK_H
 #  define WIN32_LEAN_AND_MEAN
@@ -58,10 +57,12 @@
 # endif // HAVE_WINSOCK_H
 #endif // HAVE_SLEEP
 
+namespace aria2 {
+
 template<typename T>
-string uint2str(T value, bool comma)
+std::string uint2str(T value, bool comma)
 {
-  string str;
+  std::string str;
   if(value == 0) {
     str = "0";
     return str;
@@ -80,14 +81,14 @@ string uint2str(T value, bool comma)
 }
 
 template<typename T>
-string int2str(T value, bool comma)
+std::string int2str(T value, bool comma)
 {
   bool flag = false;
   if(value < 0) {
     flag = true;
     value = -value;
   }
-  string str = uint2str<T>(value, comma);
+  std::string str = uint2str<T>(value, comma);
   if(flag) {
     str.insert(str.begin(), '-');
   }
@@ -96,53 +97,53 @@ string int2str(T value, bool comma)
 
 
 
-string Util::uitos(uint16_t value, bool comma)
+std::string Util::uitos(uint16_t value, bool comma)
 {
   return uint2str<uint16_t>(value, comma);
 }
 
-string Util::itos(int16_t value, bool comma)
+std::string Util::itos(int16_t value, bool comma)
 {
   return int2str<int16_t>(value, comma);
 }
 
-string Util::uitos(uint32_t value, bool comma)
+std::string Util::uitos(uint32_t value, bool comma)
 {
   return uint2str<uint32_t>(value, comma);
 }
 
-string Util::itos(int32_t value, bool comma)
+std::string Util::itos(int32_t value, bool comma)
 {
   return int2str<int32_t>(value, comma);
 }
 
-string Util::ullitos(uint64_t value, bool comma)
+std::string Util::ullitos(uint64_t value, bool comma)
 {
   return uint2str<uint64_t>(value, comma);
 }
 
-string Util::llitos(int64_t value, bool comma)
+std::string Util::llitos(int64_t value, bool comma)
 {
   return int2str<int64_t>(value, comma);
 }
 
-string Util::trim(const string& src, const string& trimCharset)
+std::string Util::trim(const std::string& src, const std::string& trimCharset)
 {
-  string::size_type sp = src.find_first_not_of(trimCharset);
-  string::size_type ep = src.find_last_not_of(trimCharset);
-  if(sp == string::npos || ep == string::npos) {
+  std::string::size_type sp = src.find_first_not_of(trimCharset);
+  std::string::size_type ep = src.find_last_not_of(trimCharset);
+  if(sp == std::string::npos || ep == std::string::npos) {
     return "";
   } else {
     return src.substr(sp, ep-sp+1);
   }
 }
 
-void Util::split(pair<string, string>& hp, const string& src, char delim)
+void Util::split(std::pair<std::string, std::string>& hp, const std::string& src, char delim)
 {
   hp.first = "";
   hp.second = "";
-  string::size_type p = src.find(delim);
-  if(p == string::npos) {
+  std::string::size_type p = src.find(delim);
+  if(p == std::string::npos) {
     hp.first = src;
     hp.second = "";
   } else {
@@ -151,13 +152,13 @@ void Util::split(pair<string, string>& hp, const string& src, char delim)
   }
 }
 
-pair<string, string> Util::split(const string& src, const string& delims)
+std::pair<std::string, std::string> Util::split(const std::string& src, const std::string& delims)
 {
-  pair<string, string> hp;
+  std::pair<std::string, std::string> hp;
   hp.first = "";
   hp.second = "";
-  string::size_type p = src.find_first_of(delims);
-  if(p == string::npos) {
+  std::string::size_type p = src.find_first_of(delims);
+  if(p == std::string::npos) {
     hp.first = src;
     hp.second = "";
   } else {
@@ -182,12 +183,12 @@ int32_t Util::difftvsec(struct timeval tv1, struct timeval tv2) {
   return tv1.tv_sec-tv2.tv_sec;
 }
 
-void Util::slice(Strings& result, const string& src, char delim, bool doTrim) {
-  string::size_type p = 0;
+void Util::slice(std::deque<std::string>& result, const std::string& src, char delim, bool doTrim) {
+  std::string::size_type p = 0;
   while(1) {
-    string::size_type np = src.find(delim, p);
-    if(np == string::npos) {
-      string term = src.substr(p);
+    std::string::size_type np = src.find(delim, p);
+    if(np == std::string::npos) {
+      std::string term = src.substr(p);
       if(doTrim) {
 	term = trim(term);
       }
@@ -196,7 +197,7 @@ void Util::slice(Strings& result, const string& src, char delim, bool doTrim) {
       }
       break;
     }
-    string term = src.substr(p, np-p);
+    std::string term = src.substr(p, np-p);
     if(doTrim) {
       term = trim(term);
     }
@@ -207,7 +208,7 @@ void Util::slice(Strings& result, const string& src, char delim, bool doTrim) {
   } 
 }
 
-bool Util::startsWith(const string& target, const string& part) {
+bool Util::startsWith(const std::string& target, const std::string& part) {
   if(target.size() < part.size()) {
     return false;
   }
@@ -221,7 +222,7 @@ bool Util::startsWith(const string& target, const string& part) {
   }
 }
 
-bool Util::endsWith(const string& target, const string& part) {
+bool Util::endsWith(const std::string& target, const std::string& part) {
   if(target.size() < part.size()) {
     return false;
   }
@@ -235,14 +236,14 @@ bool Util::endsWith(const string& target, const string& part) {
   }
 }
 
-string Util::replace(const string& target, const string& oldstr, const string& newstr) {
+std::string Util::replace(const std::string& target, const std::string& oldstr, const std::string& newstr) {
   if(target == "" || oldstr == "" ) {
     return target;
   }
-  string result;
-  string::size_type p = 0;
-  string::size_type np = target.find(oldstr);
-  while(np != string::npos) {
+  std::string result;
+  std::string::size_type p = 0;
+  std::string::size_type np = target.find(oldstr);
+  while(np != std::string::npos) {
     result += target.substr(p, np-p)+newstr;
     p = np+oldstr.size();
     np = target.find(oldstr, p);
@@ -268,8 +269,8 @@ bool Util::shouldUrlencode(const char c)
 	   '@' == c || '&' == c || '=' == c || '+' == c);	   
 }
 
-string Util::urlencode(const unsigned char* target, int32_t len) {
-  string dest;
+std::string Util::urlencode(const unsigned char* target, int32_t len) {
+  std::string dest;
   for(int32_t i = 0; i < len; i++) {
     if(shouldUrlencode(target[i])) {
       char temp[4];
@@ -283,8 +284,8 @@ string Util::urlencode(const unsigned char* target, int32_t len) {
   return dest;
 }
 
-string Util::torrentUrlencode(const unsigned char* target, int32_t len) {
-  string dest;
+std::string Util::torrentUrlencode(const unsigned char* target, int32_t len) {
+  std::string dest;
   for(int32_t i = 0; i < len; i++) {
     if('0' <= target[i] && target[i] <= '9' ||
        'A' <= target[i] && target[i] <= 'Z' ||
@@ -300,14 +301,14 @@ string Util::torrentUrlencode(const unsigned char* target, int32_t len) {
   return dest;
 }
 
-string Util::urldecode(const string& target) {
-  string result;
-  for(string::const_iterator itr = target.begin();
+std::string Util::urldecode(const std::string& target) {
+  std::string result;
+  for(std::string::const_iterator itr = target.begin();
       itr != target.end(); itr++) {
     if(*itr == '%') {
       if(itr+1 != target.end() && itr+2 != target.end() &&
 	 isxdigit(*(itr+1)) && isxdigit(*(itr+2))) {
-	result += Util::parseInt(string(itr+1, itr+3), 16);
+	result += Util::parseInt(std::string(itr+1, itr+3), 16);
 	itr += 2;
       } else {
 	result += *itr;
@@ -319,28 +320,28 @@ string Util::urldecode(const string& target) {
   return result;
 }
 
-string Util::toHex(const unsigned char* src, int32_t len) {
+std::string Util::toHex(const unsigned char* src, int32_t len) {
   char* temp = new char[len*2+1];
   for(int32_t i = 0; i < len; i++) {
     sprintf(temp+i*2, "%02x", src[i]);
   }
   temp[len*2] = '\0';
-  string hex = temp;
+  std::string hex = temp;
   delete [] temp;
   return hex;
 }
 
-FILE* Util::openFile(const string& filename, const string& mode) {
+FILE* Util::openFile(const std::string& filename, const std::string& mode) {
   FILE* file = fopen(filename.c_str(), mode.c_str());
   return file;
 }
 
-void Util::fileCopy(const string& dest, const string& src) {
+void Util::fileCopy(const std::string& dest, const std::string& src) {
   File file(src);
   rangedFileCopy(dest, src, 0, file.size());
 }
 
-void Util::rangedFileCopy(const string& dest, const string& src, int64_t srcOffset, int64_t length)
+void Util::rangedFileCopy(const std::string& dest, const std::string& src, int64_t srcOffset, int64_t length)
 {
   int32_t bufSize = 4096;
   unsigned char buf[bufSize];
@@ -387,8 +388,8 @@ bool Util::isPowerOf(int32_t num, int32_t base) {
   return false;
 }
 
-string Util::secfmt(int32_t sec) {
-  string str;
+std::string Util::secfmt(int32_t sec) {
+  std::string str;
   if(sec >= 3600) {
     str = itos(sec/3600)+"h";
     sec %= 3600;
@@ -425,14 +426,14 @@ int32_t getNum(const char* buf, int32_t offset, int32_t length) {
   return x;
 }
 
-void unfoldSubRange(const string& src, Integers& range) {
+void unfoldSubRange(const std::string& src, std::deque<int32_t>& range) {
   if(src.empty()) {
     return;
   }
-  string::size_type p = src.find_first_of(",-");
+  std::string::size_type p = src.find_first_of(",-");
   if(p == 0) {
     return;
-  } else if(p == string::npos) {
+  } else if(p == std::string::npos) {
     range.push_back(atoi(src.c_str()));
   } else {
     if(src.at(p) == ',') {
@@ -441,8 +442,8 @@ void unfoldSubRange(const string& src, Integers& range) {
       unfoldSubRange(src.substr(p+1), range);
     } else if(src.at(p) == '-') {
       int32_t rightNumBegin = p+1;
-      string::size_type nextDelim = src.find_first_of(",", rightNumBegin);
-      if(nextDelim == string::npos) {
+      std::string::size_type nextDelim = src.find_first_of(",", rightNumBegin);
+      if(nextDelim == std::string::npos) {
 	nextDelim = src.size();
       }
       int32_t left = getNum(src.c_str(), 0, p);
@@ -457,15 +458,15 @@ void unfoldSubRange(const string& src, Integers& range) {
   }
 }
 
-void Util::unfoldRange(const string& src, Integers& range) {
+void Util::unfoldRange(const std::string& src, std::deque<int32_t>& range) {
   unfoldSubRange(src, range);
-  sort(range.begin(), range.end());
-  range.erase(unique(range.begin(), range.end()), range.end());
+  std::sort(range.begin(), range.end());
+  range.erase(std::unique(range.begin(), range.end()), range.end());
 }
 
-int32_t Util::parseInt(const string& s, int32_t base)
+int32_t Util::parseInt(const std::string& s, int32_t base)
 {
-  string trimed = Util::trim(s);
+  std::string trimed = Util::trim(s);
   if(trimed.empty()) {
     throw new DlAbortEx(MSG_STRING_INTEGER_CONVERSION_FAILURE,
 			"empty string");
@@ -483,9 +484,9 @@ int32_t Util::parseInt(const string& s, int32_t base)
   return v;
 }
 
-int64_t Util::parseLLInt(const string& s, int32_t base)
+int64_t Util::parseLLInt(const std::string& s, int32_t base)
 {
-  string trimed = Util::trim(s);
+  std::string trimed = Util::trim(s);
   if(trimed.empty()) {
     throw new DlAbortEx(MSG_STRING_INTEGER_CONVERSION_FAILURE,
 			"empty string");
@@ -503,21 +504,21 @@ int64_t Util::parseLLInt(const string& s, int32_t base)
   return v;
 }
 
-IntSequence Util::parseIntRange(const string& src)
+IntSequence Util::parseIntRange(const std::string& src)
 {
   IntSequence::Values values;
-  string temp = src;
+  std::string temp = src;
   while(temp.size()) {
-    pair<string, string> p = Util::split(temp, ",");
+    std::pair<std::string, std::string> p = Util::split(temp, ",");
     temp = p.second;
     if(p.first.empty()) {
       continue;
     }
-    if(p.first.find("-") == string::npos) {
+    if(p.first.find("-") == std::string::npos) {
       int32_t v = Util::parseInt(p.first.c_str());
       values.push_back(IntSequence::Value(v, v+1));
     } else {
-      pair<string, string> vp = Util::split(p.first.c_str(), "-");
+      std::pair<std::string, std::string> vp = Util::split(p.first.c_str(), "-");
       if(vp.first.empty() || vp.second.empty()) {
 	throw new DlAbortEx(MSG_INCOMPLETE_RANGE, p.first.c_str());
       }
@@ -529,14 +530,14 @@ IntSequence Util::parseIntRange(const string& src)
   return values;
 }
 
-string Util::getContentDispositionFilename(const string& header) {
-  string keyName = "filename=";
-  string::size_type attributesp = header.find(keyName);
-  if(attributesp == string::npos) {
+std::string Util::getContentDispositionFilename(const std::string& header) {
+  std::string keyName = "filename=";
+  std::string::size_type attributesp = header.find(keyName);
+  if(attributesp == std::string::npos) {
     return "";
   }
-  string::size_type filenamesp = attributesp+strlen(keyName.c_str());
-  string::size_type filenameep;
+  std::string::size_type filenamesp = attributesp+strlen(keyName.c_str());
+  std::string::size_type filenameep;
   if(filenamesp == header.size()) {
     return "";
   }
@@ -547,7 +548,7 @@ string Util::getContentDispositionFilename(const string& header) {
   } else {
     filenameep = header.find(';', filenamesp);
   }
-  if(filenameep == string::npos) {
+  if(filenameep == std::string::npos) {
     filenameep = header.size();
   }
   return trim(header.substr(filenamesp, filenameep-filenamesp), "\r\n '\"");
@@ -580,9 +581,9 @@ int32_t Util::countBit(uint32_t n) {
     nbits[(n >> 24)&0xffu];
 }
 
-string Util::randomAlpha(int32_t length, const RandomizerHandle& randomizer) {
+std::string Util::randomAlpha(int32_t length, const RandomizerHandle& randomizer) {
   static const char *random_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  string str;
+  std::string str;
   for(int32_t i = 0; i < length; i++) {
     int32_t index = randomizer->getRandomNumber(strlen(random_chars));
     str += random_chars[index];
@@ -590,19 +591,19 @@ string Util::randomAlpha(int32_t length, const RandomizerHandle& randomizer) {
   return str;
 }
 
-string Util::toUpper(const string& src) {
-  string temp = src;
-  transform(temp.begin(), temp.end(), temp.begin(), ::toupper);
+std::string Util::toUpper(const std::string& src) {
+  std::string temp = src;
+  std::transform(temp.begin(), temp.end(), temp.begin(), ::toupper);
   return temp;
 }
 
-string Util::toLower(const string& src) {
-  string temp = src;
-  transform(temp.begin(), temp.end(), temp.begin(), ::tolower);
+std::string Util::toLower(const std::string& src) {
+  std::string temp = src;
+  std::transform(temp.begin(), temp.end(), temp.begin(), ::tolower);
   return temp;
 }
 
-bool Util::isNumbersAndDotsNotation(const string& name) {
+bool Util::isNumbersAndDotsNotation(const std::string& name) {
   struct sockaddr_in sockaddr;
   if(inet_aton(name.c_str(), &sockaddr.sin_addr)) {
     return true;
@@ -634,7 +635,7 @@ void Util::indexRange(int32_t& startIndex, int32_t& endIndex,
   endIndex = _endIndex;
 }
 
-string Util::getHomeDir()
+std::string Util::getHomeDir()
 {
   const char* p = getenv("HOME");
   if(p) {
@@ -644,12 +645,12 @@ string Util::getHomeDir()
   }
 }
 
-int64_t Util::getRealSize(const string& sizeWithUnit)
+int64_t Util::getRealSize(const std::string& sizeWithUnit)
 {
-  string::size_type p = sizeWithUnit.find_first_of("KM");
-  string size;
+  std::string::size_type p = sizeWithUnit.find_first_of("KM");
+  std::string size;
   int32_t mult = 1;
-  if(p == string::npos) {
+  if(p == std::string::npos) {
     size = sizeWithUnit;
   } else {
     if(sizeWithUnit[p] == 'K') {
@@ -670,7 +671,7 @@ int64_t Util::getRealSize(const string& sizeWithUnit)
   return v*mult;
 }
 
-string Util::abbrevSize(int64_t size)
+std::string Util::abbrevSize(int64_t size)
 {
   if(size < 1024) {
     return Util::llitos(size, true);
@@ -687,7 +688,7 @@ string Util::abbrevSize(int64_t size)
   return Util::llitos(size, true)+"."+Util::itos(r*10/1024)+units[i]+"i";
 }
 
-time_t Util::httpGMT(const string& httpStdTime)
+time_t Util::httpGMT(const std::string& httpStdTime)
 {
   struct tm tm;
   memset(&tm, 0, sizeof(tm));
@@ -696,7 +697,7 @@ time_t Util::httpGMT(const string& httpStdTime)
   return thetime;
 }
 
-void Util::toStream(ostream& os, const FileEntries& fileEntries)
+void Util::toStream(std::ostream& os, const FileEntries& fileEntries)
 {
   os << _("Files:") << "\n";
   os << "idx|path/length" << "\n";
@@ -704,7 +705,7 @@ void Util::toStream(ostream& os, const FileEntries& fileEntries)
   int32_t count = 1;
   for(FileEntries::const_iterator itr = fileEntries.begin();
       itr != fileEntries.end(); count++, itr++) {
-    os << setw(3) << count << "|" << (*itr)->getPath() << "\n";
+    os << std::setw(3) << count << "|" << (*itr)->getPath() << "\n";
     os << "   |" << Util::abbrevSize((*itr)->getLength()) << "B" << "\n";
     os << "---+---------------------------------------------------------------------------" << "\n";
   }
@@ -757,7 +758,7 @@ void Util::usleep(long microseconds) {
 #endif
 }
 
-bool Util::isNumber(const string& what)
+bool Util::isNumber(const std::string& what)
 {
   if(what.empty()) {
     return false;
@@ -770,7 +771,7 @@ bool Util::isNumber(const string& what)
   return true;
 }
 
-bool Util::isLowercase(const string& what)
+bool Util::isLowercase(const std::string& what)
 {
   if(what.empty()) {
     return false;
@@ -783,7 +784,7 @@ bool Util::isLowercase(const string& what)
   return true;
 }
 
-bool Util::isUppercase(const string& what)
+bool Util::isUppercase(const std::string& what)
 {
   if(what.empty()) {
     return false;
@@ -796,7 +797,7 @@ bool Util::isUppercase(const string& what)
   return true;
 }
 
-int32_t Util::alphaToNum(const string& alphabets)
+int32_t Util::alphaToNum(const std::string& alphabets)
 {
   if(alphabets.empty()) {
     return 0;
@@ -815,7 +816,7 @@ int32_t Util::alphaToNum(const string& alphabets)
   return num;
 }
 
-void Util::mkdirs(const string& dirpath)
+void Util::mkdirs(const std::string& dirpath)
 {
   File dir(dirpath);
   if(dir.isDir()) {
@@ -837,9 +838,9 @@ void Util::convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
   }
 }
 
-string Util::toString(const BinaryStreamHandle& binaryStream)
+std::string Util::toString(const BinaryStreamHandle& binaryStream)
 {
-  stringstream strm;
+  std::stringstream strm;
   char data[2048];
   while(1) {
     int32_t dataLength = binaryStream->readData((unsigned char*)data, sizeof(data), strm.tellp());
@@ -865,3 +866,5 @@ void* Util::allocateAlignedMemory(size_t alignment, size_t size)
   return buffer;
 }
 #endif // HAVE_POSIX_MEMALIGN
+
+} // namespace aria2
diff --git a/src/Util.h b/src/Util.h
index bf531b58..41de9287 100644
--- a/src/Util.h
+++ b/src/Util.h
@@ -36,34 +36,42 @@
 #define _D_UTIL_H_
 
 #include "common.h"
-#include "a2time.h"
-#include "FileEntry.h"
+#include "SharedHandle.h"
 #include "IntSequence.h"
+#include <sys/time.h>
+#include <string>
 #include <utility>
 #include <deque>
-#include <ostream>
+#include <iosfwd>
+
+namespace aria2 {
 
 class Randomizer;
-typedef SharedHandle<Randomizer> RandomizerHandle;
 class BitfieldMan;
 class BinaryStream;
-typedef SharedHandle<BinaryStream> BinaryStreamHandle;
+class FileEntry;
 
 #define STRTOLL(X) strtoll(X, (char**)NULL, 10)
 
 #define START_INDEX(OFFSET, PIECE_LENGTH) ((OFFSET)/(PIECE_LENGTH))
 #define END_INDEX(OFFSET, LENGTH, PIECE_LENGTH) (((OFFSET)+(LENGTH)-1)/(PIECE_LENGTH))
 
+#define DIV_FLOOR(X,Y) ((X)/(Y)+((X)%(Y)? 1:0))
+
 class Util {
 public:
-  static void split(pair<string, string>& hp, const string& src, char delim);
-  static pair<string, string> split(const string& src, const string& delims);
-  static string llitos(int64_t value, bool comma = false);
-  static string ullitos(uint64_t value, bool comma = false);
-  static string itos(int32_t value, bool comma = false);
-  static string uitos(uint32_t value, bool comma = false);
-  static string itos(int16_t value, bool comma = false);
-  static string uitos(uint16_t value, bool comma = false);
+  static void split(std::pair<std::string, std::string>& hp,
+		    const std::string& src, char delim);
+
+  static std::pair<std::string, std::string>
+  split(const std::string& src, const std::string& delims);
+
+  static std::string llitos(int64_t value, bool comma = false);
+  static std::string ullitos(uint64_t value, bool comma = false);
+  static std::string itos(int32_t value, bool comma = false);
+  static std::string uitos(uint32_t value, bool comma = false);
+  static std::string itos(int16_t value, bool comma = false);
+  static std::string uitos(uint16_t value, bool comma = false);
 
   /**
    * Computes difference in micro-seconds between tv1 and tv2,
@@ -76,68 +84,70 @@ public:
    * Take a string src which is a deliminated list and add its elements
    * into result. result is not cleared before conversion begins.
    */
-  static void slice(Strings& result, const string& src, char delim, bool trim = false);
+  static void slice(std::deque<std::string>& result, const std::string& src,
+		    char delim, bool trim = false);
   
-  static string trim(const string& src, const string& trimCharset = "\r\n\t ");
+  static std::string trim(const std::string& src, const std::string& trimCharset = "\r\n\t ");
 
-  static bool startsWith(const string& target, const string& part);
+  static bool startsWith(const std::string& target, const std::string& part);
 
-  static bool endsWith(const string& target, const string& part);
+  static bool endsWith(const std::string& target, const std::string& part);
 
-  static string replace(const string& target, const string& oldstr, const string& newstr);
+  static std::string replace(const std::string& target, const std::string& oldstr, const std::string& newstr);
 
-  static string urlencode(const unsigned char* target, int32_t len);
+  static std::string urlencode(const unsigned char* target, int32_t len);
 
-  static string urlencode(const string& target)
+  static std::string urlencode(const std::string& target)
   {
     return urlencode((const unsigned char*)target.c_str(), target.size());
   }
 
   static bool shouldUrlencode(const char c);
 
-  static string urldecode(const string& target);
+  static std::string urldecode(const std::string& target);
 
-  static string torrentUrlencode(const unsigned char* target, int32_t len);
+  static std::string torrentUrlencode(const unsigned char* target, int32_t len);
 
-  static string toHex(const unsigned char* src, int32_t len);
+  static std::string toHex(const unsigned char* src, int32_t len);
 
-  static string toHex(const string& src)
+  static std::string toHex(const std::string& src)
   {
     return toHex(reinterpret_cast<const unsigned char*>(src.c_str()), src.size());
   }
 
-  static FILE* openFile(const string& filename, const string& mode);
+  static FILE* openFile(const std::string& filename, const std::string& mode);
 
-  static void fileCopy(const string& destFile, const string& src);
+  static void fileCopy(const std::string& destFile, const std::string& src);
 
-  static void rangedFileCopy(const string& destFile, const string& src, int64_t srcOffset, int64_t length);
+  static void rangedFileCopy(const std::string& destFile, const std::string& src, int64_t srcOffset, int64_t length);
 
   static bool isPowerOf(int32_t num, int32_t base);
 
-  static string secfmt(int32_t sec);
+  static std::string secfmt(int32_t sec);
 
   static int32_t expandBuffer(char** pbuf, int32_t curLength, int32_t newLength);
 
-  static void unfoldRange(const string& src, Integers& range);
+  static void unfoldRange(const std::string& src, std::deque<int32_t>& range);
 
-  static int32_t parseInt(const string& s, int32_t base = 10);
+  static int32_t parseInt(const std::string& s, int32_t base = 10);
 
-  static int64_t parseLLInt(const string& s, int32_t base = 10);
+  static int64_t parseLLInt(const std::string& s, int32_t base = 10);
 
-  static IntSequence parseIntRange(const string& src);
+  static IntSequence parseIntRange(const std::string& src);
 
   // this function temporarily put here
-  static string getContentDispositionFilename(const string& header);
+  static std::string getContentDispositionFilename(const std::string& header);
 
   static int32_t countBit(uint32_t n);
   
-  static string randomAlpha(int32_t length, const RandomizerHandle& randomizer);
+  static std::string randomAlpha(int32_t length,
+				 const SharedHandle<Randomizer>& randomizer);
   
-  static string toUpper(const string& src);
+  static std::string toUpper(const std::string& src);
 
-  static string toLower(const string& src);
+  static std::string toLower(const std::string& src);
 
-  static bool isNumbersAndDotsNotation(const string& name);
+  static bool isNumbersAndDotsNotation(const std::string& name);
 
   static void setGlobalSignalHandler(int32_t signal, void (*handler)(int), int32_t flags);
 
@@ -145,38 +155,41 @@ public:
 			 int64_t offset,
 			 int32_t srcLength, int32_t destLength);
 
-  static string getHomeDir();
+  static std::string getHomeDir();
 
-  static int64_t getRealSize(const string& sizeWithUnit);
+  static int64_t getRealSize(const std::string& sizeWithUnit);
 
-  static string abbrevSize(int64_t size);
+  static std::string abbrevSize(int64_t size);
 
-  static time_t httpGMT(const string& httpTimeFormat);
+  static time_t httpGMT(const std::string& httpTimeFormat);
 
-  static void toStream(ostream& os, const FileEntries& entries);
+  static void toStream(std::ostream& os,
+		       const std::deque<SharedHandle<FileEntry> >& entries);
 
   static void sleep(long seconds);
 
   static void usleep(long microseconds);
 
-  static bool isNumber(const string& what);
+  static bool isNumber(const std::string& what);
 
-  static bool isLowercase(const string& what);
+  static bool isLowercase(const std::string& what);
 
-  static bool isUppercase(const string& what);
+  static bool isUppercase(const std::string& what);
 
-  static int32_t alphaToNum(const string& alphabets);
+  static int32_t alphaToNum(const std::string& alphabets);
 
-  static void mkdirs(const string& dirpath);
+  static void mkdirs(const std::string& dirpath);
 
   static void convertBitfield(BitfieldMan* dest, const BitfieldMan* src);
 
   // binaryStream has to be opened before calling this function.
-  static string toString(const BinaryStreamHandle& binaryStream);
+  static std::string toString(const SharedHandle<BinaryStream>& binaryStream);
 
 #ifdef HAVE_POSIX_MEMALIGN
   static void* allocateAlignedMemory(size_t alignment, size_t size);
 #endif // HAVE_POSIX_MEMALIGN
 };
 
+} // namespace aria2
+
 #endif // _D_UTIL_H_
diff --git a/src/VerificationMetalinkParserState.cc b/src/VerificationMetalinkParserState.cc
index a2bd0476..c962b6d2 100644
--- a/src/VerificationMetalinkParserState.cc
+++ b/src/VerificationMetalinkParserState.cc
@@ -37,17 +37,19 @@
 #include "DlAbortEx.h"
 #include "Util.h"
 
+namespace aria2 {
+
 void VerificationMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-						   const string& name,
-						   const map<string, string>& attrs)
+						   const std::string& name,
+						   const std::map<std::string, std::string>& attrs)
 {
   if(name == "hash") {
     stm->setHashState();
-    map<string, string>::const_iterator itr = attrs.find("type");
+    std::map<std::string, std::string>::const_iterator itr = attrs.find("type");
     if(itr == attrs.end()) {
       return;
     } else {
-      string type = (*itr).second;
+      std::string type = (*itr).second;
       stm->newChecksumTransaction();
       stm->setTypeOfChecksum(type);
     }
@@ -56,16 +58,16 @@ void VerificationMetalinkParserState::beginElement(MetalinkParserStateMachine* s
     try {
       int32_t length;
       {
-	map<string, string>::const_iterator itr = attrs.find("length");
+	std::map<std::string, std::string>::const_iterator itr = attrs.find("length");
 	if(itr == attrs.end()) {
 	  return;
 	} else {
 	  length = Util::parseInt((*itr).second);
 	}
       }
-      string type;
+      std::string type;
       {
-	map<string, string>::const_iterator itr = attrs.find("type");
+	std::map<std::string, std::string>::const_iterator itr = attrs.find("type");
 	if(itr == attrs.end()) {
 	  return;
 	} else {
@@ -85,8 +87,10 @@ void VerificationMetalinkParserState::beginElement(MetalinkParserStateMachine* s
 }
 
 void VerificationMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-						 const string& name,
-						 const string& characters)
+						 const std::string& name,
+						 const std::string& characters)
 {
   stm->setFileState();
 }
+
+} //  namespace aria2
diff --git a/src/VerificationMetalinkParserState.h b/src/VerificationMetalinkParserState.h
index 1ab7ce08..cae02ff2 100644
--- a/src/VerificationMetalinkParserState.h
+++ b/src/VerificationMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class VerificationMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_VERIFICATION_METALINK_PARSER_STATE_H_
diff --git a/src/VersionMetalinkParserState.cc b/src/VersionMetalinkParserState.cc
index 4ebba31a..42db95bf 100644
--- a/src/VersionMetalinkParserState.cc
+++ b/src/VersionMetalinkParserState.cc
@@ -35,17 +35,21 @@
 #include "VersionMetalinkParserState.h"
 #include "MetalinkParserStateMachine.h"
 
+namespace aria2 {
+
 void VersionMetalinkParserState::beginElement(MetalinkParserStateMachine* stm,
-					      const string& name,
-					      const map<string, string>& attrs)
+					      const std::string& name,
+					      const std::map<std::string, std::string>& attrs)
 {
   stm->setSkipTagState(this);
 }
 
 void VersionMetalinkParserState::endElement(MetalinkParserStateMachine* stm,
-					    const string& name,
-					    const string& characters)
+					    const std::string& name,
+					    const std::string& characters)
 {
   stm->setVersionOfEntry(characters);
   stm->setFileState();
 }
+
+} // namespace aria2
diff --git a/src/VersionMetalinkParserState.h b/src/VersionMetalinkParserState.h
index d7673ea4..2b6b74ce 100644
--- a/src/VersionMetalinkParserState.h
+++ b/src/VersionMetalinkParserState.h
@@ -37,14 +37,18 @@
 
 #include "MetalinkParserState.h"
 
+namespace aria2 {
+
 class VersionMetalinkParserState:public MetalinkParserState
 {
 public:
   void beginElement(MetalinkParserStateMachine* stm,
-		    const string& name, const map<string, string>& attrs);
+		    const std::string& name, const std::map<std::string, std::string>& attrs);
 
   void endElement(MetalinkParserStateMachine* stm,
-		  const string& name, const string& characters);
+		  const std::string& name, const std::string& characters);
 };
 
+} // namespace aria2
+
 #endif // _D_VERSION_METALINK_PARSER_STATE_H_
diff --git a/src/XML2SAXMetalinkProcessor.cc b/src/XML2SAXMetalinkProcessor.cc
index dd1733cd..b4c1dd69 100644
--- a/src/XML2SAXMetalinkProcessor.cc
+++ b/src/XML2SAXMetalinkProcessor.cc
@@ -35,32 +35,35 @@
 #include "XML2SAXMetalinkProcessor.h"
 #include "BinaryStream.h"
 #include "MetalinkParserStateMachine.h"
+#include "Metalinker.h"
+#include "MetalinkEntry.h"
 #include "Util.h"
 #include "message.h"
+#include "DlAbortEx.h"
+
+namespace aria2 {
 
 class SessionData {
 public:
-  MetalinkParserStateMachineHandle _stm;
+  SharedHandle<MetalinkParserStateMachine> _stm;
 
-  Strings _charactersStack;
+  std::deque<std::string> _charactersStack;
 
-  SessionData(const MetalinkParserStateMachineHandle& stm):_stm(stm) {}
+  SessionData(const SharedHandle<MetalinkParserStateMachine>& stm):_stm(stm) {}
 };
 
-typedef SharedHandle<SessionData> SessionDataHandle;
-
 static void mlStartElement(void* userData, const xmlChar* name, const xmlChar** attrs)
 {
-  ((SessionData*)userData)->_charactersStack.push_front(string());
-  map<string, string> attrmap;
+  ((SessionData*)userData)->_charactersStack.push_front(std::string());
+  std::map<std::string, std::string> attrmap;
   if(attrs) {
     const xmlChar** p = attrs;
     while(*p != 0) {
-      string name = (const char*)*p++;
+      std::string name = (const char*)*p++;
       if(*p == 0) {
 	break;
       }
-      string value = Util::trim((const char*)*p++);
+      std::string value = Util::trim((const char*)*p++);
       attrmap[name] = value;
     }
   }
@@ -77,7 +80,7 @@ static void mlEndElement(void* userData, const xmlChar* name)
 
 static void mlCharacters(void* userData, const xmlChar* ch, int len)
 {
-  ((SessionData*)userData)->_charactersStack.front() += string(&ch[0], &ch[len]);
+  ((SessionData*)userData)->_charactersStack.front() += std::string(&ch[0], &ch[len]);
 }
 
 static xmlSAXHandler mySAXHandler =
@@ -119,12 +122,12 @@ static xmlSAXHandler mySAXHandler =
 XML2SAXMetalinkProcessor::XML2SAXMetalinkProcessor():
   _stm(0)
 {}
-	 
-	 
-MetalinkerHandle XML2SAXMetalinkProcessor::parseFile(const string& filename)
+
+SharedHandle<Metalinker>
+XML2SAXMetalinkProcessor::parseFile(const std::string& filename)
 {
   _stm = new MetalinkParserStateMachine();
-  SessionDataHandle sessionData = new SessionData(_stm);
+  SharedHandle<SessionData> sessionData = new SessionData(_stm);
   int32_t retval = xmlSAXUserParseFile(&mySAXHandler, sessionData.get(),
 				       filename.c_str());
   if(retval != 0) {
@@ -133,7 +136,8 @@ MetalinkerHandle XML2SAXMetalinkProcessor::parseFile(const string& filename)
   return _stm->getResult();
 }
 	 
-MetalinkerHandle XML2SAXMetalinkProcessor::parseFromBinaryStream(const BinaryStreamHandle& binaryStream)
+SharedHandle<Metalinker>
+XML2SAXMetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream)
 {
   _stm = new MetalinkParserStateMachine();
   int32_t bufSize = 4096;
@@ -144,7 +148,7 @@ MetalinkerHandle XML2SAXMetalinkProcessor::parseFromBinaryStream(const BinaryStr
     throw new DlAbortEx("Too small data for parsing XML.");
   }
 
-  SessionDataHandle sessionData = new SessionData(_stm);
+  SharedHandle<SessionData> sessionData = new SessionData(_stm);
   xmlParserCtxtPtr ctx = xmlCreatePushParserCtxt(&mySAXHandler, sessionData.get(), (const char*)buf, res, 0);
   try {
     int64_t readOffset = res;
@@ -170,3 +174,5 @@ MetalinkerHandle XML2SAXMetalinkProcessor::parseFromBinaryStream(const BinaryStr
   }
   return _stm->getResult();
 }
+
+} // namespace aria2
diff --git a/src/XML2SAXMetalinkProcessor.h b/src/XML2SAXMetalinkProcessor.h
index 2159e331..930afbe9 100644
--- a/src/XML2SAXMetalinkProcessor.h
+++ b/src/XML2SAXMetalinkProcessor.h
@@ -38,22 +38,26 @@
 #include "MetalinkProcessor.h"
 #include <libxml/parser.h>
 #include <libxml/xpath.h>
+#include <string>
+
+namespace aria2 {
 
 class MetalinkParserStateMachine;
-typedef SharedHandle<MetalinkParserStateMachine> MetalinkParserStateMachineHandle;
 
 class XML2SAXMetalinkProcessor:public MetalinkProcessor {
 private:
-  MetalinkParserStateMachineHandle _stm;
+  SharedHandle<MetalinkParserStateMachine> _stm;
 
 public:
   XML2SAXMetalinkProcessor();
 
   virtual ~XML2SAXMetalinkProcessor() {}
 
-  virtual MetalinkerHandle parseFile(const string& filename);
+  virtual SharedHandle<Metalinker> parseFile(const std::string& filename);
 
-  virtual MetalinkerHandle parseFromBinaryStream(const BinaryStreamHandle& binaryStream);
+  virtual SharedHandle<Metalinker> parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream);
 };
 
+} // namespace aria2
+
 #endif // _D_XML2_SAX_METALINK_PROCESSOR_H_
diff --git a/src/XORCloser.h b/src/XORCloser.h
index 33f21047..70b1be23 100644
--- a/src/XORCloser.h
+++ b/src/XORCloser.h
@@ -37,17 +37,19 @@
 
 #include <cstdlib>
 
+namespace aria2 {
+
 class XORCloser {
 private:
   const unsigned char* _key;
-  std::size_t _length;
+  size_t _length;
 public:
-  XORCloser(const unsigned char* key, std::size_t length):_key(key), _length(length) {}
+  XORCloser(const unsigned char* key, size_t length):_key(key), _length(length) {}
 
   bool operator()(const unsigned char* key1,
 		  const unsigned char* key2) const
   {
-    for(std::size_t i = 0; i < _length; ++i) {
+    for(size_t i = 0; i < _length; ++i) {
       unsigned char c1 = _key[i]^key1[i];
       unsigned char c2 = _key[i]^key2[i];
 
@@ -61,4 +63,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_XOR_CLOSER_H_
diff --git a/src/a2algo.h b/src/a2algo.h
index eeff683a..e041b3c4 100644
--- a/src/a2algo.h
+++ b/src/a2algo.h
@@ -32,6 +32,10 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
+#ifndef _D_A2_ALGO_H_
+#define _D_A2_ALGO_H_
+
+namespace aria2 {
 
 template<typename InputIterator, typename OutputIterator>
 OutputIterator ncopy(InputIterator first, InputIterator last,
@@ -43,3 +47,7 @@ OutputIterator ncopy(InputIterator first, InputIterator last,
   }
   return x;
 }
+
+} // namespace aria2
+
+#endif // _D_A2_ALGO_H_
diff --git a/src/a2functional.h b/src/a2functional.h
index 8382b572..a6ac6bde 100644
--- a/src/a2functional.h
+++ b/src/a2functional.h
@@ -32,9 +32,14 @@
  * files in the program, then also delete it here.
  */
 /* copyright --> */
+#ifndef _D_A2_FUNCTIONAL_H_
+#define _D_A2_FUNCTIONAL_H_
+
 #include <functional>
 #include "SharedHandle.h"
 
+namespace aria2 {
+
 // mem_fun_t for SharedHandle
 template <class ReturnType, typename ClassType>
 class mem_fun_sh_t:public std::unary_function< SharedHandle<ClassType>, ReturnType>
@@ -108,19 +113,31 @@ adopt2nd(const BinaryOp& binaryOp, const UnaryOp& unaryOp)
   return adopt2nd_t<BinaryOp, UnaryOp>(binaryOp, unaryOp);
 };
 
-template<typename T, std::size_t N>
-char (&char_array_ref(T (&)[N]))[N];
-
-template<typename T, std::size_t N>
-std::size_t
-arrayLength(T (&a)[N])
+template<typename Pair>
+class Ascend1st:public std::binary_function<Pair, Pair, bool>
 {
-  return sizeof(char_array_ref(a));
-}
+public:
+  bool operator()(const Pair& p1, const Pair& p2) const
+  {
+    return p1.first < p2.first;
+  }
+};
 
-template<typename T>
-std::size_t
-arrayLength(T (&a)[0u])
+template<typename Pair>
+class select2nd
 {
-  return 0;
-}
+public:
+  typename Pair::second_type operator()(const Pair& p) const
+  {
+    return p.second;
+  }
+
+  typename Pair::second_type operator()(Pair& p) const
+  {
+    return p.second;
+  }
+};
+
+} // namespace aria2
+
+#endif // _D_A2_FUNCTIONAL_H_
diff --git a/src/a2io.h b/src/a2io.h
index 3507851a..f82be679 100644
--- a/src/a2io.h
+++ b/src/a2io.h
@@ -120,4 +120,7 @@
 # define ENABLE_DIRECT_IO 1
 #endif // HAVE_POSIX_MEMALIGN && O_DIRECT
 
+#define OPEN_MODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
+#define DIR_OPEN_MODE S_IRWXU|S_IRWXG|S_IRWXO
+
 #endif // _D_A2IO_H_
diff --git a/src/array_fun.h b/src/array_fun.h
index d9ac1c26..3647b6d8 100644
--- a/src/array_fun.h
+++ b/src/array_fun.h
@@ -37,6 +37,8 @@
 
 #include <functional>
 
+namespace aria2 {
+
 template<typename T>
 class bit_negate:public std::unary_function<T, T> {
 public:
@@ -195,4 +197,25 @@ array_and(A a, B b)
   return array_fun<typename B::result_type>(a, b, bit_and<typename B::result_type>());
 }
 
+// calculate length of array
+
+template<typename T, std::size_t N>
+char (&char_array_ref(T (&)[N]))[N];
+
+template<typename T, std::size_t N>
+std::size_t
+arrayLength(T (&a)[N])
+{
+  return sizeof(char_array_ref(a));
+}
+
+template<typename T>
+std::size_t
+arrayLength(T (&a)[0u])
+{
+  return 0;
+}
+
+} // namespace aria2
+
 #endif // _D_ARRAY_FUN_H_
diff --git a/src/common.h b/src/common.h
index 7562495a..b24e3adc 100644
--- a/src/common.h
+++ b/src/common.h
@@ -34,8 +34,7 @@
 /* copyright --> */
 #ifndef _D_COMMON_H_
 #define _D_COMMON_H_
-// use C99 limit macros
-#define __STDC_LIMIT_MACROS
+
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
@@ -49,55 +48,10 @@
 #endif
 #endif // __MINGW32__
 
-#include <stdio.h>
-#include <stdint.h>
-#include <iostream>
-#include <assert.h>
-#include <limits.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string>
-#include <deque>
-#include <algorithm>
 #include "gettext.h"
 #define _(String) gettext(String)
 
-#define USER_AGENT "aria2"
-
-#define BITFIELD_LEN_FROM_PIECES(X) ((X)/8+((X)%8? 1 : 0))
-
-#define DIV_FLOOR(X,Y) ((X)/(Y)+((X)%(Y)? 1:0))
-
-using namespace std;
-//#include "debug_new.h"
-
-class Deleter {
-public:
-  template<class T>
-  void operator()(T* ptr) {
-    delete ptr;
-  }
-};
-
-#include "SharedHandle.h"
-#include "SingletonHolder.h"
-
-typedef deque<string> Strings;
-typedef deque<int32_t> Integers;
-
-#define OPEN_MODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
-#define DIR_OPEN_MODE S_IRWXU|S_IRWXG|S_IRWXO
-
-#ifdef __MINGW32__
-# define LONGLONG_PRINTF "%I64d"
-# define ULONGLONG_PRINTF "%I64u"
-# define LONGLONG_SCANF "%I64d"
-# define ULONGLONG_SCANF "%I64u"
-#else
-# define LONGLONG_PRINTF "%lld"
-# define ULONGLONG_PRINTF "%llu"
-# define LONGLONG_SCANF "%Ld"
-# define ULONGLONG_SCANF "%Lu"
-#endif // __MINGW32__
+// use C99 limit macros
+#define __STDC_LIMIT_MACROS
 
 #endif // _D_COMMON_H_
diff --git a/src/main.cc b/src/main.cc
index bb2667a0..f53df1c2 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -33,48 +33,47 @@
  */
 /* copyright --> */
 #include "common.h"
+#include "SharedHandle.h"
 #include "LogFactory.h"
+#include "Logger.h"
 #include "Util.h"
+#include "BitfieldManFactory.h"
+#include "AuthConfigFactory.h"
+#include "CookieBoxFactory.h"
 #include "FeatureConfig.h"
 #include "MultiUrlRequestInfo.h"
-#include "BitfieldManFactory.h"
 #include "SimpleRandomizer.h"
 #include "Netrc.h"
-#include "AuthConfigFactory.h"
 #include "FatalException.h"
 #include "File.h"
 #include "CUIDCounter.h"
-#include "FileUriListParser.h"
-#include "StreamUriListParser.h"
-#include "CookieBoxFactory.h"
-#include "a2algo.h"
+#include "UriListParser.h"
 #include "message.h"
+#include "prefs.h"
+#include "Option.h"
+#include "a2algo.h"
 #include "a2io.h"
 #include "a2time.h"
 #include "Platform.h"
-#include "prefs.h"
 #include "ParameterizedStringParser.h"
 #include "PStringBuildVisitor.h"
 #include "SingleFileDownloadContext.h"
 #include "DefaultBtContext.h"
+#include "FileEntry.h"
 #include "RequestGroup.h"
-#include "Option.h"
-#include "MetalinkHelper.h"
-#include <deque>
-#include <algorithm>
-#include <signal.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <utility>
-#include <fstream>
-extern char* optarg;
-extern int optind, opterr, optopt;
-#include <getopt.h>
-
 #ifdef ENABLE_METALINK
+# include "MetalinkHelper.h"
 # include "Metalink2RequestGroup.h"
 # include "MetalinkEntry.h"
 #endif // ENABLE_METALINK
+#include <deque>
+#include <signal.h>
+#include <unistd.h>
+#include <fstream>
+#include <iostream>
+extern char* optarg;
+extern int optind, opterr, optopt;
+#include <getopt.h>
 
 #ifdef HAVE_LIBSSL
 // for SSL
@@ -85,22 +84,24 @@ extern int optind, opterr, optopt;
 # include <gnutls/gnutls.h>
 #endif // HAVE_LIBGNUTLS
 
-Strings unfoldURI(const Strings& args)
+namespace aria2 {
+
+std::deque<std::string> unfoldURI(const std::deque<std::string>& args)
 {
-  Strings nargs;
+  std::deque<std::string> nargs;
   ParameterizedStringParser p;
-  PStringBuildVisitorHandle v = new PStringBuildVisitor();
-  for(Strings::const_iterator itr = args.begin(); itr != args.end();
+  PStringBuildVisitor v;
+  for(std::deque<std::string>::const_iterator itr = args.begin(); itr != args.end();
       ++itr) {
-    v->reset();
-    p.parse(*itr)->accept(v);
-    nargs.insert(nargs.end(), v->getURIs().begin(), v->getURIs().end()); 
+    v.reset();
+    p.parse(*itr)->accept(&v);
+    nargs.insert(nargs.end(), v.getURIs().begin(), v.getURIs().end()); 
   }
   return nargs;
 }
 
-RequestGroupHandle createRequestGroup(const Option* op, const Strings& uris,
-				      const string& ufilename = "")
+RequestGroupHandle createRequestGroup(const Option* op, const std::deque<std::string>& uris,
+				      const std::string& ufilename = "")
 {
   RequestGroupHandle rg = new RequestGroup(op, uris);
   SingleFileDownloadContextHandle dctx =
@@ -116,15 +117,15 @@ RequestGroupHandle createRequestGroup(const Option* op, const Strings& uris,
 extern Option* option_processing(int argc, char* const argv[]);
 
 #ifdef ENABLE_BITTORRENT
-void downloadBitTorrent(Option* op, const Strings& uri)
+void downloadBitTorrent(Option* op, const std::deque<std::string>& uri)
 {
-  Strings nargs;
+  std::deque<std::string> nargs;
   if(op->get(PREF_PARAMETERIZED_URI) == V_TRUE) {
     nargs = unfoldURI(uri);
   } else {
     nargs = uri;
   }
-  Strings xargs;
+  std::deque<std::string> xargs;
   ncopy(nargs.begin(), nargs.end(), op->getAsInt(PREF_SPLIT),
 	back_inserter(xargs));
   
@@ -155,43 +156,48 @@ void downloadMetalink(Option* op)
 }
 #endif // ENABLE_METALINK
 
-void downloadUriList(Option* op)
+void downloadUriList(Option* op, std::istream& in)
 {
-  SharedHandle<UriListParser> flparser(0);
-  if(op->get(PREF_INPUT_FILE) == "-") {
-    flparser = new StreamUriListParser(cin);
-  } else {
-    if(!File(op->get(PREF_INPUT_FILE)).isFile()) {
-      throw new FatalException(EX_FILE_OPEN, op->get(PREF_INPUT_FILE).c_str(), "No such file");
-    }
-    flparser = new FileUriListParser(op->get(PREF_INPUT_FILE));
-  }
+  UriListParser p;
   RequestGroups groups;
-  while(flparser->hasNext()) {
-    Strings uris = flparser->next();
+  while(in) {
+    std::deque<std::string> uris = p.parseNext(in);
     if(uris.size() == 1 && op->get(PREF_PARAMETERIZED_URI) == V_TRUE) {
-      Strings unfoldedURIs = unfoldURI(uris);
-      for(Strings::const_iterator itr = unfoldedURIs.begin();
+      std::deque<std::string> unfoldedURIs = unfoldURI(uris);
+      for(std::deque<std::string>::const_iterator itr = unfoldedURIs.begin();
 	  itr != unfoldedURIs.end(); ++itr) {
-	Strings xuris;
+	std::deque<std::string> xuris;
 	ncopy(itr, itr+1, op->getAsInt(PREF_SPLIT), back_inserter(xuris));
-	RequestGroupHandle rg = createRequestGroup(op, xuris);
+	SharedHandle<RequestGroup> rg = createRequestGroup(op, xuris);
 	groups.push_back(rg);
       }
     } else if(uris.size() > 0) {
-      Strings xuris;
+      std::deque<std::string> xuris;
       ncopy(uris.begin(), uris.end(), op->getAsInt(PREF_SPLIT),
 	    back_inserter(xuris));
-      RequestGroupHandle rg = createRequestGroup(op, xuris);
+      SharedHandle<RequestGroup> rg = createRequestGroup(op, xuris);
       groups.push_back(rg);
     }
   }
   MultiUrlRequestInfo(groups, op).execute();
 }
 
-void downloadUri(Option* op, const Strings& uris)
+void downloadUriList(Option* op)
 {
-  Strings nargs;
+  if(op->get(PREF_INPUT_FILE) == "-") {
+    downloadUriList(op, std::cin);
+  } else {
+    if(!File(op->get(PREF_INPUT_FILE)).isFile()) {
+      throw new FatalException(EX_FILE_OPEN, op->get(PREF_INPUT_FILE).c_str(), "No such file");
+    }
+    std::ifstream f(op->get(PREF_INPUT_FILE).c_str());
+    downloadUriList(op, f);
+  }
+}
+
+void downloadUri(Option* op, const std::deque<std::string>& uris)
+{
+  std::deque<std::string> nargs;
   if(op->get(PREF_PARAMETERIZED_URI) == V_TRUE) {
     nargs = unfoldURI(uris);
   } else {
@@ -199,16 +205,16 @@ void downloadUri(Option* op, const Strings& uris)
   }
   RequestGroups groups;
   if(op->get(PREF_FORCE_SEQUENTIAL) == V_TRUE) {
-    for(Strings::const_iterator itr = nargs.begin();
+    for(std::deque<std::string>::const_iterator itr = nargs.begin();
 	itr != nargs.end(); ++itr) {
-      Strings xuris;
+      std::deque<std::string> xuris;
       ncopy(itr, itr+1, op->getAsInt(PREF_SPLIT),
 	    back_inserter(xuris));
       RequestGroupHandle rg = createRequestGroup(op, xuris);
       groups.push_back(rg);
     }
   } else {
-    Strings xargs;
+    std::deque<std::string> xargs;
     ncopy(nargs.begin(), nargs.end(), op->getAsInt(PREF_SPLIT),
 	  back_inserter(xargs));
     RequestGroupHandle rg = createRequestGroup(op, xargs, op->get(PREF_OUT));
@@ -217,28 +223,11 @@ void downloadUri(Option* op, const Strings& uris)
   MultiUrlRequestInfo(groups, op).execute();
 }
 
-int main(int argc, char* argv[]) {
-#ifdef HAVE_WINSOCK2_H
-  Platform platform;
-#endif // HAVE_WINSOCK2_H
-
-#ifdef ENABLE_NLS
-  setlocale (LC_CTYPE, "");
-  setlocale (LC_MESSAGES, "");
-  bindtextdomain (PACKAGE, LOCALEDIR);
-  textdomain (PACKAGE);
-#endif // ENABLE_NLS
+int main(int argc, char* argv[])
+{
   Option* op = option_processing(argc, argv);
-  Strings args(argv+optind, argv+argc);
-  
-#ifdef HAVE_LIBSSL
-  // for SSL initialization
-  SSL_load_error_strings();
-  SSL_library_init();
-#endif // HAVE_LIBSSL
-#ifdef HAVE_LIBGNUTLS
-  gnutls_global_init();
-#endif // HAVE_LIBGNUTLS
+  std::deque<std::string> args(argv+optind, argv+argc);
+
   SimpleRandomizer::init();
   BitfieldManFactory::setDefaultRandomizer(SimpleRandomizer::getInstance());
   if(op->getAsBool(PREF_STDOUT_LOG)) {
@@ -273,7 +262,7 @@ int main(int argc, char* argv[]) {
     if(op->defined(PREF_LOAD_COOKIES)) {
       File cookieFile(op->get(PREF_LOAD_COOKIES));
       if(cookieFile.isFile()) {
-	ifstream in(op->get(PREF_LOAD_COOKIES).c_str());
+	std::ifstream in(op->get(PREF_LOAD_COOKIES).c_str());
 	CookieBoxFactorySingletonHolder::instance()->loadDefaultCookie(in);
       } else {
 	logger->error(MSG_LOADING_COOKIE_FAILED, op->get(PREF_LOAD_COOKIES).c_str());
@@ -293,7 +282,7 @@ int main(int argc, char* argv[]) {
       if(op->get(PREF_SHOW_FILES) == V_TRUE) {
 	DefaultBtContextHandle btContext = new DefaultBtContext();
 	btContext->load(op->get(PREF_TORRENT_FILE));
-	cout << btContext << endl;
+	std::cout << btContext << std::endl;
       } else {
 	downloadBitTorrent(op, args);
       }
@@ -303,7 +292,7 @@ int main(int argc, char* argv[]) {
 #ifdef ENABLE_METALINK
       if(op->defined(PREF_METALINK_FILE)) {
 	if(op->get(PREF_SHOW_FILES) == V_TRUE) {
-	  Util::toStream(cout, MetalinkEntry::toFileEntry(MetalinkHelper::parseAndQuery(op->get(PREF_METALINK_FILE), op)));
+	  Util::toStream(std::cout, MetalinkEntry::toFileEntry(MetalinkHelper::parseAndQuery(op->get(PREF_METALINK_FILE), op)));
 	} else {
 	  downloadMetalink(op);
 	}
@@ -316,15 +305,44 @@ int main(int argc, char* argv[]) {
 	  downloadUri(op, args);
 	}
   } catch(Exception* ex) {
-    cerr << EX_EXCEPTION_CAUGHT << "\n" << *ex << endl;
+    std::cerr << EX_EXCEPTION_CAUGHT << "\n" << *ex << std::endl;
     delete ex;
     exit(EXIT_FAILURE);
   }
   delete op;
   LogFactory::release();
-#ifdef HAVE_LIBGNUTLS
-  gnutls_global_deinit();
-#endif // HAVE_LIBGNUTLS
   FeatureConfig::release();
   return exitStatus;
 }
+
+} // namespace aria2
+
+int main(int argc, char* argv[]) {
+#ifdef HAVE_WINSOCK2_H
+  aria2::Platform platform;
+#endif // HAVE_WINSOCK2_H
+
+#ifdef ENABLE_NLS
+  setlocale (LC_CTYPE, "");
+  setlocale (LC_MESSAGES, "");
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+#endif // ENABLE_NLS
+  
+#ifdef HAVE_LIBSSL
+  // for SSL initialization
+  SSL_load_error_strings();
+  SSL_library_init();
+#endif // HAVE_LIBSSL
+#ifdef HAVE_LIBGNUTLS
+  gnutls_global_init();
+#endif // HAVE_LIBGNUTLS
+
+  int r = aria2::main(argc, argv);
+
+#ifdef HAVE_LIBGNUTLS
+  gnutls_global_deinit();
+#endif // HAVE_LIBGNUTLS
+
+  return r;
+}
diff --git a/src/messageDigest.cc b/src/messageDigest.cc
index faa669d2..848afbe0 100644
--- a/src/messageDigest.cc
+++ b/src/messageDigest.cc
@@ -34,6 +34,8 @@
 /* copyright --> */
 #include "messageDigest.h"
 
+namespace aria2 {
+
 static MessageDigestContext::DigestAlgoMap::value_type digests[] = {
 #ifdef HAVE_LIBSSL
   MessageDigestContext::DigestAlgoMap::value_type("md5", EVP_md5()),
@@ -52,12 +54,14 @@ MessageDigestContext::DigestAlgoMap
 MessageDigestContext::digestAlgos(&digests[0],
 				  &digests[sizeof(digests)/sizeof(DigestAlgoMap::value_type)]);
 
-string MessageDigestContext::digestFinal()
+std::string MessageDigestContext::digestFinal()
 {
   int32_t length = digestLength(algo);
   unsigned char* rawMD = new unsigned char[length];
   digestFinal(rawMD);
-  string rawMDString(&rawMD[0], &rawMD[length]);
+  std::string rawMDString(&rawMD[0], &rawMD[length]);
   delete [] rawMD;
   return rawMDString;
 }
+
+} // namespace aria2
diff --git a/src/messageDigest.h b/src/messageDigest.h
index 612e0920..8186b0cd 100644
--- a/src/messageDigest.h
+++ b/src/messageDigest.h
@@ -36,6 +36,7 @@
 #define _D_MESSAGE_DIGEST_H_
 
 #include "common.h"
+#include "SharedHandle.h"
 #include "DlAbortEx.h"
 #include <map>
 
@@ -47,6 +48,8 @@
 #include <gcrypt.h>
 #endif // HAVE_LIBGCRYPT
 
+namespace aria2 {
+
 class MessageDigestContext {
 public:
 #ifdef HAVE_LIBSSL
@@ -55,7 +58,7 @@ public:
 #ifdef HAVE_LIBGCRYPT
   typedef int32_t DigestAlgo;
 #endif // HAVE_LIBGCRYPT
-  typedef map<string, MessageDigestContext::DigestAlgo> DigestAlgoMap;
+  typedef std::map<std::string, MessageDigestContext::DigestAlgo> DigestAlgoMap;
 private:
 #ifdef HAVE_LIBSSL
   EVP_MD_CTX ctx;
@@ -75,12 +78,12 @@ public:
     digestFree();
   }
 
-  void trySetAlgo(const string& algostring)
+  void trySetAlgo(const std::string& algostring)
   {
     algo = getDigestAlgo(algostring);
   }
 
-  static bool supports(const string& algostring)
+  static bool supports(const std::string& algostring)
   {
     DigestAlgoMap::const_iterator itr = digestAlgos.find(algostring);
     if(itr == digestAlgos.end()) {
@@ -90,7 +93,7 @@ public:
     }
   }
 
-  static DigestAlgo getDigestAlgo(const string& algostring)
+  static DigestAlgo getDigestAlgo(const std::string& algostring)
   {
     DigestAlgoMap::const_iterator itr = digestAlgos.find(algostring);
     if(itr == digestAlgos.end()) {
@@ -99,9 +102,9 @@ public:
     return (*itr).second;
   }
 
-  static string getSupportedAlgoString()
+  static std::string getSupportedAlgoString()
   {
-    string algos;
+    std::string algos;
     for(DigestAlgoMap::const_iterator itr = digestAlgos.begin();
 	itr != digestAlgos.end(); ++itr) {
       algos += (*itr).first+" ";
@@ -109,12 +112,12 @@ public:
     return algos;
   }
 
-  static int digestLength(const string& algostring)
+  static int digestLength(const std::string& algostring)
   {
     return digestLength(getDigestAlgo(algostring));
   }
 
-  string digestFinal();
+  std::string digestFinal();
 
 #if defined(HAVE_OLD_LIBSSL)
   void digestInit() {EVP_DigestInit(&ctx, algo);}
@@ -183,4 +186,7 @@ public:
 #endif // HAVE_LIBGCRYPT
 };
 typedef SharedHandle<MessageDigestContext> MessageDigestContextHandle;
+
+} // namespace aria2
+
 #endif // _D_MESSAGE_DIGEST_H_
diff --git a/src/option_processing.cc b/src/option_processing.cc
index 21e1a607..7bac84dc 100644
--- a/src/option_processing.cc
+++ b/src/option_processing.cc
@@ -37,26 +37,30 @@
 #include "prefs.h"
 #include "OptionParser.h"
 #include "OptionHandlerFactory.h"
+#include "OptionHandler.h"
 #include "Util.h"
 #include "message.h"
 #include "Exception.h"
 #include "a2io.h"
 #include "help_tags.h"
-#include "LogFactory.h"
+#include "File.h"
 #include <fstream>
 #include <sstream>
+#include <iostream>
 
 extern char* optarg;
 extern int optind, opterr, optopt;
 #include <getopt.h>
 
-extern void showVersion();
-extern void showUsage(const string& category);
+namespace aria2 {
 
-static string toBoolArg(const char* optarg)
+extern void showVersion();
+extern void showUsage(const std::string& category);
+
+static std::string toBoolArg(const char* optarg)
 {
-  string arg;
-  if(!optarg || string(optarg) == "") {
+  std::string arg;
+  if(!optarg || std::string(optarg) == "") {
     arg = V_TRUE;
   } else {
     arg = optarg;
@@ -66,7 +70,7 @@ static string toBoolArg(const char* optarg)
 
 Option* option_processing(int argc, char* const argv[])
 {
-  stringstream cmdstream;
+  std::stringstream cmdstream;
   int32_t c;
   Option* op = new Option();
   op->put(PREF_STDOUT_LOG, V_FALSE);
@@ -139,8 +143,8 @@ Option* option_processing(int argc, char* const argv[])
 
   // following options are not parsed by OptionHandler and not stored in Option.
   bool noConf = false;
-  string defaultCfname = Util::getHomeDir()+"/.aria2/aria2.conf";
-  string ucfname;
+  std::string defaultCfname = Util::getHomeDir()+"/.aria2/aria2.conf";
+  std::string ucfname;
 
   while(1) {
     int optIndex = 0;
@@ -453,8 +457,8 @@ Option* option_processing(int argc, char* const argv[])
       exit(EXIT_SUCCESS);
     case 'h':
       {
-	string category;
-	if(optarg == 0 || string(optarg) == "") {
+	std::string category;
+	if(optarg == 0 || std::string(optarg) == "") {
 	  category = TAG_BASIC;
 	} else {
 	  category = optarg;
@@ -471,31 +475,31 @@ Option* option_processing(int argc, char* const argv[])
     OptionParser oparser;
     oparser.setOptionHandlers(OptionHandlerFactory::createOptionHandlers());
     if(!noConf) {
-      string cfname;
+      std::string cfname;
       if(ucfname.size()) {
 	cfname = ucfname;
       } else {
 	cfname = defaultCfname;
       }
       if(File(cfname).isFile()) {
-	ifstream cfstream(cfname.c_str());
+	std::ifstream cfstream(cfname.c_str());
 	try {
 	  oparser.parse(op, cfstream);
 	} catch(Exception* e) {
-	  cerr << "Parse error in " << cfname << endl;
-	  cerr << *e << endl;
+	  std::cerr << "Parse error in " << cfname << "\n"
+		    << *e << std::endl;
 	  delete e;
 	  exit(EXIT_FAILURE);
 	}
       } else if(ucfname.size()) {
 	printf("Configuration file %s is not found.", cfname.c_str());
-	cout << "\n";
+	std::cout << "\n";
       }
     }
     try {
       oparser.parse(op, cmdstream);
     } catch(Exception* e) {
-      cerr << *e << endl;
+      std::cerr << *e << std::endl;
       delete e;
       exit(EXIT_FAILURE);
     }
@@ -515,7 +519,7 @@ Option* option_processing(int argc, char* const argv[])
 #endif // ENABLE_METALINK
      !op->defined(PREF_INPUT_FILE)) {
     if(optind == argc) {
-      cerr << MSG_URI_REQUIRED << endl;
+      std::cerr << MSG_URI_REQUIRED << std::endl;
       exit(EXIT_FAILURE);
     }
   }
@@ -529,3 +533,5 @@ Option* option_processing(int argc, char* const argv[])
 #endif // HAVE_DAEMON
   return op;
 }
+
+} // namespace aria2
diff --git a/src/version_usage.cc b/src/version_usage.cc
index 22256f33..f3aef4e7 100644
--- a/src/version_usage.cc
+++ b/src/version_usage.cc
@@ -33,6 +33,7 @@
  */
 /* copyright --> */
 #include "common.h"
+#include "SharedHandle.h"
 #include "a2io.h"
 #include "FeatureConfig.h"
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -43,13 +44,16 @@
 #include "HelpItemFactory.h"
 #include "help_tags.h"
 #include "prefs.h"
+#include <iostream>
 #include <iterator>
 
+namespace aria2 {
+
 void showVersion() {
-  cout << PACKAGE << _(" version ") << PACKAGE_VERSION << "\n"
-       << "Copyright (C) 2006, 2008 Tatsuhiro Tsujikawa" << "\n"
-       << "\n"
-       <<
+  std::cout << PACKAGE << _(" version ") << PACKAGE_VERSION << "\n"
+	    << "Copyright (C) 2006, 2008 Tatsuhiro Tsujikawa" << "\n"
+	    << "\n"
+	    <<
     _("This program is free software; you can redistribute it and/or modify\n"
       "it under the terms of the GNU General Public License as published by\n"
       "the Free Software Foundation; either version 2 of the License, or\n"
@@ -63,9 +67,9 @@ void showVersion() {
       "You should have received a copy of the GNU General Public License\n"
       "along with this program; if not, write to the Free Software\n"
       "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA\n")
-       << "\n"
+	    << "\n"
 
-       <<
+	    <<
     "In addition, as a special exception, the copyright holders give\n"
     "permission to link the code of portions of this program with the\n"
     "OpenSSL library under certain conditions as described in each\n"
@@ -78,18 +82,18 @@ void showVersion() {
     "do not wish to do so, delete this exception statement from your\n"
     "version.  If you delete this exception statement from all source\n"
     "files in the program, then also delete it here.\n"
-       << "\n"
-       << "** Configuration **" << "\n"
-       << FeatureConfig::getInstance()->getConfigurationSummary()
+	    << "\n"
+	    << "** Configuration **" << "\n"
+	    << FeatureConfig::getInstance()->getConfigurationSummary()
 #ifdef ENABLE_MESSAGE_DIGEST
-       << "message digest algorithms: " << MessageDigestContext::getSupportedAlgoString() << "\n"
+	    << "message digest algorithms: " << MessageDigestContext::getSupportedAlgoString() << "\n"
 #endif // ENABLE_MESSAGE_DIGEST
-       << "\n";
-    printf(_("Report bugs to %s"), "<tujikawa at users dot sourceforge dot net>");
-    cout << endl;
+	    << "\n";
+  printf(_("Report bugs to %s"), "<tujikawa at users dot sourceforge dot net>");
+  std::cout << std::endl;
 }
 
-void showUsage(const string& category) {
+void showUsage(const std::string& category) {
   printf(_("Usage: %s [options] URL ...\n"), PACKAGE_NAME);
 #ifdef ENABLE_BITTORRENT
   printf(_("       %s [options] -T TORRENT_FILE URL ...\n"), PACKAGE_NAME);
@@ -97,48 +101,51 @@ void showUsage(const string& category) {
 #ifdef ENABLE_METALINK
   printf(_("       %s [options] -M METALINK_FILE\n"), PACKAGE_NAME);
 #endif // ENABLE_METALINK
-  cout << endl;
+  std::cout << "\n";
 
-  TagContainerHandle tc = HelpItemFactory::createHelpItems();
-  TaggedItems items = category == V_ALL ? tc->getAllItems() : tc->search(category);
+  SharedHandle<TagContainer> tc = HelpItemFactory::createHelpItems();
+  std::deque<SharedHandle<TaggedItem> > items =
+    category == V_ALL ? tc->getAllItems() : tc->search(category);
   if(items.size() > 0) {
     if(category == V_ALL) {
       printf(_("Printing all options."));
     } else {
       printf(_("Printing options tagged with '%s'."), category.c_str());
-      cout << "\n";
+      std::cout << "\n";
       printf(_("See -h option to know other command-line options(%s)."),
-	       HelpItemHandle(tc->nameMatch("help"))->getAvailableValues().c_str());
+	     SharedHandle<HelpItem>(tc->nameMatch("help"))->getAvailableValues().c_str());
     }
-    cout << "\n";
-    cout << _("Options:") << endl;
-    copy(items.begin(), items.end(), ostream_iterator<HelpItemHandle>(cout, "\n"));
+    std::cout << "\n"
+	      << _("Options:") << "\n";
+    std::copy(items.begin(), items.end(), std::ostream_iterator<SharedHandle<HelpItem> >(std::cout, "\n"));
   } else {
-    TaggedItems items = tc->nameMatchForward(category);
+    std::deque<SharedHandle<TaggedItem> > items = tc->nameMatchForward(category);
     if(items.size() > 0) {
       printf(_("Printing options whose name starts with '%s'."), category.c_str());
-      cout << "\n";
-      cout << _("Options:") << endl;
-      copy(items.begin(), items.end(), ostream_iterator<HelpItemHandle>(cout, "\n"));
+      std::cout << "\n"
+		<< _("Options:") << "\n";
+      std::copy(items.begin(), items.end(), std::ostream_iterator<SharedHandle<HelpItem> >(std::cout, "\n"));
     } else {
       printf(_("No help category or option name matching with '%s'."), category.c_str());
-      cout << "\n";
-      cout << HelpItemHandle(tc->nameMatch("help")) << "\n";
+      std::cout << "\n"
+		<< SharedHandle<HelpItem>(tc->nameMatch("help")) << "\n";
     }
   }
   if(category == TAG_BASIC) {
-    cout << "\n"
-	 << "URL:" << "\n"
-	 << _(" You can specify multiple URLs. Unless you specify -Z option, all URLs must\n"
-	      " point to the same file or downloading will fail.") << "\n"
-	 << _(" You can specify both torrent file with -T option and URLs. By doing this,\n"
-	      " download a file from both torrent swarm and http/ftp server at the same time,\n"
-	      " while the data from http/ftp are uploaded to the torrent swarm. Note that\n"
-	      " only single file torrent can be integrated with http/ftp.") << "\n"
-	 << "\n"
-	 << _(" Make sure that URL is quoted with single(\') or double(\") quotation if it\n"
-	      " contains \"&\" or any characters that have special meaning in shell.") << "\n";
+    std::cout << "\n"
+	      << "URL:" << "\n"
+	      << _(" You can specify multiple URLs. Unless you specify -Z option, all URLs must\n"
+		   " point to the same file or downloading will fail.") << "\n"
+	      << _(" You can specify both torrent file with -T option and URLs. By doing this,\n"
+		   " download a file from both torrent swarm and http/ftp server at the same time,\n"
+		   " while the data from http/ftp are uploaded to the torrent swarm. Note that\n"
+		   " only single file torrent can be integrated with http/ftp.") << "\n"
+	      << "\n"
+	      << _(" Make sure that URL is quoted with single(\') or double(\") quotation if it\n"
+		   " contains \"&\" or any characters that have special meaning in shell.") << "\n";
   }
-  cout << "\n";
-  cout << _("Refer to man page for more information.") << endl;
+  std::cout << "\n"
+	    << _("Refer to man page for more information.") << std::endl;
 }
+
+} // namespace aria2
diff --git a/test/AllTest.cc b/test/AllTest.cc
index 6e93353c..41db8292 100644
--- a/test/AllTest.cc
+++ b/test/AllTest.cc
@@ -3,6 +3,9 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
 
+using aria2::SharedHandle;
+using aria2::SingletonHolder;
+
 int main(int argc, char* argv[]) {
   CppUnit::Test* suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
   CppUnit::TextUi::TestRunner runner;
@@ -11,8 +14,8 @@ int main(int argc, char* argv[]) {
   runner.setOutputter(new CppUnit::CompilerOutputter(&runner.result(), std::cerr));
   
   // setup
-  CookieBoxFactoryHandle cookieBoxFactory = new CookieBoxFactory();
-  CookieBoxFactorySingletonHolder::instance(cookieBoxFactory);
+  SharedHandle<aria2::CookieBoxFactory> cookieBoxFactory = new aria2::CookieBoxFactory();
+  SingletonHolder<SharedHandle<aria2::CookieBoxFactory> >::instance(cookieBoxFactory);
 
   // Run the tests.
   bool successfull = runner.run();
diff --git a/test/AlphaNumberDecoratorTest.cc b/test/AlphaNumberDecoratorTest.cc
index 5fd2501b..5aa9cec6 100644
--- a/test/AlphaNumberDecoratorTest.cc
+++ b/test/AlphaNumberDecoratorTest.cc
@@ -1,6 +1,9 @@
 #include "AlphaNumberDecorator.h"
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class AlphaNumberDecoratorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(AlphaNumberDecoratorTest);
@@ -24,18 +27,18 @@ CPPUNIT_TEST_SUITE_REGISTRATION( AlphaNumberDecoratorTest );
 
 void AlphaNumberDecoratorTest::testDecorate()
 {
-  CPPUNIT_ASSERT_EQUAL(string("a"), AlphaNumberDecorator(1).decorate(0));
-  CPPUNIT_ASSERT_EQUAL(string("z"), AlphaNumberDecorator(1).decorate(25));
-  CPPUNIT_ASSERT_EQUAL(string("zz"), AlphaNumberDecorator(1).decorate(675)); // 25*26+25
-  CPPUNIT_ASSERT_EQUAL(string("aab"), AlphaNumberDecorator(3).decorate(1));
+  CPPUNIT_ASSERT_EQUAL(std::string("a"), AlphaNumberDecorator(1).decorate(0));
+  CPPUNIT_ASSERT_EQUAL(std::string("z"), AlphaNumberDecorator(1).decorate(25));
+  CPPUNIT_ASSERT_EQUAL(std::string("zz"), AlphaNumberDecorator(1).decorate(675)); // 25*26+25
+  CPPUNIT_ASSERT_EQUAL(std::string("aab"), AlphaNumberDecorator(3).decorate(1));
 }
 
 void AlphaNumberDecoratorTest::testDecorate_uppercase()
 {
-  CPPUNIT_ASSERT_EQUAL(string("A"), AlphaNumberDecorator(1, true).decorate(0));
-  CPPUNIT_ASSERT_EQUAL(string("Z"), AlphaNumberDecorator(1, true).decorate(25));
-  CPPUNIT_ASSERT_EQUAL(string("ZZ"), AlphaNumberDecorator(1, true).decorate(675)); // 25*26+25
-  CPPUNIT_ASSERT_EQUAL(string("AAB"), AlphaNumberDecorator(3, true).decorate(1));
+  CPPUNIT_ASSERT_EQUAL(std::string("A"), AlphaNumberDecorator(1, true).decorate(0));
+  CPPUNIT_ASSERT_EQUAL(std::string("Z"), AlphaNumberDecorator(1, true).decorate(25));
+  CPPUNIT_ASSERT_EQUAL(std::string("ZZ"), AlphaNumberDecorator(1, true).decorate(675)); // 25*26+25
+  CPPUNIT_ASSERT_EQUAL(std::string("AAB"), AlphaNumberDecorator(3, true).decorate(1));
 }
 
 void AlphaNumberDecoratorTest::testDecorate_minus()
@@ -44,9 +47,11 @@ void AlphaNumberDecoratorTest::testDecorate_minus()
     AlphaNumberDecorator(1, true).decorate(-1);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(DlAbortEx* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("DlAbortEx must be thrown.");
   }
 }
+
+} // namespace aria2
diff --git a/test/AnnounceListTest.cc b/test/AnnounceListTest.cc
index 646b007a..4576c818 100644
--- a/test/AnnounceListTest.cc
+++ b/test/AnnounceListTest.cc
@@ -1,9 +1,10 @@
 #include "AnnounceList.h"
 #include "MetaFileUtil.h"
 #include "Exception.h"
+#include "Dictionary.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class AnnounceListTest:public CppUnit::TestFixture {
 
@@ -41,7 +42,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( AnnounceListTest );
 
 void AnnounceListTest::testSingleElementList() {
-  string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
+  std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
@@ -49,16 +50,16 @@ void AnnounceListTest::testSingleElementList() {
   AnnounceList announceList(announces);
   
   CPPUNIT_ASSERT(!announceList.allTiersFailed());
-  string url =  announceList.getAnnounce();
-  string event = announceList.getEventString();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
-  CPPUNIT_ASSERT_EQUAL(string("started"), event);
+  std::string url =  announceList.getAnnounce();
+  std::string event = announceList.getEventString();
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("started"), event);
   announceList.announceFailure();
   url =  announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
   announceList.announceFailure();
   url =  announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker3"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker3"), url);
   announceList.announceFailure();
   CPPUNIT_ASSERT(announceList.allTiersFailed());
   announceList.resetTier();
@@ -66,86 +67,86 @@ void AnnounceListTest::testSingleElementList() {
   // back to the first list
   url = announceList.getAnnounce();
   event = announceList.getEventString();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
-  CPPUNIT_ASSERT_EQUAL(string("started"), event);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("started"), event);
   announceList.announceFailure();
   url = announceList.getAnnounce();
   event = announceList.getEventString();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
-  CPPUNIT_ASSERT_EQUAL(string("started"), event);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("started"), event);
   announceList.announceSuccess();
   // back to the first list because announce to tracker2 succeeded.
   url = announceList.getAnnounce();
   event = announceList.getEventString();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
-  CPPUNIT_ASSERT_EQUAL(string("started"), event);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("started"), event);
   announceList.announceFailure();
   url = announceList.getAnnounce();
   event = announceList.getEventString();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
-  CPPUNIT_ASSERT_EQUAL(string(""), event);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string(""), event);
 }
 
 void AnnounceListTest::testMultiElementList() {
-  string peersString = "ll8:tracker18:tracker28:tracker3ee";
+  std::string peersString = "ll8:tracker18:tracker28:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
   // ANNOUNCE_LIST
   // [ [ tracker1, tracker2, tracker3 ] ]
   AnnounceList announceList(announces);
   
   CPPUNIT_ASSERT(!announceList.allTiersFailed());
-  string url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
+  std::string url = announceList.getAnnounce();
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
   announceList.announceFailure();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
   announceList.announceSuccess();
   url = announceList.getAnnounce();
   // tracker2 returns because tracker2 is now first.
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
   announceList.announceFailure();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
   announceList.announceFailure();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker3"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker3"), url);
   announceList.announceFailure();
   CPPUNIT_ASSERT(announceList.allTiersFailed());
   announceList.resetTier();
   CPPUNIT_ASSERT(!announceList.allTiersFailed());
   // back to the first list because there is no other list.
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
 }
 
 void AnnounceListTest::testSingleAndMulti() {
-  string peersString = "ll8:tracker18:tracker2el8:tracker3ee";
+  std::string peersString = "ll8:tracker18:tracker2el8:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
   // [ [ tracker1, tracker2 ], [ tracker3 ] ]
   AnnounceList announceList(announces);
 
-  string url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
+  std::string url = announceList.getAnnounce();
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
   announceList.announceSuccess();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
   announceList.announceFailure();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), url);
   announceList.announceFailure();
   url = announceList.getAnnounce();
-  CPPUNIT_ASSERT_EQUAL(string("tracker3"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker3"), url);
   announceList.announceSuccess();
   url = announceList.getAnnounce();
   // tracker1 returns because after the announce to tracker3 succeeds, list
   // pointer points to the first list.
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), url);
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), url);
 }
 
 void AnnounceListTest::testNoGroup() {
-  string peersString = "llee";
+  std::string peersString = "llee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   AnnounceList announceList(announces);
@@ -154,7 +155,7 @@ void AnnounceListTest::testNoGroup() {
 }
 
 void AnnounceListTest::testNextEventIfAfterStarted() {
-  string peersString = "ll8:tracker1ee";
+  std::string peersString = "ll8:tracker1ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
@@ -163,18 +164,18 @@ void AnnounceListTest::testNextEventIfAfterStarted() {
   announceList.setEvent(AnnounceTier::STOPPED);
   announceList.announceFailure();
   announceList.resetTier();
-  CPPUNIT_ASSERT_EQUAL(string(""), announceList.getEventString());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), announceList.getEventString());
   CPPUNIT_ASSERT_EQUAL(AnnounceTier::HALTED, announceList.getEvent());
 
   announceList.setEvent(AnnounceTier::COMPLETED);
   announceList.announceFailure();
   announceList.resetTier();
-  CPPUNIT_ASSERT_EQUAL(string(""), announceList.getEventString());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), announceList.getEventString());
   CPPUNIT_ASSERT_EQUAL(AnnounceTier::SEEDING, announceList.getEvent());
 }
 
 void AnnounceListTest::testEvent() {
-  string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
+  std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
@@ -183,22 +184,22 @@ void AnnounceListTest::testEvent() {
 
   announceList.setEvent(AnnounceTier::STOPPED);
   announceList.announceSuccess();
-  CPPUNIT_ASSERT_EQUAL(string(""), announceList.getEventString());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), announceList.getEventString());
   CPPUNIT_ASSERT_EQUAL(AnnounceTier::HALTED, announceList.getEvent());
 
   announceList.setEvent(AnnounceTier::COMPLETED);
   announceList.announceSuccess();
-  CPPUNIT_ASSERT_EQUAL(string(""), announceList.getEventString());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), announceList.getEventString());
   CPPUNIT_ASSERT_EQUAL(AnnounceTier::SEEDING, announceList.getEvent());
 
   announceList.setEvent(AnnounceTier::STARTED_AFTER_COMPLETION);
-  CPPUNIT_ASSERT_EQUAL(string("started"), announceList.getEventString());
+  CPPUNIT_ASSERT_EQUAL(std::string("started"), announceList.getEventString());
   announceList.announceSuccess();
   CPPUNIT_ASSERT_EQUAL(AnnounceTier::SEEDING, announceList.getEvent());
 }
 
 void AnnounceListTest::testCountStoppedAllowedTier() {
-  string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
+  std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
@@ -225,7 +226,7 @@ void AnnounceListTest::testCountStoppedAllowedTier() {
 }
 
 void AnnounceListTest::testCountCompletedAllowedTier() {
-  string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
+  std::string peersString = "ll8:tracker1el8:tracker2el8:tracker3ee";
   Dictionary* announces = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
   // ANNOUNCE_LIST
@@ -251,19 +252,19 @@ void AnnounceListTest::testCountCompletedAllowedTier() {
 
 }
 
-Strings createUrls(const string& url) {
-  Strings urls;
+std::deque<std::string> createUrls(const std::string& url) {
+  std::deque<std::string> urls;
   urls.push_back(url);
   return urls;
 }
 
 void AnnounceListTest::testMoveToStoppedAllowedTier() {
-  AnnounceTierHandle t1(new AnnounceTier(createUrls("tracker1")));
-  AnnounceTierHandle t2(new AnnounceTier(createUrls("tracker2")));
+  SharedHandle<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
+  SharedHandle<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
   t2->event = AnnounceTier::COMPLETED;
-  AnnounceTierHandle t3(new AnnounceTier(createUrls("tracker3")));
+  SharedHandle<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
 
-  AnnounceTiers tiers;
+  std::deque<SharedHandle<AnnounceTier> > tiers;
   tiers.push_back(t1);
   tiers.push_back(t2);
   tiers.push_back(t3);
@@ -271,25 +272,25 @@ void AnnounceListTest::testMoveToStoppedAllowedTier() {
   AnnounceList announceList(tiers);
 
   CPPUNIT_ASSERT(!announceList.currentTierAcceptsStoppedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), announceList.getAnnounce());
   announceList.moveToStoppedAllowedTier();
   CPPUNIT_ASSERT(announceList.currentTierAcceptsStoppedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), announceList.getAnnounce());
   announceList.announceFailure();
   CPPUNIT_ASSERT(!announceList.currentTierAcceptsStoppedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker3"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker3"), announceList.getAnnounce());
   // test wrapped search
   announceList.moveToStoppedAllowedTier();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), announceList.getAnnounce());  
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), announceList.getAnnounce());  
 }
 
 void AnnounceListTest::testMoveToCompletedAllowedTier() {
-  AnnounceTierHandle t1(new AnnounceTier(createUrls("tracker1")));
-  AnnounceTierHandle t2(new AnnounceTier(createUrls("tracker2")));
+  SharedHandle<AnnounceTier> t1(new AnnounceTier(createUrls("tracker1")));
+  SharedHandle<AnnounceTier> t2(new AnnounceTier(createUrls("tracker2")));
   t2->event = AnnounceTier::COMPLETED;
-  AnnounceTierHandle t3(new AnnounceTier(createUrls("tracker3")));
+  SharedHandle<AnnounceTier> t3(new AnnounceTier(createUrls("tracker3")));
 
-  AnnounceTiers tiers;
+  std::deque<SharedHandle<AnnounceTier> > tiers;
   tiers.push_back(t1);
   tiers.push_back(t2);
   tiers.push_back(t3);
@@ -297,14 +298,16 @@ void AnnounceListTest::testMoveToCompletedAllowedTier() {
   AnnounceList announceList(tiers);
 
   CPPUNIT_ASSERT(!announceList.currentTierAcceptsCompletedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker1"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker1"), announceList.getAnnounce());
   announceList.moveToStoppedAllowedTier();
   CPPUNIT_ASSERT(announceList.currentTierAcceptsCompletedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), announceList.getAnnounce());
   announceList.announceFailure();
   CPPUNIT_ASSERT(!announceList.currentTierAcceptsCompletedEvent());
-  CPPUNIT_ASSERT_EQUAL(string("tracker3"), announceList.getAnnounce());
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker3"), announceList.getAnnounce());
   // test wrapped search
   announceList.moveToStoppedAllowedTier();
-  CPPUNIT_ASSERT_EQUAL(string("tracker2"), announceList.getAnnounce());  
+  CPPUNIT_ASSERT_EQUAL(std::string("tracker2"), announceList.getAnnounce());  
 }
+
+} // namespace aria2
diff --git a/test/AuthConfigFactoryTest.cc b/test/AuthConfigFactoryTest.cc
index 0a735f31..1b8357e4 100644
--- a/test/AuthConfigFactoryTest.cc
+++ b/test/AuthConfigFactoryTest.cc
@@ -6,6 +6,8 @@
 #include "Option.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class AuthConfigFactoryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(AuthConfigFactoryTest);
@@ -25,7 +27,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( AuthConfigFactoryTest );
 
 void AuthConfigFactoryTest::testCreateAuthConfig_http()
 {
-  RequestHandle req = new Request();
+  SharedHandle<Request> req = new Request();
   req->setUrl("http://localhost/download/aria2-1.0.0.tar.bz2");
 
   Option option;
@@ -34,37 +36,37 @@ void AuthConfigFactoryTest::testCreateAuthConfig_http()
   AuthConfigFactory factory(&option);
 
   // without auth info
-  CPPUNIT_ASSERT_EQUAL(string(":"),
+  CPPUNIT_ASSERT_EQUAL(std::string(":"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // with Netrc: disabled by default
-  NetrcHandle netrc = new Netrc();
+  SharedHandle<Netrc> netrc = new Netrc();
   netrc->addAuthenticator(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount"));
   factory.setNetrc(netrc);
-  CPPUNIT_ASSERT_EQUAL(string(":"),
+  CPPUNIT_ASSERT_EQUAL(std::string(":"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // with Netrc + user defined
   option.put(PREF_HTTP_USER, "userDefinedUser");
   option.put(PREF_HTTP_PASSWD, "userDefinedPassword");
-  CPPUNIT_ASSERT_EQUAL(string("userDefinedUser:userDefinedPassword"),
+  CPPUNIT_ASSERT_EQUAL(std::string("userDefinedUser:userDefinedPassword"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // username and password in URI: disabled by default.
   req->setUrl("http://aria2user:aria2password@localhost/download/aria2-1.0.0.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("userDefinedUser:userDefinedPassword"),
+  CPPUNIT_ASSERT_EQUAL(std::string("userDefinedUser:userDefinedPassword"),
 		       factory.createAuthConfig(req)->getAuthText());
 
-//   CPPUNIT_ASSERT_EQUAL(string("aria2user:aria2password"),
+//   CPPUNIT_ASSERT_EQUAL(std::string("aria2user:aria2password"),
 // 		       factory.createAuthConfig(req)->getAuthText());
 }
 
 void AuthConfigFactoryTest::testCreateAuthConfigForHttpProxy()
 {
-  RequestHandle req = new Request();
+  SharedHandle<Request> req = new Request();
   req->setUrl("http://localhost/download/aria2-1.0.0.tar.bz2");
   // with Netrc
-  NetrcHandle netrc = new Netrc();
+  SharedHandle<Netrc> netrc = new Netrc();
   netrc->addAuthenticator(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount"));
 
   Option option;
@@ -74,19 +76,19 @@ void AuthConfigFactoryTest::testCreateAuthConfigForHttpProxy()
   factory.setNetrc(netrc);
 
   // netrc is not used in http proxy auth
-  CPPUNIT_ASSERT_EQUAL(string(":"),
+  CPPUNIT_ASSERT_EQUAL(std::string(":"),
 		       factory.createAuthConfigForHttpProxy(req)->getAuthText());
 
   option.put(PREF_HTTP_PROXY_USER, "userDefinedUser");
   option.put(PREF_HTTP_PROXY_PASSWD, "userDefinedPassword");
-  CPPUNIT_ASSERT_EQUAL(string("userDefinedUser:userDefinedPassword"),
+  CPPUNIT_ASSERT_EQUAL(std::string("userDefinedUser:userDefinedPassword"),
 		       factory.createAuthConfigForHttpProxy(req)->getAuthText());
 
 }
 
 void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
 {
-  RequestHandle req = new Request();
+  SharedHandle<Request> req = new Request();
   req->setUrl("ftp://localhost/download/aria2-1.0.0.tar.bz2");
 
   Option option;
@@ -95,30 +97,32 @@ void AuthConfigFactoryTest::testCreateAuthConfig_ftp()
   AuthConfigFactory factory(&option);
 
   // without auth info
-  CPPUNIT_ASSERT_EQUAL(string("anonymous:ARIA2USER@"),
+  CPPUNIT_ASSERT_EQUAL(std::string("anonymous:ARIA2USER@"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // with Netrc
-  NetrcHandle netrc = new Netrc();
+  SharedHandle<Netrc> netrc = new Netrc();
   netrc->addAuthenticator(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount"));
   factory.setNetrc(netrc);
-  CPPUNIT_ASSERT_EQUAL(string("default:defaultpassword"),
+  CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpassword"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // disable Netrc
   option.put(PREF_NO_NETRC, V_TRUE);
-  CPPUNIT_ASSERT_EQUAL(string("anonymous:ARIA2USER@"),
+  CPPUNIT_ASSERT_EQUAL(std::string("anonymous:ARIA2USER@"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // with Netrc + user defined
   option.put(PREF_NO_NETRC, V_FALSE);
   option.put(PREF_FTP_USER, "userDefinedUser");
   option.put(PREF_FTP_PASSWD, "userDefinedPassword");
-  CPPUNIT_ASSERT_EQUAL(string("userDefinedUser:userDefinedPassword"),
+  CPPUNIT_ASSERT_EQUAL(std::string("userDefinedUser:userDefinedPassword"),
 		       factory.createAuthConfig(req)->getAuthText());
 
   // username and password in URI
   req->setUrl("ftp://aria2user:aria2password@localhost/download/aria2-1.0.0.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("aria2user:aria2password"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2user:aria2password"),
  		       factory.createAuthConfig(req)->getAuthText());
 }
+
+} // namespace aria2
diff --git a/test/BNodeTest.cc b/test/BNodeTest.cc
index 57bc63d7..88d88d06 100644
--- a/test/BNodeTest.cc
+++ b/test/BNodeTest.cc
@@ -6,6 +6,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class BNodeTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(BNodeTest);
@@ -33,11 +35,11 @@ void BNodeTest::testIsInRange()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xff, DHT_ID_LENGTH);
 
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
 
-  DHTBucketHandle bucket1 = new DHTBucket(localNode);
-  DHTBucketHandle bucket2 = bucket1->split();
-  DHTBucketHandle bucket3 = bucket1->split();
+  SharedHandle<DHTBucket> bucket1 = new DHTBucket(localNode);
+  SharedHandle<DHTBucket> bucket2 = bucket1->split();
+  SharedHandle<DHTBucket> bucket3 = bucket1->split();
 
   {
     BNode b(bucket1);
@@ -54,13 +56,13 @@ void BNodeTest::testFindBucketFor()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
 
-  DHTBucketHandle bucket1 = new DHTBucket(localNode);
-  DHTBucketHandle bucket2 = bucket1->split();
-  DHTBucketHandle bucket3 = bucket1->split();
-  DHTBucketHandle bucket4 = bucket3->split();
-  DHTBucketHandle bucket5 = bucket3->split();
+  SharedHandle<DHTBucket> bucket1 = new DHTBucket(localNode);
+  SharedHandle<DHTBucket> bucket2 = bucket1->split();
+  SharedHandle<DHTBucket> bucket3 = bucket1->split();
+  SharedHandle<DHTBucket> bucket4 = bucket3->split();
+  SharedHandle<DHTBucket> bucket5 = bucket3->split();
 
   {
     BNode b(bucket5);
@@ -104,13 +106,13 @@ void BNodeTest::testFindClosestKNodes()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
 
-  DHTBucketHandle bucket1 = new DHTBucket(localNode);
-  DHTBucketHandle bucket2 = bucket1->split();
-  DHTBucketHandle bucket3 = bucket1->split();
-  DHTBucketHandle bucket4 = bucket3->split();
-  DHTBucketHandle bucket5 = bucket3->split();
+  SharedHandle<DHTBucket> bucket1 = new DHTBucket(localNode);
+  SharedHandle<DHTBucket> bucket2 = bucket1->split();
+  SharedHandle<DHTBucket> bucket3 = bucket1->split();
+  SharedHandle<DHTBucket> bucket4 = bucket3->split();
+  SharedHandle<DHTBucket> bucket5 = bucket3->split();
 
   unsigned char id[DHT_ID_LENGTH];
   {
@@ -152,7 +154,7 @@ void BNodeTest::testFindClosestKNodes()
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID);
+      std::deque<SharedHandle<DHTNode> > nodes = BNode::findClosestKNodes(bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket4->isInRange(nodes[0]));
       CPPUNIT_ASSERT(bucket4->isInRange(nodes[1]));
@@ -166,7 +168,7 @@ void BNodeTest::testFindClosestKNodes()
     {
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0xf0, DHT_ID_LENGTH);
-      DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID);
+      std::deque<SharedHandle<DHTNode> > nodes = BNode::findClosestKNodes(bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       CPPUNIT_ASSERT(bucket1->isInRange(nodes[0]));
       CPPUNIT_ASSERT(bucket1->isInRange(nodes[1]));
@@ -184,7 +186,7 @@ void BNodeTest::testFindClosestKNodes()
       }
       unsigned char targetID[DHT_ID_LENGTH];
       memset(targetID, 0x80, DHT_ID_LENGTH);
-      DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID);
+      std::deque<SharedHandle<DHTNode> > nodes = BNode::findClosestKNodes(bp4, targetID);
       CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
       for(size_t i = 0; i < DHTBucket::K; ++i) {
 	CPPUNIT_ASSERT(bucket4->isInRange(nodes[i]));
@@ -200,17 +202,17 @@ void BNodeTest::testEnumerateBucket()
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0xaa, DHT_ID_LENGTH);
 
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
 
-  DHTBucketHandle bucket1 = new DHTBucket(localNode);
-  DHTBucketHandle bucket2 = bucket1->split();
-  DHTBucketHandle bucket3 = bucket1->split();
-  DHTBucketHandle bucket4 = bucket3->split();
-  DHTBucketHandle bucket5 = bucket3->split();
+  SharedHandle<DHTBucket> bucket1 = new DHTBucket(localNode);
+  SharedHandle<DHTBucket> bucket2 = bucket1->split();
+  SharedHandle<DHTBucket> bucket3 = bucket1->split();
+  SharedHandle<DHTBucket> bucket4 = bucket3->split();
+  SharedHandle<DHTBucket> bucket5 = bucket3->split();
 
   {
     BNode b(bucket1);
-    DHTBuckets buckets = BNode::enumerateBucket(&b);
+    std::deque<SharedHandle<DHTBucket> > buckets = BNode::enumerateBucket(&b);
     CPPUNIT_ASSERT_EQUAL((size_t)1, buckets.size());
     CPPUNIT_ASSERT(bucket1 == buckets[0]);
   }
@@ -237,7 +239,7 @@ void BNodeTest::testEnumerateBucket()
     bp4->setLeft(bp3);
     bp4->setRight(b2);
 
-    DHTBuckets buckets = BNode::enumerateBucket(bp4);
+    std::deque<SharedHandle<DHTBucket> > buckets = BNode::enumerateBucket(bp4);
     CPPUNIT_ASSERT_EQUAL((size_t)5, buckets.size());
     CPPUNIT_ASSERT(bucket1 == buckets[0]);
     CPPUNIT_ASSERT(bucket3 == buckets[1]);
@@ -248,3 +250,5 @@ void BNodeTest::testEnumerateBucket()
     delete bp4;
   }
 }
+
+} // namespace aria2
diff --git a/test/Base64Test.cc b/test/Base64Test.cc
index 77fa61bd..cccb9e48 100644
--- a/test/Base64Test.cc
+++ b/test/Base64Test.cc
@@ -1,6 +1,8 @@
 #include "Base64.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class Base64Test:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(Base64Test);
@@ -29,53 +31,53 @@ CPPUNIT_TEST_SUITE_REGISTRATION( Base64Test );
 void Base64Test::testEncode() {
   unsigned char* buf = 0;
   size_t len;
-  string s1 = "Hello World!";
+  std::string s1 = "Hello World!";
   Base64::encode(buf, len, s1.c_str(), s1.size());
-  CPPUNIT_ASSERT_EQUAL(string("SGVsbG8gV29ybGQh"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("SGVsbG8gV29ybGQh"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s2 = "Hello World";
+  std::string s2 = "Hello World";
   Base64::encode(buf, len, s2.c_str(), s2.size());
-  CPPUNIT_ASSERT_EQUAL(string("SGVsbG8gV29ybGQ="), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("SGVsbG8gV29ybGQ="), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s3 = "Hello Worl";
+  std::string s3 = "Hello Worl";
   Base64::encode(buf, len, s3.c_str(), s3.size());
-  CPPUNIT_ASSERT_EQUAL(string("SGVsbG8gV29ybA=="), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("SGVsbG8gV29ybA=="), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s4 = "Man";
+  std::string s4 = "Man";
   Base64::encode(buf, len, s4.c_str(), s4.size());
-  CPPUNIT_ASSERT_EQUAL(string("TWFu"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("TWFu"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s5 = "M";
+  std::string s5 = "M";
   Base64::encode(buf, len, s5.c_str(), s5.size());
-  CPPUNIT_ASSERT_EQUAL(string("TQ=="), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("TQ=="), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
   buf = 0;
-  string s6 = "";
+  std::string s6 = "";
   Base64::encode(buf, len, s6.c_str(), s6.size());
-  CPPUNIT_ASSERT_EQUAL(string(""), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), std::string(&buf[0], &buf[len]));
   CPPUNIT_ASSERT_EQUAL((size_t)0, len);
   CPPUNIT_ASSERT(0 == buf);
 
   {
     const char temp[] = { -1 };
     Base64::encode(buf, len, temp, 1);
-    CPPUNIT_ASSERT_EQUAL(string("/w=="), string(&buf[0], &buf[len]));
+    CPPUNIT_ASSERT_EQUAL(std::string("/w=="), std::string(&buf[0], &buf[len]));
     delete [] buf;
   }
 }
 
 void Base64Test::testEncode_string()
 {
-  string s1 = "Hello World!";
-  CPPUNIT_ASSERT_EQUAL(string("SGVsbG8gV29ybGQh"), Base64::encode(s1));
+  std::string s1 = "Hello World!";
+  CPPUNIT_ASSERT_EQUAL(std::string("SGVsbG8gV29ybGQh"), Base64::encode(s1));
 
-  string s2 = "";
-  CPPUNIT_ASSERT_EQUAL(string(""), Base64::encode(s2));
+  std::string s2 = "";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Base64::encode(s2));
 
 
   
@@ -86,52 +88,52 @@ void Base64Test::testDecode()
   unsigned char* buf;
   size_t len;
 
-  string s1 = "SGVsbG8gV29ybGQh";
+  std::string s1 = "SGVsbG8gV29ybGQh";
   Base64::decode(buf, len, s1.c_str(), s1.size());
-  CPPUNIT_ASSERT_EQUAL(string("Hello World!"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello World!"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s2 = "SGVsbG8gV29ybGQ=";
+  std::string s2 = "SGVsbG8gV29ybGQ=";
   Base64::decode(buf, len, s2.c_str(), s2.size());
-  CPPUNIT_ASSERT_EQUAL(string("Hello World"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello World"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s3 = "SGVsbG8gV29ybA==";
+  std::string s3 = "SGVsbG8gV29ybA==";
   Base64::decode(buf, len, s3.c_str(), s3.size());
-  CPPUNIT_ASSERT_EQUAL(string("Hello Worl"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello Worl"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s4 = "TWFu";
+  std::string s4 = "TWFu";
   Base64::decode(buf, len, s4.c_str(), s4.size());
-  CPPUNIT_ASSERT_EQUAL(string("Man"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("Man"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
-  string s5 = "TQ==";
+  std::string s5 = "TQ==";
   Base64::decode(buf, len, s5.c_str(), s5.size());
-  CPPUNIT_ASSERT_EQUAL(string("M"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("M"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
   buf = 0;
-  string s6 = "";
+  std::string s6 = "";
   Base64::decode(buf, len, s6.c_str(), s6.size());
-  CPPUNIT_ASSERT_EQUAL(string(""), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), std::string(&buf[0], &buf[len]));
   CPPUNIT_ASSERT_EQUAL((size_t)0, len);
   CPPUNIT_ASSERT(!buf);
 
-  string s7 = "SGVsbG8\ngV2*9ybGQ=";
+  std::string s7 = "SGVsbG8\ngV2*9ybGQ=";
   Base64::decode(buf, len, s7.c_str(), s7.size());
-  CPPUNIT_ASSERT_EQUAL(string("Hello World"), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello World"), std::string(&buf[0], &buf[len]));
   delete [] buf;
 
   buf = 0;
-  string s8 = "SGVsbG8\ngV2*9ybGQ";
+  std::string s8 = "SGVsbG8\ngV2*9ybGQ";
   Base64::decode(buf, len, s8.c_str(), s8.size());
-  CPPUNIT_ASSERT_EQUAL(string(""), string(&buf[0], &buf[len]));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), std::string(&buf[0], &buf[len]));
   CPPUNIT_ASSERT_EQUAL((size_t)0, len);
   CPPUNIT_ASSERT(!buf);
 
   {
-    string s = "/w==";
+    std::string s = "/w==";
     Base64::decode(buf, len, s.c_str(), s.size());
     CPPUNIT_ASSERT_EQUAL((unsigned char)-1, buf[0]);
     delete [] buf;
@@ -141,16 +143,16 @@ void Base64Test::testDecode()
 
 void Base64Test::testDecode_string()
 {
-  string s1 = "SGVsbG8gV29ybGQh";
-  CPPUNIT_ASSERT_EQUAL(string("Hello World!"), Base64::decode(s1));
+  std::string s1 = "SGVsbG8gV29ybGQh";
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello World!"), Base64::decode(s1));
 
-  string s2 = "";
-  CPPUNIT_ASSERT_EQUAL(string(""), Base64::decode(s2));
+  std::string s2 = "";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Base64::decode(s2));
 }
 
 void Base64Test::testLongString()
 {
-  string s =
+  std::string s =
     "LyogPCEtLSBjb3B5cmlnaHQgKi8KLyoKICogYXJpYTIgLSBUaGUgaGlnaCBzcGVlZCBkb3dubG9h"
     "ZCB1dGlsaXR5CiAqCiAqIENvcHlyaWdodCAoQykgMjAwNiBUYXRzdWhpcm8gVHN1amlrYXdhCiAq"
     "CiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp"
@@ -180,7 +182,7 @@ void Base64Test::testLongString()
     "dGhpcyBleGNlcHRpb24gc3RhdGVtZW50IGZyb20gYWxsIHNvdXJjZQogKiBmaWxlcyBpbiB0aGUg"
     "cHJvZ3JhbSwgdGhlbiBhbHNvIGRlbGV0ZSBpdCBoZXJlLgogKi8KLyogY29weXJpZ2h0IC0tPiAq"
     "Lwo=";
-  string d =
+  std::string d =
     "/* <!-- copyright */\n"
     "/*\n"
     " * aria2 - The high speed download utility\n"
@@ -215,8 +217,8 @@ void Base64Test::testLongString()
     " * files in the program, then also delete it here.\n"
     " */\n"
     "/* copyright --> */\n";
-  CPPUNIT_ASSERT_EQUAL(d,
-		       Base64::decode(s));  
-  CPPUNIT_ASSERT_EQUAL(s,
-		       Base64::encode(d));  
+  CPPUNIT_ASSERT_EQUAL(d, Base64::decode(s));  
+  CPPUNIT_ASSERT_EQUAL(s, Base64::encode(d));  
 }
+
+} // namespace aria2
diff --git a/test/BencodeVisitorTest.cc b/test/BencodeVisitorTest.cc
index 3af7e0b4..0e780378 100644
--- a/test/BencodeVisitorTest.cc
+++ b/test/BencodeVisitorTest.cc
@@ -4,6 +4,8 @@
 #include "Dictionary.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class BencodeVisitorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(BencodeVisitorTest);
@@ -29,17 +31,17 @@ void BencodeVisitorTest::testVisit_data()
 {
   {
     BencodeVisitor v;
-    string str = "apple";
+    std::string str = "apple";
     MetaEntryHandle m = new Data(str.c_str(), str.size());
     m->accept(&v);
-    CPPUNIT_ASSERT_EQUAL(string("5:apple"), v.getBencodedData());
+    CPPUNIT_ASSERT_EQUAL(std::string("5:apple"), v.getBencodedData());
   }
   {
     BencodeVisitor v;
-    string str = "123";
+    std::string str = "123";
     MetaEntryHandle m = new Data(str.c_str(), str.size(), true);
     m->accept(&v);
-    CPPUNIT_ASSERT_EQUAL(string("i123e"), v.getBencodedData());
+    CPPUNIT_ASSERT_EQUAL(std::string("i123e"), v.getBencodedData());
   }
 }
 
@@ -47,24 +49,26 @@ void BencodeVisitorTest::testVisit_list()
 {
   BencodeVisitor v;
   List l;
-  string s1 = "alpha";
+  std::string s1 = "alpha";
   l.add(new Data(s1.c_str(), s1.size()));
-  string s2 = "bravo";
+  std::string s2 = "bravo";
   l.add(new Data(s2.c_str(), s2.size()));
-  string s3 = "123";
+  std::string s3 = "123";
   l.add(new Data(s3.c_str(), s3.size(), true));
   l.accept(&v);
-  CPPUNIT_ASSERT_EQUAL(string("l5:alpha5:bravoi123ee"), v.getBencodedData());
+  CPPUNIT_ASSERT_EQUAL(std::string("l5:alpha5:bravoi123ee"), v.getBencodedData());
 }
 
 void BencodeVisitorTest::testVisit_dictionary()
 {
   BencodeVisitor v;
   Dictionary d;
-  string s1 = "alpha";
+  std::string s1 = "alpha";
   d.put("team", new Data(s1.c_str(), s1.size()));
-  string s2 = "123";
+  std::string s2 = "123";
   d.put("score", new Data(s2.c_str(), s2.size(), true));
   d.accept(&v);
-  CPPUNIT_ASSERT_EQUAL(string("d4:team5:alpha5:scorei123ee"), v.getBencodedData());
+  CPPUNIT_ASSERT_EQUAL(std::string("d4:team5:alpha5:scorei123ee"), v.getBencodedData());
 }
+
+} // namespace aria2
diff --git a/test/BitfieldManTest.cc b/test/BitfieldManTest.cc
index 2ab69298..68ca78d1 100644
--- a/test/BitfieldManTest.cc
+++ b/test/BitfieldManTest.cc
@@ -2,6 +2,8 @@
 #include "FixedNumberRandomizer.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class BitfieldManTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(BitfieldManTest);
@@ -24,7 +26,7 @@ class BitfieldManTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCountFilteredBlock);
   CPPUNIT_TEST_SUITE_END();
 private:
-  RandomizerHandle fixedNumberRandomizer;
+  SharedHandle<Randomizer> fixedNumberRandomizer;
 
 public:
   BitfieldManTest():fixedNumberRandomizer(0) {
@@ -490,8 +492,8 @@ void BitfieldManTest::testGetAllMissingIndexes()
   peerBf.unsetBit(62);
 
   {
-    Integers indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
-					       peerBf.getBitfieldLength());
+    std::deque<int32_t> indexes = bf.getAllMissingIndexes(peerBf.getBitfield(),
+							  peerBf.getBitfieldLength());
     
     CPPUNIT_ASSERT_EQUAL((size_t)1, indexes.size());
     CPPUNIT_ASSERT_EQUAL(63, indexes.front());
@@ -559,3 +561,5 @@ void BitfieldManTest::testCountFilteredBlock()
   CPPUNIT_ASSERT_EQUAL(256, bt.countBlock());
   CPPUNIT_ASSERT_EQUAL(0, bt.countFilteredBlock());
 }
+
+} // namespace aria2
diff --git a/test/BtAllowedFastMessageTest.cc b/test/BtAllowedFastMessageTest.cc
index 449c6b3c..605e7951 100644
--- a/test/BtAllowedFastMessageTest.cc
+++ b/test/BtAllowedFastMessageTest.cc
@@ -1,9 +1,11 @@
 #include "BtAllowedFastMessage.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtAllowedFastMessageTest:public CppUnit::TestFixture {
 
@@ -34,7 +36,7 @@ void BtAllowedFastMessageTest::testCreate() {
   unsigned char msg[9];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 5, 17);
   PeerMessageUtil::setIntParam(&msg[5], 12345);
-  BtAllowedFastMessageHandle pm = BtAllowedFastMessage::create(&msg[4], 5);
+  SharedHandle<BtAllowedFastMessage> pm = BtAllowedFastMessage::create(&msg[4], 5);
   CPPUNIT_ASSERT_EQUAL((int8_t)17, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
 
@@ -68,7 +70,7 @@ void BtAllowedFastMessageTest::testGetMessage() {
 void BtAllowedFastMessageTest::testDoReceivedAction() {
   BtAllowedFastMessage msg;
   msg.setIndex(1);
-  PeerHandle peer = new Peer("localhost", 6969);
+  SharedHandle<Peer> peer = new Peer("localhost", 6969);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->isInPeerAllowedIndexSet(1));
@@ -85,7 +87,7 @@ void BtAllowedFastMessageTest::testDoReceivedAction() {
 void BtAllowedFastMessageTest::testOnSendComplete() {
   BtAllowedFastMessage msg;
   msg.setIndex(1);
-  PeerHandle peer = new Peer("localhost", 6969);
+  SharedHandle<Peer> peer = new Peer("localhost", 6969);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->isInAmAllowedIndexSet(1));
@@ -96,5 +98,7 @@ void BtAllowedFastMessageTest::testOnSendComplete() {
 void BtAllowedFastMessageTest::testToString() {
   BtAllowedFastMessage msg;
   msg.setIndex(1);
-  CPPUNIT_ASSERT_EQUAL(string("allowed fast index=1"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("allowed fast index=1"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtBitfieldMessageTest.cc b/test/BtBitfieldMessageTest.cc
index da28563f..50bc23d2 100644
--- a/test/BtBitfieldMessageTest.cc
+++ b/test/BtBitfieldMessageTest.cc
@@ -1,9 +1,11 @@
 #include "BtBitfieldMessage.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtBitfieldMessageTest:public CppUnit::TestFixture {
 
@@ -34,7 +36,7 @@ void BtBitfieldMessageTest::testCreate() {
   unsigned char bitfield[2];
   memset(bitfield, 0xff, sizeof(bitfield));
   memcpy(&msg[5], bitfield, sizeof(bitfield));
-  BtBitfieldMessageHandle pm = BtBitfieldMessage::create(&msg[4], 3);
+  SharedHandle<BtBitfieldMessage> pm = BtBitfieldMessage::create(&msg[4], 3);
   CPPUNIT_ASSERT_EQUAL((int8_t)5, pm->getId());
   CPPUNIT_ASSERT(memcmp(bitfield, pm->getBitfield(), sizeof(bitfield)) == 0);
   CPPUNIT_ASSERT_EQUAL((int32_t)2, pm->getBitfieldLength());
@@ -68,18 +70,18 @@ void BtBitfieldMessageTest::testGetMessage() {
 }
 
 void BtBitfieldMessageTest::testDoReceivedAction() {
-  PeerHandle peer = new Peer("host1", 6969);
+  SharedHandle<Peer> peer = new Peer("host1", 6969);
   peer->allocateBitfield(16*1024, 16*16*1024);
   BtBitfieldMessage msg;
   msg.setPeer(peer);
   unsigned char bitfield[] = { 0xff, 0xff };
   msg.setBitfield(bitfield, sizeof(bitfield));
   
-  CPPUNIT_ASSERT_EQUAL(string("0000"), Util::toHex(peer->getBitfield(),
-						   peer->getBitfieldLength()));
+  CPPUNIT_ASSERT_EQUAL(std::string("0000"), Util::toHex(peer->getBitfield(),
+							peer->getBitfieldLength()));
   msg.doReceivedAction();
-  CPPUNIT_ASSERT_EQUAL(string("ffff"), Util::toHex(peer->getBitfield(),
-						   peer->getBitfieldLength()));
+  CPPUNIT_ASSERT_EQUAL(std::string("ffff"), Util::toHex(peer->getBitfield(),
+							peer->getBitfieldLength()));
 }
 
 void BtBitfieldMessageTest::testToString() {
@@ -87,5 +89,7 @@ void BtBitfieldMessageTest::testToString() {
   unsigned char bitfield[] = { 0xff, 0xff };
   msg.setBitfield(bitfield, sizeof(bitfield));
 
-  CPPUNIT_ASSERT_EQUAL(string("bitfield ffff"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("bitfield ffff"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtCancelMessageTest.cc b/test/BtCancelMessageTest.cc
index dee1e14c..d9a06e7b 100644
--- a/test/BtCancelMessageTest.cc
+++ b/test/BtCancelMessageTest.cc
@@ -2,9 +2,20 @@
 #include "PeerMessageUtil.h"
 #include "MockBtMessageDispatcher.h"
 #include "MockBtContext.h"
+#include "Peer.h"
+#include "FileEntry.h"
+#include "PeerObject.h"
+#include "Piece.h"
+#include "BtRegistry.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtCancelMessageTest:public CppUnit::TestFixture {
 
@@ -18,8 +29,8 @@ private:
 public:
   BtCancelMessageTest():peer(0), btContext(0) {}
 
-  PeerHandle peer;
-  MockBtContextHandle btContext;
+  SharedHandle<Peer> peer;
+  SharedHandle<MockBtContext> btContext;
 
   void setUp() {
     BtRegistry::unregisterAll();    
@@ -51,8 +62,6 @@ public:
       this->length = length;
     }
   };
-
-  typedef SharedHandle<MockBtMessageDispatcher2> MockBtMessageDispatcher2Handle;
 };
 
 
@@ -64,7 +73,7 @@ void BtCancelMessageTest::testCreate() {
   PeerMessageUtil::setIntParam(&msg[5], 12345);
   PeerMessageUtil::setIntParam(&msg[9], 256);
   PeerMessageUtil::setIntParam(&msg[13], 1024);
-  BtCancelMessageHandle pm = BtCancelMessage::create(&msg[4], 13);
+  SharedHandle<BtCancelMessage> pm = BtCancelMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((int8_t)8, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)256, pm->getBegin());
@@ -108,7 +117,7 @@ void BtCancelMessageTest::testDoReceivedAction() {
   msg.setLength(16*1024);
   msg.setBtContext(btContext);
   msg.setPeer(peer);
-  MockBtMessageDispatcher2Handle dispatcher = new MockBtMessageDispatcher2();
+  SharedHandle<MockBtMessageDispatcher2> dispatcher = new MockBtMessageDispatcher2();
   msg.setBtMessageDispatcher(dispatcher);
 
   msg.doReceivedAction();
@@ -116,3 +125,5 @@ void BtCancelMessageTest::testDoReceivedAction() {
   CPPUNIT_ASSERT_EQUAL(msg.getBegin(), dispatcher->begin);
   CPPUNIT_ASSERT_EQUAL(msg.getLength(), dispatcher->length);
 }
+
+} // namespace aria2
diff --git a/test/BtChokeMessageTest.cc b/test/BtChokeMessageTest.cc
index 432c22fc..353542b5 100644
--- a/test/BtChokeMessageTest.cc
+++ b/test/BtChokeMessageTest.cc
@@ -3,9 +3,18 @@
 #include "MockBtMessageDispatcher.h"
 #include "MockBtRequestFactory.h"
 #include "MockBtContext.h"
+#include "Peer.h"
+#include "FileEntry.h"
+#include "BtRegistry.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtChokeMessageTest:public CppUnit::TestFixture {
 
@@ -21,8 +30,8 @@ private:
 public:
   BtChokeMessageTest():peer(0), btContext(0) {}
 
-  PeerHandle peer;
-  MockBtContextHandle btContext;
+  SharedHandle<Peer> peer;
+  SharedHandle<MockBtContext> btContext;
 
   void setUp() {
     BtRegistry::unregisterAll();    
@@ -56,8 +65,6 @@ public:
     }
   };
 
-  typedef SharedHandle<MockBtMessageDispatcher2> MockBtMessageDispatcher2Handle;
-
   class MockBtRequestFactory2 : public MockBtRequestFactory {
   public:
     bool doChokedActionCalled;
@@ -68,8 +75,6 @@ public:
       doChokedActionCalled = true;
     }
   };
-
-  typedef SharedHandle<MockBtRequestFactory2> MockBtRequestFactory2Handle;
 };
 
 
@@ -78,7 +83,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtChokeMessageTest);
 void BtChokeMessageTest::testCreate() {
   unsigned char msg[5];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 1, 0);
-  BtChokeMessageHandle pm = BtChokeMessage::create(&msg[4], 1);
+  SharedHandle<BtChokeMessage> pm = BtChokeMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((int8_t)0, pm->getId());
 
   // case: payload size is wrong
@@ -111,9 +116,9 @@ void BtChokeMessageTest::testDoReceivedAction() {
   msg.setPeer(peer);
   msg.setBtContext(btContext);
 
-  MockBtMessageDispatcher2Handle dispatcher = new MockBtMessageDispatcher2();
+  SharedHandle<MockBtMessageDispatcher2> dispatcher = new MockBtMessageDispatcher2();
   msg.setBtMessageDispatcher(dispatcher);
-  MockBtRequestFactory2Handle requestFactory = new MockBtRequestFactory2();
+  SharedHandle<MockBtRequestFactory2> requestFactory = new MockBtRequestFactory2();
   msg.setBtRequestFactory(requestFactory);
 
   msg.doReceivedAction();
@@ -127,7 +132,7 @@ void BtChokeMessageTest::testOnSendComplete() {
   msg.setPeer(peer);
   msg.setBtContext(btContext);
 
-  MockBtMessageDispatcher2Handle dispatcher = new MockBtMessageDispatcher2();
+  SharedHandle<MockBtMessageDispatcher2> dispatcher = new MockBtMessageDispatcher2();
   msg.setBtMessageDispatcher(dispatcher);
 
   msg.onSendComplete();
@@ -138,5 +143,7 @@ void BtChokeMessageTest::testOnSendComplete() {
 
 void BtChokeMessageTest::testToString() {
   BtChokeMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("choke"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("choke"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtDependencyTest.cc b/test/BtDependencyTest.cc
index 174ce4fb..bff84dbb 100644
--- a/test/BtDependencyTest.cc
+++ b/test/BtDependencyTest.cc
@@ -6,8 +6,11 @@
 #include "Option.h"
 #include "Exception.h"
 #include "SegmentMan.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class BtDependencyTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(BtDependencyTest);
@@ -17,20 +20,21 @@ class BtDependencyTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testResolve_dependeeInProgress);
   CPPUNIT_TEST_SUITE_END();
 
-  RequestGroupHandle createDependant(const Option* option)
+  SharedHandle<RequestGroup> createDependant(const Option* option)
   {
-    RequestGroupHandle dependant = new RequestGroup(option, Strings());
-    SingleFileDownloadContextHandle dctx =
+    SharedHandle<RequestGroup> dependant = new RequestGroup(option, std::deque<std::string>());
+    SharedHandle<SingleFileDownloadContext> dctx =
       new SingleFileDownloadContext(0, 0, "");
     dctx->setDir("/tmp");
     dependant->setDownloadContext(dctx);
     return dependant;
   }
 
-  RequestGroupHandle createDependee(const Option* option, const string& torrentFile, int64_t length)
+  SharedHandle<RequestGroup>
+  createDependee(const Option* option, const std::string& torrentFile, int64_t length)
   {
-    RequestGroupHandle dependee = new RequestGroup(option, Strings());
-    SingleFileDownloadContextHandle dctx =
+    SharedHandle<RequestGroup> dependee = new RequestGroup(option, std::deque<std::string>());
+    SharedHandle<SingleFileDownloadContext> dctx =
       new SingleFileDownloadContext(1024*1024, length, torrentFile);
     dctx->setDir(".");
     dependee->setDownloadContext(dctx);
@@ -55,36 +59,36 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtDependencyTest );
 
 void BtDependencyTest::testResolve()
 {
-  string filename = "test.torrent";
+  std::string filename = "test.torrent";
   Option option;
-  RequestGroupHandle dependant = createDependant(&option);
-  RequestGroupHandle dependee = createDependee(&option, filename, File(filename).size());
+  SharedHandle<RequestGroup> dependant = createDependant(&option);
+  SharedHandle<RequestGroup> dependee = createDependee(&option, filename, File(filename).size());
   dependee->getPieceStorage()->markAllPiecesDone();
   
   BtDependency dep(dependant, dependee, &option);
   CPPUNIT_ASSERT(dep.resolve());
   
-  BtContextHandle btContext = dependant->getDownloadContext();
+  SharedHandle<BtContext> btContext = dependant->getDownloadContext();
   CPPUNIT_ASSERT(!btContext.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("/tmp/aria2-test"), btContext->getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-test"), btContext->getActualBasePath());
 }
 
 void BtDependencyTest::testResolve_loadError()
 {
   try {
     Option option;
-    RequestGroupHandle dependant = createDependant(&option);
-    RequestGroupHandle dependee = createDependee(&option, "notExist", 40);
+    SharedHandle<RequestGroup> dependant = createDependant(&option);
+    SharedHandle<RequestGroup> dependee = createDependee(&option, "notExist", 40);
     dependee->getPieceStorage()->markAllPiecesDone();
     
     BtDependency dep(dependant, dependee, &option);
     CPPUNIT_ASSERT(dep.resolve());
     
-    SingleFileDownloadContextHandle dctx = dependant->getDownloadContext();
+    SharedHandle<SingleFileDownloadContext> dctx = dependant->getDownloadContext();
     CPPUNIT_ASSERT(!dctx.isNull());
-    CPPUNIT_ASSERT_EQUAL(string("/tmp/index.html"), dctx->getActualBasePath());
+    CPPUNIT_ASSERT_EQUAL(std::string("/tmp/index.html"), dctx->getActualBasePath());
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
     CPPUNIT_FAIL("an exception was thrown.");
   }
@@ -93,25 +97,27 @@ void BtDependencyTest::testResolve_loadError()
 void BtDependencyTest::testResolve_dependeeFailure()
 {
   Option option;
-  RequestGroupHandle dependant = createDependant(&option);
-  RequestGroupHandle dependee = createDependee(&option, "notExist", 40);
+  SharedHandle<RequestGroup> dependant = createDependant(&option);
+  SharedHandle<RequestGroup> dependee = createDependee(&option, "notExist", 40);
     
   BtDependency dep(dependant, dependee, &option);
   CPPUNIT_ASSERT(dep.resolve());
   
-  SingleFileDownloadContextHandle dctx = dependant->getDownloadContext();
+  SharedHandle<SingleFileDownloadContext> dctx = dependant->getDownloadContext();
   CPPUNIT_ASSERT(!dctx.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("/tmp/index.html"), dctx->getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("/tmp/index.html"), dctx->getActualBasePath());
 }
 
 void BtDependencyTest::testResolve_dependeeInProgress()
 {
-  string filename = "test.torrent";
+  std::string filename = "test.torrent";
   Option option;
-  RequestGroupHandle dependant = createDependant(&option);
-  RequestGroupHandle dependee = createDependee(&option, filename, File(filename).size());
+  SharedHandle<RequestGroup> dependant = createDependant(&option);
+  SharedHandle<RequestGroup> dependee = createDependee(&option, filename, File(filename).size());
   dependee->increaseNumCommand();
 
   BtDependency dep(dependant, dependee, &option);
   CPPUNIT_ASSERT(!dep.resolve());
 }
+
+} // namespace aria2
diff --git a/test/BtExtendedMessageTest.cc b/test/BtExtendedMessageTest.cc
index 34ee594e..9eeedfca 100644
--- a/test/BtExtendedMessageTest.cc
+++ b/test/BtExtendedMessageTest.cc
@@ -2,9 +2,20 @@
 #include "PeerMessageUtil.h"
 #include "MockBtContext.h"
 #include "MockExtensionMessageFactory.h"
+#include "BtRegistry.h"
+#include "Peer.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "Exception.h"
+#include "FileEntry.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtExtendedMessageTest:public CppUnit::TestFixture {
 
@@ -37,30 +48,30 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(BtExtendedMessageTest);
 
 void BtExtendedMessageTest::testCreate() {
-  PeerHandle peer = new Peer("192.168.0.1", 6969);
+  SharedHandle<Peer> peer = new Peer("192.168.0.1", 6969);
   peer->setExtension("charlie", 1);
-  MockBtContextHandle ctx = new MockBtContext();
+  SharedHandle<MockBtContext> ctx = new MockBtContext();
   unsigned char infohash[20];
   memset(infohash, 0, sizeof(infohash));
   ctx->setInfoHash(infohash);
-  MockExtensionMessageFactoryHandle exmsgFactory = new MockExtensionMessageFactory();
+  SharedHandle<MockExtensionMessageFactory> exmsgFactory = new MockExtensionMessageFactory();
   
 
   BtRegistry::registerPeerObjectCluster(ctx->getInfoHashAsString(), new PeerObjectCluster());
-  PeerObjectHandle peerObject = new PeerObject();
+  SharedHandle<PeerObject> peerObject = new PeerObject();
   peerObject->extensionMessageFactory = exmsgFactory;
 
   PEER_OBJECT_CLUSTER(ctx)->registerHandle(peer->getId(), peerObject);
 
   // payload:{4:name3:foo}->11bytes
-  string payload = "4:name3:foo";
+  std::string payload = "4:name3:foo";
   char msg[17];// 6+11bytes
   PeerMessageUtil::createPeerMessageString((unsigned char*)msg, sizeof(msg), 13, 20);
   msg[5] = 1; // Set dummy extended message ID 1
   memcpy(msg+6, payload.c_str(), payload.size());
-  BtExtendedMessageHandle pm = BtExtendedMessage::create(ctx,
-							 peer,
-							 &msg[4], 13);
+  SharedHandle<BtExtendedMessage> pm = BtExtendedMessage::create(ctx,
+								 peer,
+								 &msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((int8_t)20, pm->getId());
   
   // case: payload size is wrong
@@ -70,7 +81,7 @@ void BtExtendedMessageTest::testCreate() {
     BtExtendedMessage::create(ctx, peer, &msg[4], 1);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
   // case: id is wrong
@@ -80,15 +91,15 @@ void BtExtendedMessageTest::testCreate() {
     BtExtendedMessage::create(ctx, peer, &msg[4], 2);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
 
 void BtExtendedMessageTest::testGetMessage() {
-  string payload = "4:name3:foo";
+  std::string payload = "4:name3:foo";
   uint8_t extendedMessageID = 1;
-  MockExtensionMessageHandle exmsg =
+  SharedHandle<MockExtensionMessage> exmsg =
     new MockExtensionMessage("charlie", extendedMessageID,
 			     payload.c_str(),
 			     payload.size());
@@ -102,7 +113,7 @@ void BtExtendedMessageTest::testGetMessage() {
 }
 
 void BtExtendedMessageTest::testDoReceivedAction() {
-  MockExtensionMessageHandle exmsg =
+  SharedHandle<MockExtensionMessage> exmsg =
     new MockExtensionMessage("charlie", 1, "", 0);
   BtExtendedMessage msg(exmsg);
   msg.doReceivedAction();
@@ -110,12 +121,14 @@ void BtExtendedMessageTest::testDoReceivedAction() {
 }
   
 void BtExtendedMessageTest::testToString() {
-  string payload = "4:name3:foo";
+  std::string payload = "4:name3:foo";
   uint8_t extendedMessageID = 1;
-  MockExtensionMessageHandle exmsg =
+  SharedHandle<MockExtensionMessage> exmsg =
     new MockExtensionMessage("charlie", extendedMessageID,
 			     payload.c_str(),
 			     payload.size());
   BtExtendedMessage msg(exmsg);
-  CPPUNIT_ASSERT_EQUAL(string("extended charlie"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("extended charlie"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtHandshakeMessageTest.cc b/test/BtHandshakeMessageTest.cc
index ce57b7f4..21da5f2a 100644
--- a/test/BtHandshakeMessageTest.cc
+++ b/test/BtHandshakeMessageTest.cc
@@ -1,9 +1,11 @@
 #include "BtHandshakeMessage.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
+#include "BtConstants.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtHandshakeMessageTest:public CppUnit::TestFixture {
 
@@ -24,11 +26,11 @@ public:
   void testToString();
   void testSetDHTEnabled();
 
-  static string BTPSTR;
+  static std::string BTPSTR;
 };
 
 
-string BtHandshakeMessageTest::BTPSTR = "BitTorrent protocol";
+std::string BtHandshakeMessageTest::BTPSTR = "BitTorrent protocol";
 
 CPPUNIT_TEST_SUITE_REGISTRATION(BtHandshakeMessageTest);
 
@@ -53,16 +55,16 @@ void createHandshakeMessageData(unsigned char* msg) {
 void BtHandshakeMessageTest::testCreate() {
   unsigned char msg[68];
   createHandshakeMessageData(msg);
-  BtHandshakeMessageHandle message = BtHandshakeMessage::create(&msg[0], sizeof(msg));
+  SharedHandle<BtHandshakeMessage> message = BtHandshakeMessage::create(&msg[0], sizeof(msg));
   CPPUNIT_ASSERT_EQUAL((int8_t)INT8_MAX, message->getId());
   CPPUNIT_ASSERT_EQUAL((int8_t)19, message->getPstrlen());
   CPPUNIT_ASSERT_EQUAL(Util::toHex((const unsigned char*)BTPSTR.c_str(), BTPSTR.size()),
 		       Util::toHex(message->getPstr(), BtHandshakeMessage::PSTR_LENGTH));
-  CPPUNIT_ASSERT_EQUAL(string("0000000000100004"),
+  CPPUNIT_ASSERT_EQUAL(std::string("0000000000100004"),
 		       Util::toHex(message->getReserved(), BtHandshakeMessage::RESERVED_LENGTH));
-  CPPUNIT_ASSERT_EQUAL(string("ffffffffffffffffffffffffffffffffffffffff"),
+  CPPUNIT_ASSERT_EQUAL(std::string("ffffffffffffffffffffffffffffffffffffffff"),
 		       Util::toHex(message->getInfoHash(), INFO_HASH_LENGTH));
-  CPPUNIT_ASSERT_EQUAL(string("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"),
+  CPPUNIT_ASSERT_EQUAL(std::string("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"),
 		       Util::toHex(message->getPeerId(), PEER_ID_LENGTH));
 }
 
@@ -76,7 +78,7 @@ void BtHandshakeMessageTest::testGetMessage() {
 			     0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
 			     0xf0, 0xf0, 0xf0, 0xf0, 0xf0 };
 
-  BtHandshakeMessageHandle msg = new BtHandshakeMessage();
+  SharedHandle<BtHandshakeMessage> msg = new BtHandshakeMessage();
   msg->setInfoHash(infoHash);
   msg->setPeerId(peerId);
 
@@ -100,7 +102,7 @@ void BtHandshakeMessageTest::testToString() {
   msg.setInfoHash(infoHash);
   msg.setPeerId(peerId);
 
-  CPPUNIT_ASSERT_EQUAL(string("handshake peerId=%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0, reserved=0000000000100004"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("handshake peerId=%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0, reserved=0000000000100004"), msg.toString());
 }
 
 void BtHandshakeMessageTest::testSetDHTEnabled()
@@ -112,3 +114,5 @@ void BtHandshakeMessageTest::testSetDHTEnabled()
   msg.setDHTEnabled(true);
   CPPUNIT_ASSERT(msg.isDHTEnabled());
 }
+
+} // namespace aria2
diff --git a/test/BtHaveAllMessageTest.cc b/test/BtHaveAllMessageTest.cc
index 362735f9..a5c28781 100644
--- a/test/BtHaveAllMessageTest.cc
+++ b/test/BtHaveAllMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtHaveAllMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtHaveAllMessageTest:public CppUnit::TestFixture {
 
@@ -28,7 +30,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtHaveAllMessageTest);
 void BtHaveAllMessageTest::testCreate() {
   unsigned char msg[5];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 1, 14);
-  BtHaveAllMessageHandle pm = BtHaveAllMessage::create(&msg[4], 1);
+  SharedHandle<BtHaveAllMessage> pm = BtHaveAllMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((int8_t)14, pm->getId());
 
   // case: payload size is wrong
@@ -58,7 +60,7 @@ void BtHaveAllMessageTest::testGetMessage() {
 
 void BtHaveAllMessageTest::testDoReceivedAction() {
   BtHaveAllMessage msg;
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->allocateBitfield(16*1024, 256*1024);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
@@ -74,3 +76,5 @@ void BtHaveAllMessageTest::testDoReceivedAction() {
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(...) {}
 }
+
+} // namespace aria2
diff --git a/test/BtHaveMessageTest.cc b/test/BtHaveMessageTest.cc
index e794550c..4ffa8274 100644
--- a/test/BtHaveMessageTest.cc
+++ b/test/BtHaveMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtHaveMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtHaveMessageTest:public CppUnit::TestFixture {
 
@@ -31,7 +33,7 @@ void BtHaveMessageTest::testCreate() {
   unsigned char msg[9];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 5, 4);
   PeerMessageUtil::setIntParam(&msg[5], 12345);
-  BtHaveMessageHandle pm = BtHaveMessage::create(&msg[4], 5);
+  SharedHandle<BtHaveMessage> pm = BtHaveMessage::create(&msg[4], 5);
   CPPUNIT_ASSERT_EQUAL((int8_t)4, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
 
@@ -63,7 +65,7 @@ void BtHaveMessageTest::testGetMessage() {
 }
 
 void BtHaveMessageTest::testDoReceivedAction() {
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->allocateBitfield(16*1024, 256*1024);
   BtHaveMessage msg;
   msg.setIndex(1);
@@ -80,5 +82,7 @@ void BtHaveMessageTest::testToString() {
   BtHaveMessage msg;
   msg.setIndex(1);
 
-  CPPUNIT_ASSERT_EQUAL(string("have index=1"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("have index=1"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtHaveNoneMessageTest.cc b/test/BtHaveNoneMessageTest.cc
index 41d13cce..8bad7343 100644
--- a/test/BtHaveNoneMessageTest.cc
+++ b/test/BtHaveNoneMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtHaveNoneMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtHaveNoneMessageTest:public CppUnit::TestFixture {
 
@@ -30,7 +32,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtHaveNoneMessageTest);
 void BtHaveNoneMessageTest::testCreate() {
   unsigned char msg[5];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 1, 15);
-  BtHaveNoneMessageHandle pm = BtHaveNoneMessage::create(&msg[4], 1);
+  SharedHandle<BtHaveNoneMessage> pm = BtHaveNoneMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((int8_t)15, pm->getId());
 
   // case: payload size is wrong
@@ -60,7 +62,7 @@ void BtHaveNoneMessageTest::testGetMessage() {
 
 void BtHaveNoneMessageTest::testDoReceivedAction() {
   BtHaveNoneMessage msg;
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->setFastExtensionEnabled(true);
   msg.setPeer(peer);
   msg.doReceivedAction();
@@ -74,5 +76,7 @@ void BtHaveNoneMessageTest::testDoReceivedAction() {
 
 void BtHaveNoneMessageTest::testToString() {
   BtHaveNoneMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("have none"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("have none"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtInterestedMessageTest.cc b/test/BtInterestedMessageTest.cc
index 372cb2c0..091f51dc 100644
--- a/test/BtInterestedMessageTest.cc
+++ b/test/BtInterestedMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtInterestedMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtInterestedMessageTest:public CppUnit::TestFixture {
 
@@ -62,7 +64,7 @@ void BtInterestedMessageTest::testGetMessage() {
 
 void BtInterestedMessageTest::testDoReceivedAction() {
   BtInterestedMessage msg;
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->peerInterested);
   msg.doReceivedAction();
@@ -71,7 +73,7 @@ void BtInterestedMessageTest::testDoReceivedAction() {
 
 void BtInterestedMessageTest::testOnSendComplete() {
   BtInterestedMessage msg;
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   msg.setPeer(peer);
   CPPUNIT_ASSERT(!peer->amInterested);
   msg.onSendComplete();
@@ -80,5 +82,7 @@ void BtInterestedMessageTest::testOnSendComplete() {
 
 void BtInterestedMessageTest::testToString() {
   BtInterestedMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("interested"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("interested"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtKeepAliveMessageTest.cc b/test/BtKeepAliveMessageTest.cc
index 0009952a..fc1a4e37 100644
--- a/test/BtKeepAliveMessageTest.cc
+++ b/test/BtKeepAliveMessageTest.cc
@@ -1,7 +1,8 @@
 #include "BtKeepAliveMessage.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtKeepAliveMessageTest:public CppUnit::TestFixture {
 
@@ -32,5 +33,7 @@ void BtKeepAliveMessageTest::testGetMessage() {
 
 void BtKeepAliveMessageTest::testToString() {
   BtKeepAliveMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("keep alive"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("keep alive"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtNotInterestedMessageTest.cc b/test/BtNotInterestedMessageTest.cc
index 6b33640a..41a9f275 100644
--- a/test/BtNotInterestedMessageTest.cc
+++ b/test/BtNotInterestedMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtNotInterestedMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtNotInterestedMessageTest:public CppUnit::TestFixture {
 
@@ -61,7 +63,7 @@ void BtNotInterestedMessageTest::testGetMessage() {
 }
 
 void BtNotInterestedMessageTest::testDoReceivedAction() {
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->peerInterested = true;
   BtNotInterestedMessage msg;
   msg.setPeer(peer);
@@ -71,7 +73,7 @@ void BtNotInterestedMessageTest::testDoReceivedAction() {
 }
 
 void BtNotInterestedMessageTest::testOnSendComplete() {
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->amInterested = true;
   BtNotInterestedMessage msg;
   msg.setPeer(peer);
@@ -82,5 +84,7 @@ void BtNotInterestedMessageTest::testOnSendComplete() {
 
 void BtNotInterestedMessageTest::testToString() {
   BtNotInterestedMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("not interested"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("not interested"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtPieceMessageTest.cc b/test/BtPieceMessageTest.cc
index f82dc6fe..7683a6d1 100644
--- a/test/BtPieceMessageTest.cc
+++ b/test/BtPieceMessageTest.cc
@@ -6,9 +6,19 @@
 #include "MockBtMessageDispatcher.h"
 #include "BtChokingEvent.h"
 #include "BtCancelSendingPieceEvent.h"
+#include "FileEntry.h"
+#include "Peer.h"
+#include "Piece.h"
+#include "BtRegistry.h"
+#include "PeerObject.h"
+#include "BtMessageReceiver.h"
+#include "BtRequestFactory.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtPieceMessageTest:public CppUnit::TestFixture {
 
@@ -54,28 +64,25 @@ public:
 
   };
 
-  typedef SharedHandle<MockBtMessage2> MockBtMessage2Handle;
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual BtMessageHandle createRejectMessage(int32_t index,
-						int32_t begin,
-						int32_t length) {
-      MockBtMessage2Handle msg = new MockBtMessage2(index, begin, length);
+    virtual SharedHandle<BtMessage>
+    createRejectMessage(int32_t index,
+			int32_t begin,
+			int32_t length) {
+      SharedHandle<MockBtMessage2> msg = new MockBtMessage2(index, begin, length);
       return msg;
     }
   };
 
-  typedef SharedHandle<MockBtMessageFactory2> MockBtMessageFactory2Handle;
-
-  MockBtMessageDispatcherHandle btMessageDispatcher;
-  PeerHandle peer;
-  BtPieceMessageHandle msg;
+  SharedHandle<MockBtMessageDispatcher> btMessageDispatcher;
+  SharedHandle<Peer> peer;
+  SharedHandle<BtPieceMessage> msg;
 
   void setUp() {
     BtRegistry::unregisterAll();
 
-    MockBtContextHandle btContext;
+    SharedHandle<MockBtContext> btContext;
     btContext->setInfoHash((const unsigned char*)"12345678901234567890");
     btContext->setPieceLength(16*1024);
     btContext->setTotalLength(256*1024);
@@ -110,7 +117,7 @@ void BtPieceMessageTest::testCreate() {
   PeerMessageUtil::setIntParam(&msg[5], 12345);
   PeerMessageUtil::setIntParam(&msg[9], 256);
   memcpy(&msg[13], data, sizeof(data));
-  BtPieceMessageHandle pm = BtPieceMessage::create(&msg[4], 11);
+  SharedHandle<BtPieceMessage> pm = BtPieceMessage::create(&msg[4], 11);
   CPPUNIT_ASSERT_EQUAL((int8_t)7, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)256, pm->getBegin());
@@ -287,6 +294,8 @@ void BtPieceMessageTest::testCancelSendingPieceEvent_sendingInProgress() {
 }
 
 void BtPieceMessageTest::testToString() {
-  CPPUNIT_ASSERT_EQUAL(string("piece index=1, begin=1024, length=16384"),
+  CPPUNIT_ASSERT_EQUAL(std::string("piece index=1, begin=1024, length=16384"),
 		 msg->toString());
 }
+
+} // namespace aria2
diff --git a/test/BtPortMessageTest.cc b/test/BtPortMessageTest.cc
index f1c63f6d..5438caad 100644
--- a/test/BtPortMessageTest.cc
+++ b/test/BtPortMessageTest.cc
@@ -1,13 +1,15 @@
 #include "BtPortMessage.h"
 #include "PeerMessageUtil.h"
 #include "Util.h"
+#include "Peer.h"
 #include "DHTNode.h"
 #include "MockDHTTask.h"
 #include "MockDHTTaskFactory.h"
 #include "MockDHTTaskQueue.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtPortMessageTest:public CppUnit::TestFixture {
 
@@ -30,8 +32,8 @@ public:
 
   class MockDHTTaskFactory2:public MockDHTTaskFactory {
   public:
-    virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode,
-					 size_t numRetry)
+    virtual SharedHandle<DHTTask>
+    createPingTask(const SharedHandle<DHTNode>& remoteNode, size_t numRetry)
     {
       return new MockDHTTask(remoteNode);
     }
@@ -69,7 +71,7 @@ void BtPortMessageTest::testCreate() {
 
 void BtPortMessageTest::testToString() {
   BtPortMessage msg(1);
-  CPPUNIT_ASSERT_EQUAL(string("port port=1"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("port port=1"), msg.toString());
 }
 
 void BtPortMessageTest::testGetMessage() {
@@ -82,7 +84,7 @@ void BtPortMessageTest::testGetMessage() {
 
 void BtPortMessageTest::testDoReceivedAction()
 {
-  PeerHandle peer = new Peer("192.168.0.1", 6881);
+  SharedHandle<Peer> peer = new Peer("192.168.0.1", 6881);
   BtPortMessage msg(6881);
   MockDHTTaskQueue taskQueue;
   MockDHTTaskFactory2 taskFactory;
@@ -93,7 +95,9 @@ void BtPortMessageTest::testDoReceivedAction()
   msg.doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, taskQueue._immediateTaskQueue.size());
-  DHTNodeHandle node = SharedHandle<MockDHTTask>(taskQueue._immediateTaskQueue.front())->_remoteNode;
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), node->getIPAddress());
+  SharedHandle<DHTNode> node = SharedHandle<MockDHTTask>(taskQueue._immediateTaskQueue.front())->_remoteNode;
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), node->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort());
 }
+
+} // namespace aria2
diff --git a/test/BtPostDownloadHandlerTest.cc b/test/BtPostDownloadHandlerTest.cc
index ec469ee4..8f9e49fe 100644
--- a/test/BtPostDownloadHandlerTest.cc
+++ b/test/BtPostDownloadHandlerTest.cc
@@ -3,8 +3,11 @@
 #include "RequestGroup.h"
 #include "Option.h"
 #include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class BtPostDownloadHandlerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(BtPostDownloadHandlerTest);
@@ -28,8 +31,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtPostDownloadHandlerTest );
 void BtPostDownloadHandlerTest::testCanHandle_extension()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
   BtPostDownloadHandler handler;
@@ -43,9 +46,9 @@ void BtPostDownloadHandlerTest::testCanHandle_extension()
 void BtPostDownloadHandlerTest::testCanHandle_contentType()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test");
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test");
   dctx->setContentType("application/x-bittorrent");
-  RequestGroup rg(&op, Strings());
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
   BtPostDownloadHandler handler;
@@ -59,15 +62,17 @@ void BtPostDownloadHandlerTest::testCanHandle_contentType()
 void BtPostDownloadHandlerTest::testGetNextRequestGroups()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
   rg.initPieceStorage();
 
   BtPostDownloadHandler handler;
-  RequestGroups groups = handler.getNextRequestGroups(&rg);
+  std::deque<SharedHandle<RequestGroup> > groups = handler.getNextRequestGroups(&rg);
   CPPUNIT_ASSERT_EQUAL((size_t)1, groups.size());
-  BtContextHandle btctx = groups.front()->getDownloadContext();
+  SharedHandle<BtContext> btctx = groups.front()->getDownloadContext();
   CPPUNIT_ASSERT(!btctx.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-test"), btctx->getName());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-test"), btctx->getName());
 }
+
+} // namespace aria2
diff --git a/test/BtRegistryTest.cc b/test/BtRegistryTest.cc
index 7cabb0dc..08898517 100644
--- a/test/BtRegistryTest.cc
+++ b/test/BtRegistryTest.cc
@@ -5,9 +5,18 @@
 #include "MockPieceStorage.h"
 #include "MockBtAnnounce.h"
 #include "MockBtProgressInfoFile.h"
+#include "BtRuntime.h"
+#include "FileEntry.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtRegistryTest:public CppUnit::TestFixture {
 
@@ -48,7 +57,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtRegistryTest );
 void BtRegistryTest::testGetBtContext()
 {
   CPPUNIT_ASSERT(BtRegistry::getBtContext("test").isNull());
-  BtContextHandle btContext = new MockBtContext();
+  SharedHandle<BtContext> btContext = new MockBtContext();
   BtRegistry::registerBtContext("test", btContext);
   CPPUNIT_ASSERT_EQUAL(btContext.get(),
 		       BtRegistry::getBtContext("test").get());
@@ -57,7 +66,7 @@ void BtRegistryTest::testGetBtContext()
 void BtRegistryTest::testGetPeerStorage() {
   CPPUNIT_ASSERT(!BtRegistry::getPeerStorage("test").get());
 
-  PeerStorageHandle peerStorage(new MockPeerStorage());
+  SharedHandle<PeerStorage> peerStorage(new MockPeerStorage());
 
   BtRegistry::registerPeerStorage("test", peerStorage);
   CPPUNIT_ASSERT_EQUAL(peerStorage.get(),
@@ -67,7 +76,7 @@ void BtRegistryTest::testGetPeerStorage() {
 void BtRegistryTest::testGetPieceStorage() {
   CPPUNIT_ASSERT(!BtRegistry::getPieceStorage("test").get());
 
-  PieceStorageHandle pieceStorage(new MockPieceStorage());
+  SharedHandle<PieceStorage> pieceStorage(new MockPieceStorage());
 
   BtRegistry::registerPieceStorage("test", pieceStorage);
   CPPUNIT_ASSERT_EQUAL(pieceStorage.get(),
@@ -77,7 +86,7 @@ void BtRegistryTest::testGetPieceStorage() {
 void BtRegistryTest::testGetBtRuntime() {
   CPPUNIT_ASSERT(!BtRegistry::getBtRuntime("test").get());
 
-  BtRuntimeHandle runtime;
+  SharedHandle<BtRuntime> runtime;
 
   BtRegistry::registerBtRuntime("test", runtime);
   CPPUNIT_ASSERT_EQUAL(runtime.get(),
@@ -87,7 +96,7 @@ void BtRegistryTest::testGetBtRuntime() {
 void BtRegistryTest::testGetBtAnnounce() {
   CPPUNIT_ASSERT(!BtRegistry::getBtAnnounce("test").get());
   
-  BtAnnounceHandle btAnnounce(new MockBtAnnounce());
+  SharedHandle<BtAnnounce> btAnnounce(new MockBtAnnounce());
 
   BtRegistry::registerBtAnnounce("test", btAnnounce);
   CPPUNIT_ASSERT_EQUAL(btAnnounce.get(),
@@ -97,7 +106,7 @@ void BtRegistryTest::testGetBtAnnounce() {
 void BtRegistryTest::testGetBtProgressInfoFile() {
   CPPUNIT_ASSERT(!BtRegistry::getBtProgressInfoFile("test").get());
 
-  BtProgressInfoFileHandle btProgressInfoFile(new MockBtProgressInfoFile());
+  SharedHandle<BtProgressInfoFile> btProgressInfoFile(new MockBtProgressInfoFile());
 
   BtRegistry::registerBtProgressInfoFile("test", btProgressInfoFile);
   CPPUNIT_ASSERT_EQUAL(btProgressInfoFile.get(),
@@ -115,3 +124,5 @@ void BtRegistryTest::testGetPeerObjectCluster() {
 
   CPPUNIT_ASSERT(!BtRegistry::getPeerObjectCluster("test").get());
 }
+
+} // namespace aria2
diff --git a/test/BtRejectMessageTest.cc b/test/BtRejectMessageTest.cc
index 73bfb163..2119acf2 100644
--- a/test/BtRejectMessageTest.cc
+++ b/test/BtRejectMessageTest.cc
@@ -1,11 +1,20 @@
 #include "BtRejectMessage.h"
 #include "PeerMessageUtil.h"
 #include "Peer.h"
+#include "FileEntry.h"
+#include "BtRegistry.h"
+#include "PeerObject.h"
+#include "BtMessageFactory.h"
+#include "BtRequestFactory.h"
+#include "BtMessageReceiver.h"
+#include "ExtensionMessageFactory.h"
+#include "PeerConnection.h"
 #include "MockBtMessageDispatcher.h"
 #include "MockBtContext.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtRejectMessageTest:public CppUnit::TestFixture {
 
@@ -58,9 +67,9 @@ public:
 
   typedef SharedHandle<MockBtMessageDispatcher2> MockBtMessageDispatcher2Handle;
 
-  PeerHandle peer;
-  MockBtMessageDispatcher2Handle dispatcher;
-  BtRejectMessageHandle msg;
+  SharedHandle<Peer> peer;
+  SharedHandle<MockBtMessageDispatcher2> dispatcher;
+  SharedHandle<BtRejectMessage> msg;
 
   BtRejectMessageTest():peer(0), dispatcher(0), msg(0) {}
 
@@ -68,7 +77,7 @@ public:
     BtRegistry::unregisterAll();
     peer = new Peer("host", 6969);
 
-    MockBtContextHandle btContext = new MockBtContext();
+    SharedHandle<MockBtContext> btContext = new MockBtContext();
     btContext->setInfoHash((const unsigned char*)"12345678901234567890");
     BtRegistry::registerPeerObjectCluster(btContext->getInfoHashAsString(),
 					  new PeerObjectCluster());
@@ -96,7 +105,7 @@ void BtRejectMessageTest::testCreate() {
   PeerMessageUtil::setIntParam(&msg[5], 12345);
   PeerMessageUtil::setIntParam(&msg[9], 256);
   PeerMessageUtil::setIntParam(&msg[13], 1024);
-  BtRejectMessageHandle pm = BtRejectMessage::create(&msg[4], 13);
+  SharedHandle<BtRejectMessage> pm = BtRejectMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((int8_t)16, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)256, pm->getBegin());
@@ -171,6 +180,8 @@ void BtRejectMessageTest::testDoReceivedActionFastExtensionDisabled() {
 }
 
 void BtRejectMessageTest::testToString() {
-  CPPUNIT_ASSERT_EQUAL(string("reject index=1, begin=16, length=32"),
+  CPPUNIT_ASSERT_EQUAL(std::string("reject index=1, begin=16, length=32"),
 		       msg->toString());
 }
+
+} // namespace aria2
diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc
index d8ec67e2..33bc3f10 100644
--- a/test/BtRequestMessageTest.cc
+++ b/test/BtRequestMessageTest.cc
@@ -7,9 +7,18 @@
 #include "MockBtMessageDispatcher.h"
 #include "DefaultBtContext.h"
 #include "BtAbortOutstandingRequestEvent.h"
+#include "Peer.h"
+#include "BtRegistry.h"
+#include "PeerObject.h"
+#include "BtMessageReceiver.h"
+#include "BtRequestFactory.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+#include "FileEntry.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtRequestMessageTest:public CppUnit::TestFixture {
 
@@ -52,48 +61,48 @@ public:
 
   class MockBtMessage2 : public MockBtMessage {
   public:
-    string type;
+    std::string type;
     int32_t index;
     int32_t begin;
     int32_t length;
   public:
-    MockBtMessage2(string type, int32_t index, int32_t begin, int32_t length):type(type), index(index), begin(begin), length(length) {}
+    MockBtMessage2(std::string type, int32_t index, int32_t begin, int32_t length):type(type), index(index), begin(begin), length(length) {}
   };
 
   typedef SharedHandle<MockBtMessage2> MockBtMessage2Handle;
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual BtMessageHandle
+    virtual SharedHandle<BtMessage>
     createPieceMessage(int32_t index, int32_t begin, int32_t length) {
-      MockBtMessage2Handle btMsg = new MockBtMessage2("piece", index, begin, length);
+      SharedHandle<MockBtMessage2> btMsg = new MockBtMessage2("piece", index, begin, length);
       return btMsg;
     }
 
-    virtual BtMessageHandle
+    virtual SharedHandle<BtMessage>
     createRejectMessage(int32_t index, int32_t begin, int32_t length) {
-      MockBtMessage2Handle btMsg = new MockBtMessage2("reject", index, begin, length);
+      SharedHandle<MockBtMessage2> btMsg = new MockBtMessage2("reject", index, begin, length);
       return btMsg;
     }
   };
 
   typedef SharedHandle<MockBtMessageFactory2> MockBtMessageFactory2Handle;
 
-  PeerHandle peer;
-  MockBtMessageDispatcherHandle dispatcher;
-  BtRequestMessageHandle msg;
+  SharedHandle<Peer> peer;
+  SharedHandle<MockBtMessageDispatcher> dispatcher;
+  SharedHandle<BtRequestMessage> msg;
 
   BtRequestMessageTest():peer(0), dispatcher(0), msg(0) {}
 
   void setUp() {
     BtRegistry::unregisterAll();
 
-    MockBtContextHandle btContext = new MockBtContext();
+    SharedHandle<MockBtContext> btContext = new MockBtContext();
     btContext->setInfoHash((const unsigned char*)"12345678901234567890");
     btContext->setPieceLength(16*1024);
     btContext->setTotalLength(256*1024);
 
-    MockPieceStorageHandle pieceStorage = new MockPieceStorage2();
+    SharedHandle<MockPieceStorage> pieceStorage = new MockPieceStorage2();
 
     BtRegistry::registerPieceStorage(btContext->getInfoHashAsString(),
 				     pieceStorage);
@@ -130,7 +139,7 @@ void BtRequestMessageTest::testCreate() {
   PeerMessageUtil::setIntParam(&msg[5], 12345);
   PeerMessageUtil::setIntParam(&msg[9], 256);
   PeerMessageUtil::setIntParam(&msg[13], 1024);
-  BtRequestMessageHandle pm = BtRequestMessage::create(&msg[4], 13);
+  SharedHandle<BtRequestMessage> pm = BtRequestMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((int8_t)6, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)256, pm->getBegin());
@@ -173,7 +182,7 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() {
   
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher->messageQueue.size());
   MockBtMessage2* pieceMsg = (MockBtMessage2*)dispatcher->messageQueue.front().get();
-  CPPUNIT_ASSERT_EQUAL(string("piece"), pieceMsg->type);
+  CPPUNIT_ASSERT_EQUAL(std::string("piece"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((int32_t)16, pieceMsg->begin);
   CPPUNIT_ASSERT_EQUAL((int32_t)32, pieceMsg->length);
@@ -186,7 +195,7 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExten
   
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher->messageQueue.size());
   MockBtMessage2* pieceMsg = (MockBtMessage2*)dispatcher->messageQueue.front().get();
-  CPPUNIT_ASSERT_EQUAL(string("reject"), pieceMsg->type);
+  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((int32_t)16, pieceMsg->begin);
   CPPUNIT_ASSERT_EQUAL((int32_t)32, pieceMsg->length);
@@ -207,7 +216,7 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionE
   
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher->messageQueue.size());
   MockBtMessage2* pieceMsg = (MockBtMessage2*)dispatcher->messageQueue.front().get();
-  CPPUNIT_ASSERT_EQUAL(string("reject"), pieceMsg->type);
+  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
   CPPUNIT_ASSERT_EQUAL((int32_t)2, pieceMsg->index);
   CPPUNIT_ASSERT_EQUAL((int32_t)16, pieceMsg->begin);
   CPPUNIT_ASSERT_EQUAL((int32_t)32, pieceMsg->length);
@@ -222,8 +231,8 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionD
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent() {
-  PieceHandle piece = new Piece(1, 16*1024);
-  BtAbortOutstandingRequestEventHandle event =
+  SharedHandle<Piece> piece = new Piece(1, 16*1024);
+  SharedHandle<BtAbortOutstandingRequestEvent> event =
     new BtAbortOutstandingRequestEvent(piece);
 
   CPPUNIT_ASSERT(!msg->isInvalidate());
@@ -233,8 +242,8 @@ void BtRequestMessageTest::testHandleAbortRequestEvent() {
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() {
-  PieceHandle piece = new Piece(2, 16*1024);
-  BtAbortOutstandingRequestEventHandle event =
+  SharedHandle<Piece> piece = new Piece(2, 16*1024);
+  SharedHandle<BtAbortOutstandingRequestEvent> event =
     new BtAbortOutstandingRequestEvent(piece);
 
   CPPUNIT_ASSERT(!msg->isInvalidate());
@@ -244,8 +253,8 @@ void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() {
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() {
-  PieceHandle piece = new Piece(1, 16*1024);
-  BtAbortOutstandingRequestEventHandle event =
+  SharedHandle<Piece> piece = new Piece(1, 16*1024);
+  SharedHandle<BtAbortOutstandingRequestEvent> event =
     new BtAbortOutstandingRequestEvent(piece);
   msg->setInvalidate(true);
 
@@ -256,8 +265,8 @@ void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() {
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_sendingInProgress() {
-  PieceHandle piece = new Piece(1, 16*1024);
-  BtAbortOutstandingRequestEventHandle event =
+  SharedHandle<Piece> piece = new Piece(1, 16*1024);
+  SharedHandle<BtAbortOutstandingRequestEvent> event =
     new BtAbortOutstandingRequestEvent(piece);
   msg->setSendingInProgress(true);
 
@@ -268,6 +277,8 @@ void BtRequestMessageTest::testHandleAbortRequestEvent_sendingInProgress() {
 }
 
 void BtRequestMessageTest::testToString() {
-  CPPUNIT_ASSERT_EQUAL(string("request index=1, begin=16, length=32"),
+  CPPUNIT_ASSERT_EQUAL(std::string("request index=1, begin=16, length=32"),
 		       msg->toString());
 }
+
+} // namespace aria2
diff --git a/test/BtSuggestPieceMessageTest.cc b/test/BtSuggestPieceMessageTest.cc
index 68e3ecba..b40c576f 100644
--- a/test/BtSuggestPieceMessageTest.cc
+++ b/test/BtSuggestPieceMessageTest.cc
@@ -1,8 +1,9 @@
 #include "BtSuggestPieceMessage.h"
 #include "PeerMessageUtil.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtSuggestPieceMessageTest:public CppUnit::TestFixture {
 
@@ -29,7 +30,7 @@ void BtSuggestPieceMessageTest::testCreate() {
   unsigned char msg[9];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 5, 13);
   PeerMessageUtil::setIntParam(&msg[5], 12345);
-  BtSuggestPieceMessageHandle pm = BtSuggestPieceMessage::create(&msg[4], 5);
+  SharedHandle<BtSuggestPieceMessage> pm = BtSuggestPieceMessage::create(&msg[4], 5);
   CPPUNIT_ASSERT_EQUAL((int8_t)13, pm->getId());
   CPPUNIT_ASSERT_EQUAL((int32_t)12345, pm->getIndex());
 
@@ -64,6 +65,8 @@ void BtSuggestPieceMessageTest::testToString() {
   BtSuggestPieceMessage msg;
   msg.setIndex(12345);
 
-  CPPUNIT_ASSERT_EQUAL(string("suggest piece index=12345"),
+  CPPUNIT_ASSERT_EQUAL(std::string("suggest piece index=12345"),
 		       msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/BtUnchokeMessageTest.cc b/test/BtUnchokeMessageTest.cc
index 281e67f8..29cac162 100644
--- a/test/BtUnchokeMessageTest.cc
+++ b/test/BtUnchokeMessageTest.cc
@@ -1,8 +1,10 @@
 #include "BtUnchokeMessage.h"
 #include "PeerMessageUtil.h"
+#include "Peer.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class BtUnchokeMessageTest:public CppUnit::TestFixture {
 
@@ -31,7 +33,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtUnchokeMessageTest);
 void BtUnchokeMessageTest::testCreate() {
   unsigned char msg[5];
   PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 1, 1);
-  BtUnchokeMessageHandle pm = BtUnchokeMessage::create(&msg[4], 1);
+  SharedHandle<BtUnchokeMessage> pm = BtUnchokeMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((int8_t)1, pm->getId());
 
   // case: payload size is wrong
@@ -60,7 +62,7 @@ void BtUnchokeMessageTest::testGetMessage() {
 }
 
 void BtUnchokeMessageTest::testDoReceivedAction() {
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->peerChoking = true;
   BtUnchokeMessage msg;
   msg.setPeer(peer);
@@ -71,7 +73,7 @@ void BtUnchokeMessageTest::testDoReceivedAction() {
 }
 
 void BtUnchokeMessageTest::testOnSendComplete() {
-  PeerHandle peer = new Peer("host", 6969);
+  SharedHandle<Peer> peer = new Peer("host", 6969);
   peer->amChoking = true;
   BtUnchokeMessage msg;
   msg.setPeer(peer);
@@ -83,5 +85,7 @@ void BtUnchokeMessageTest::testOnSendComplete() {
 
 void BtUnchokeMessageTest::testToString() {
   BtUnchokeMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("unchoke"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("unchoke"), msg.toString());
 }
+
+} // namespace aria2
diff --git a/test/ByteArrayDiskWriterTest.cc b/test/ByteArrayDiskWriterTest.cc
index 6e12417e..2e6c52bd 100644
--- a/test/ByteArrayDiskWriterTest.cc
+++ b/test/ByteArrayDiskWriterTest.cc
@@ -2,7 +2,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class ByteArrayDiskWriterTest:public CppUnit::TestFixture {
 
@@ -26,36 +26,38 @@ CPPUNIT_TEST_SUITE_REGISTRATION( ByteArrayDiskWriterTest );
 void ByteArrayDiskWriterTest::testWriteAndRead() {
   ByteArrayDiskWriter bw;
 
-  string msg1 = "Hello";
+  std::string msg1 = "Hello";
   bw.writeData((const unsigned char*)msg1.c_str(), msg1.size(), 0);
   // write at the end of stream
-  string msg2 = " World";
+  std::string msg2 = " World";
   bw.writeData((const unsigned char*)msg2.c_str(), msg2.size(), 5);
   // write at the end of stream +1
-  string msg3 = "!!";
+  std::string msg3 = "!!";
   bw.writeData((const unsigned char*)msg3.c_str(), msg3.size(), 12);
   // write space at the 'hole'
-  string msg4 = " ";
+  std::string msg4 = " ";
   bw.writeData((const unsigned char*)msg4.c_str(), msg4.size(), 11);
 
   char buf[100];
   int32_t c = bw.readData((unsigned char*)buf, sizeof(buf), 1);
   buf[c] = '\0';
 
-  CPPUNIT_ASSERT_EQUAL(string("ello World !!"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("ello World !!"), std::string(buf));
 }
 
 void ByteArrayDiskWriterTest::testWriteAndRead2() {
   ByteArrayDiskWriter bw;
 
-  string msg1 = "Hello World";
+  std::string msg1 = "Hello World";
   bw.writeData((const unsigned char*)msg1.c_str(), msg1.size(), 0);
-  string msg2 = "From Mars";
+  std::string msg2 = "From Mars";
   bw.writeData((const unsigned char*)msg2.c_str(), msg2.size(), 6);
 
   char buf[100];
   int32_t c = bw.readData((unsigned char*)buf, sizeof(buf), 0);
   buf[c] = '\0';
 
-  CPPUNIT_ASSERT_EQUAL(string("Hello From Mars"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("Hello From Mars"), std::string(buf));
 }
+
+} // namespace aria2
diff --git a/test/ChunkedEncodingTest.cc b/test/ChunkedEncodingTest.cc
index 648383cb..1f5a4c7f 100644
--- a/test/ChunkedEncodingTest.cc
+++ b/test/ChunkedEncodingTest.cc
@@ -4,7 +4,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class ChunkedEncodingTest:public CppUnit::TestFixture {
 
@@ -29,41 +29,42 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( ChunkedEncodingTest );
 
 void ChunkedEncodingTest::testInflate1() {
-  string msg = "a\r\n1234567890\r\n";
+  std::string msg = "a\r\n1234567890\r\n";
   char buf[100];
   int32_t len = sizeof(buf);
   enc->inflate(buf, len, msg.c_str(), msg.size());
   buf[len] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890"), std::string(buf));
   // second pass
   len = sizeof(buf);
   msg = "3;extensionIgnored\r\n123\r\n0\r\n";
   enc->inflate(buf, len, msg.c_str(), msg.size());
   buf[len] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("123"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("123"), std::string(buf));
   // input is over
   CPPUNIT_ASSERT(enc->finished());
 }
 
 void ChunkedEncodingTest::testInflateLargeChunk() {
   // give over 4096 character chunk
-  fstream is("4096chunk.txt", ios::in);
+  std::fstream is("4096chunk.txt", std::ios::in);
   if(is.fail()) {
     CPPUNIT_FAIL("cannot open file 4096chunk.txt");
   }
-  string body;
+  std::string body;
   is >> body;
   char buf[4097];
   int32_t len = sizeof(buf);
   for(int i = 0; i < 2; i++) {
-    string msg = "1000\r\n"+body+"\r\n";
+    std::string msg = "1000\r\n"+body+"\r\n";
     len = sizeof(buf);
     enc->inflate(buf, len, msg.c_str(), msg.size());
     buf[len] = '\0';
-    CPPUNIT_ASSERT_EQUAL(body, string(buf));
+    CPPUNIT_ASSERT_EQUAL(body, std::string(buf));
   }
   enc->inflate(buf, len, "0\r\n", 3);
   CPPUNIT_ASSERT_EQUAL((int32_t)0, len);
   CPPUNIT_ASSERT(enc->finished());
 }
 
+} // namespace aria2
diff --git a/test/CookieBoxFactoryTest.cc b/test/CookieBoxFactoryTest.cc
index 5c5a6da6..9390bc9e 100644
--- a/test/CookieBoxFactoryTest.cc
+++ b/test/CookieBoxFactoryTest.cc
@@ -1,8 +1,9 @@
 #include "CookieBoxFactory.h"
+#include "CookieBox.h"
 #include <fstream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class CookieBoxFactoryTest:public CppUnit::TestFixture {
 
@@ -25,7 +26,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( CookieBoxFactoryTest );
 
 void CookieBoxFactoryTest::testLoadDefaultCookie()
 {
-  ifstream f("nscookietest.txt");
+  std::ifstream f("nscookietest.txt");
 
   CookieBoxFactory factory;
 
@@ -36,41 +37,43 @@ void CookieBoxFactoryTest::testLoadDefaultCookie()
   CPPUNIT_ASSERT_EQUAL((int32_t)4, (int32_t)cookies.size());
 
   Cookie c = cookies[0];
-  CPPUNIT_ASSERT_EQUAL(string("JSESSIONID"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("123456789"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("JSESSIONID"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789"), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)1181473200, c.expires);
-  CPPUNIT_ASSERT_EQUAL(string("/"), c.path);
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), c.domain);
 
   c = cookies[1];
-  CPPUNIT_ASSERT_EQUAL(string("user"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("me"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("user"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("me"), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)1181473200, c.expires);
-  CPPUNIT_ASSERT_EQUAL(string("/"), c.path);
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), c.domain);
 
   c = cookies[2];
-  CPPUNIT_ASSERT_EQUAL(string("passwd"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("secret"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("passwd"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("secret"), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)2147483647, c.expires);
-  CPPUNIT_ASSERT_EQUAL(string("/cgi-bin"), c.path);
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/cgi-bin"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), c.domain);
 
   c = cookies[3];
-  CPPUNIT_ASSERT_EQUAL(string("novalue"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string(""), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("novalue"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string(""), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)2147483647, c.expires);
-  CPPUNIT_ASSERT_EQUAL(string("/"), c.path);
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), c.domain);
 }
 
 void CookieBoxFactoryTest::testCreateNewInstance()
 {
-  ifstream f("nscookietest.txt");
+  std::ifstream f("nscookietest.txt");
   CookieBoxFactory factory;
   factory.loadDefaultCookie(f);
-  CookieBoxHandle box = factory.createNewInstance();
-  Cookies cookies = box->criteriaFind("localhost", "/", 0, true);
+  SharedHandle<CookieBox> box = factory.createNewInstance();
+  std::deque<Cookie> cookies = box->criteriaFind("localhost", "/", 0, true);
 
   CPPUNIT_ASSERT_EQUAL((int32_t)3, (int32_t)cookies.size());
 }
+
+} // namespace aria2
diff --git a/test/CookieBoxTest.cc b/test/CookieBoxTest.cc
index 16604e77..6543bb2e 100644
--- a/test/CookieBoxTest.cc
+++ b/test/CookieBoxTest.cc
@@ -2,7 +2,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class CookieBoxTest:public CppUnit::TestFixture {
 
@@ -37,18 +37,18 @@ void CookieBoxTest::testCriteriaFind() {
   Cookies result1 = box.criteriaFind("rednoah.com", "/downloads", 1181473100, false);
   CPPUNIT_ASSERT_EQUAL(2, (int)result1.size());
   Cookies::iterator itr = result1.begin();
-  CPPUNIT_ASSERT_EQUAL(string("SESSIONID1=1"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("SESSIONID1=1"), (*itr).toString());
   itr++;
-  CPPUNIT_ASSERT_EQUAL(string("SESSIONID2=2"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("SESSIONID2=2"), (*itr).toString());
 
   result1 = box.criteriaFind("rednoah.com", "/downloads", 1181473100, true);
   CPPUNIT_ASSERT_EQUAL(3, (int)result1.size());
   itr = result1.begin();
-  CPPUNIT_ASSERT_EQUAL(string("SESSIONID1=1"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("SESSIONID1=1"), (*itr).toString());
   itr++;
-  CPPUNIT_ASSERT_EQUAL(string("SESSIONID2=2"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("SESSIONID2=2"), (*itr).toString());
   itr++;
-  CPPUNIT_ASSERT_EQUAL(string("PASS=pass"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("PASS=pass"), (*itr).toString());
 
   result1 = box.criteriaFind("aria.rednoah.com", "/", 1181473100, false);
   CPPUNIT_ASSERT_EQUAL(0, (int)result1.size());
@@ -56,9 +56,10 @@ void CookieBoxTest::testCriteriaFind() {
   result1 = box.criteriaFind("aria.rednoah.com", "/home", 1181473100, false);
   CPPUNIT_ASSERT_EQUAL(1, (int)result1.size());
   itr = result1.begin();
-  CPPUNIT_ASSERT_EQUAL(string("USER=user"), (*itr).toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("USER=user"), (*itr).toString());
   
   result1 = box.criteriaFind("rednoah.com", "/downloads", 1181473200, false);
   CPPUNIT_ASSERT_EQUAL(0, (int)result1.size());
 }
 
+} // namespace aria2
diff --git a/test/CookieParserTest.cc b/test/CookieParserTest.cc
index cff6d7df..6a91ee99 100644
--- a/test/CookieParserTest.cc
+++ b/test/CookieParserTest.cc
@@ -2,7 +2,7 @@
 #include <fstream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class CookieParserTest:public CppUnit::TestFixture {
 
@@ -26,50 +26,52 @@ CPPUNIT_TEST_SUITE_REGISTRATION( CookieParserTest );
 
 void CookieParserTest::testParse()
 {
-  string str = "JSESSIONID=123456789; expires=Sun, 2007-06-10 11:00:00 GMT; path=/; domain=localhost; secure";
+  std::string str = "JSESSIONID=123456789; expires=Sun, 2007-06-10 11:00:00 GMT; path=/; domain=localhost; secure";
   Cookie c = CookieParser().parse(str);
   CPPUNIT_ASSERT(c.good());
-  CPPUNIT_ASSERT_EQUAL(string("JSESSIONID"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("123456789"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("JSESSIONID"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789"), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)1181473200, c.expires);  
-  CPPUNIT_ASSERT_EQUAL(string("/"), c.path);
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), c.domain);
   CPPUNIT_ASSERT_EQUAL(true, c.secure);
   CPPUNIT_ASSERT_EQUAL(false, c.onetime);
 
-  string str2 = "JSESSIONID=123456789";
+  std::string str2 = "JSESSIONID=123456789";
   c = CookieParser().parse(str2, "default.domain", "/default/path");
   CPPUNIT_ASSERT(c.good());
-  CPPUNIT_ASSERT_EQUAL(string("JSESSIONID"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("123456789"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("JSESSIONID"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789"), c.value);
   CPPUNIT_ASSERT_EQUAL((time_t)0, c.expires);
-  CPPUNIT_ASSERT_EQUAL(string("default.domain"), c.domain);
-  CPPUNIT_ASSERT_EQUAL(string("/default/path"), c.path);
+  CPPUNIT_ASSERT_EQUAL(std::string("default.domain"), c.domain);
+  CPPUNIT_ASSERT_EQUAL(std::string("/default/path"), c.path);
   CPPUNIT_ASSERT_EQUAL(false, c.secure);
   CPPUNIT_ASSERT_EQUAL(true, c.onetime);
 
-  string str3 = "";
+  std::string str3 = "";
   c = CookieParser().parse(str3);
   CPPUNIT_ASSERT(!c.good());
 }
 
 void CookieParserTest::testParse_file()
 {
-  ifstream f("cookietest.txt");
+  std::ifstream f("cookietest.txt");
 
   Cookies cookies = CookieParser().parse(f);
 
   CPPUNIT_ASSERT_EQUAL((int32_t)3, (int32_t)cookies.size());
 
   Cookie c = cookies[0];
-  CPPUNIT_ASSERT_EQUAL(string("JSESSIONID"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("123456789"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("JSESSIONID"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789"), c.value);
 
   c = cookies[1];
-  CPPUNIT_ASSERT_EQUAL(string("user"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("me"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("user"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("me"), c.value);
 
   c = cookies[2];
-  CPPUNIT_ASSERT_EQUAL(string("passwd"), c.name);
-  CPPUNIT_ASSERT_EQUAL(string("secret"), c.value);
+  CPPUNIT_ASSERT_EQUAL(std::string("passwd"), c.name);
+  CPPUNIT_ASSERT_EQUAL(std::string("secret"), c.value);
 }
+
+} // namespace aria2
diff --git a/test/DHTAnnouncePeerMessageTest.cc b/test/DHTAnnouncePeerMessageTest.cc
index a614b2d2..7a53624b 100644
--- a/test/DHTAnnouncePeerMessageTest.cc
+++ b/test/DHTAnnouncePeerMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTAnnouncePeerMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTAnnouncePeerMessageTest);
@@ -26,22 +28,22 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerMessageTest);
 
 void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   unsigned char infoHash[DHT_ID_LENGTH];
   DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH);
 
-  string token = "token";
+  std::string token = "token";
   uint16_t port = 6881;
 
   DHTAnnouncePeerMessage msg(localNode, remoteNode, infoHash, port, token, transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -60,3 +62,5 @@ void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
   CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 		       Util::urlencode(msgbody));
 }
+
+} // namespace aria2
diff --git a/test/DHTAnnouncePeerReplyMessageTest.cc b/test/DHTAnnouncePeerReplyMessageTest.cc
index 6cf6f6e1..0534a31f 100644
--- a/test/DHTAnnouncePeerReplyMessageTest.cc
+++ b/test/DHTAnnouncePeerReplyMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTAnnouncePeerReplyMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTAnnouncePeerReplyMessageTest);
@@ -26,16 +28,16 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerReplyMessageTest);
 
 void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   DHTAnnouncePeerReplyMessage msg(localNode, remoteNode, transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -49,3 +51,5 @@ void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage()
 
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
+
+} // namespace aria2
diff --git a/test/DHTBucketTest.cc b/test/DHTBucketTest.cc
index f79721e4..c6c3b8f8 100644
--- a/test/DHTBucketTest.cc
+++ b/test/DHTBucketTest.cc
@@ -4,6 +4,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTBucketTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTBucketTest);
@@ -40,7 +42,7 @@ void DHTBucketTest::testGetRandomNodeID()
 				  0x00, 0x00, 0x00, 0x00, 0x00,
 				  0x00, 0x00, 0x00, 0x00, 0x00,
 				  0x00, 0x00, 0x00, 0x00, 0x00 };
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   {
     DHTBucket bucket(localNode);
     unsigned char nodeID[DHT_ID_LENGTH];
@@ -58,7 +60,7 @@ void DHTBucketTest::testGetRandomNodeID()
     DHTBucket bucket(16, max, min, localNode);
     unsigned char nodeID[DHT_ID_LENGTH];
     bucket.getRandomNodeID(nodeID);
-    CPPUNIT_ASSERT_EQUAL(string("0101"),
+    CPPUNIT_ASSERT_EQUAL(std::string("0101"),
 			 Util::toHex(nodeID, sizeof(nodeID)).substr(0, 4));
   }
 }
@@ -69,13 +71,13 @@ void DHTBucketTest::testIsInRange()
 				  0x00, 0x00, 0x00, 0x00, 0x00,
 				  0x00, 0x00, 0x00, 0x00, 0x00,
 				  0x00, 0x00, 0x00, 0x00, 0x00 };
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   {
     unsigned char nodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00,
 			       0x00, 0x00, 0x00, 0x00, 0x00,
 			       0x00, 0x00, 0x00, 0x00, 0x00,
 			       0x00, 0x00, 0x00, 0x00, 0x00 };
-    DHTNodeHandle node = new DHTNode(nodeID);
+    SharedHandle<DHTNode> node = new DHTNode(nodeID);
     DHTBucket bucket(localNode);
     CPPUNIT_ASSERT(bucket.isInRange(node));
     memset(nodeID, 0xff, sizeof(nodeID));
@@ -96,7 +98,7 @@ void DHTBucketTest::testIsInRange()
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00 };
-      DHTNodeHandle node = new DHTNode(nodeID);
+      SharedHandle<DHTNode> node = new DHTNode(nodeID);
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -106,7 +108,7 @@ void DHTBucketTest::testIsInRange()
 				 0xff, 0xff, 0xff, 0xff, 0xff,
 				 0xff, 0xff, 0xff, 0xff, 0xff,
 				 0xff, 0xff, 0xff, 0xff, 0xff };
-      DHTNodeHandle node = new DHTNode(nodeID);
+      SharedHandle<DHTNode> node = new DHTNode(nodeID);
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -115,7 +117,7 @@ void DHTBucketTest::testIsInRange()
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0xff, 0xff, 0xff, 0xff, 0xff,
 				 0xff, 0xff, 0xff, 0xff, 0xff };
-      DHTNodeHandle node = new DHTNode(nodeID);
+      SharedHandle<DHTNode> node = new DHTNode(nodeID);
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(bucket.isInRange(node));
     }
@@ -125,7 +127,7 @@ void DHTBucketTest::testIsInRange()
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00 };
-      DHTNodeHandle node = new DHTNode(nodeID);
+      SharedHandle<DHTNode> node = new DHTNode(nodeID);
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.isInRange(node));
     }
@@ -135,7 +137,7 @@ void DHTBucketTest::testIsInRange()
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00,
 				 0x00, 0x00, 0x00, 0x00, 0x00 };
-      DHTNodeHandle node = new DHTNode(nodeID);
+      SharedHandle<DHTNode> node = new DHTNode(nodeID);
       DHTBucket bucket(16, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.isInRange(node));
     }
@@ -149,7 +151,7 @@ void DHTBucketTest::testSplitAllowed()
 				    0x00, 0x00, 0x00, 0x00, 0x00,
 				    0x00, 0x00, 0x00, 0x00, 0x00,
 				    0x00, 0x00, 0x00, 0x00, 0x00 };
-    DHTNodeHandle localNode = new DHTNode(localNodeID);
+    SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
     DHTBucket bucket(localNode);
     CPPUNIT_ASSERT(bucket.splitAllowed());
   }
@@ -167,7 +169,7 @@ void DHTBucketTest::testSplitAllowed()
 				      0x00, 0x00, 0x00, 0x00, 0x00,
 				      0x00, 0x00, 0x00, 0x00, 0x00,
 				      0x00, 0x00, 0x00, 0x00, 0x00 };
-      DHTNodeHandle localNode = new DHTNode(localNodeID);
+      SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
       DHTBucket bucket(3, max, min, localNode);
       CPPUNIT_ASSERT(!bucket.splitAllowed());
     }
@@ -176,7 +178,7 @@ void DHTBucketTest::testSplitAllowed()
 				      0x00, 0x00, 0x00, 0x00, 0x00,
 				      0x00, 0x00, 0x00, 0x00, 0x00,
 				      0x00, 0x00, 0x00, 0x00, 0x01 };
-      DHTNodeHandle localNode = new DHTNode(localNodeID);
+      SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
       DHTBucket bucket(3, max, min, localNode);
       CPPUNIT_ASSERT(bucket.splitAllowed());
     }
@@ -187,10 +189,10 @@ void DHTBucketTest::testSplit()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   {
     DHTBucket bucket(localNode);
-    DHTBucketHandle r = bucket.split();
+    SharedHandle<DHTBucket> r = bucket.split();
     {
       unsigned char expectedRMax[] = { 0x7f, 0xff, 0xff, 0xff, 0xff,
 				       0xff, 0xff, 0xff, 0xff, 0xff,
@@ -219,10 +221,10 @@ void DHTBucketTest::testSplit()
     }
   }
   {
-    DHTBucketHandle bucket = new DHTBucket(localNode);
+    SharedHandle<DHTBucket> bucket = new DHTBucket(localNode);
     for(int i = 0; i < 159; ++i) {
       CPPUNIT_ASSERT(bucket->splitAllowed());
-      DHTBucketHandle t = bucket;
+      SharedHandle<DHTBucket> t = bucket;
       bucket = bucket->split();
       CPPUNIT_ASSERT(!t->splitAllowed());
     }
@@ -252,18 +254,18 @@ void DHTBucketTest::testAddNode()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i] = new DHTNode(id);
     CPPUNIT_ASSERT(bucket.addNode(nodes[i]));
   }
   createID(id, 0xf0, 0xff);
-  DHTNodeHandle newNode = new DHTNode(id);
+  SharedHandle<DHTNode> newNode = new DHTNode(id);
   CPPUNIT_ASSERT(!bucket.addNode(newNode));
 
   // nodes[0] is located at the tail of the bucket(least recent seen)
@@ -276,11 +278,11 @@ void DHTBucketTest::testMoveToHead()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i] = new DHTNode(id);
@@ -294,11 +296,11 @@ void DHTBucketTest::testMoveToTail()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i] = new DHTNode(id);
@@ -312,11 +314,11 @@ void DHTBucketTest::testGetGoodNodes()
 {
   unsigned char localNodeID[DHT_ID_LENGTH];
   memset(localNodeID, 0, DHT_ID_LENGTH);
-  DHTNodeHandle localNode = new DHTNode(localNodeID);
+  SharedHandle<DHTNode> localNode = new DHTNode(localNodeID);
   DHTBucket bucket(localNode);
 
   unsigned char id[DHT_ID_LENGTH];
-  DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes[i] = new DHTNode(id);
@@ -325,7 +327,7 @@ void DHTBucketTest::testGetGoodNodes()
   }
   nodes[3]->markBad();
   nodes[5]->markBad();
-  DHTNodes goodNodes = bucket.getGoodNodes();
+  std::deque<SharedHandle<DHTNode> > goodNodes = bucket.getGoodNodes();
   CPPUNIT_ASSERT_EQUAL((size_t)6, goodNodes.size());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, goodNodes[0]->getPort());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6882, goodNodes[1]->getPort());
@@ -334,3 +336,5 @@ void DHTBucketTest::testGetGoodNodes()
   CPPUNIT_ASSERT_EQUAL((uint16_t)6887, goodNodes[4]->getPort());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6888, goodNodes[5]->getPort());
 }
+
+} // namespace aria2
diff --git a/test/DHTConnectionImplTest.cc b/test/DHTConnectionImplTest.cc
index 74c975af..a6c8544d 100644
--- a/test/DHTConnectionImplTest.cc
+++ b/test/DHTConnectionImplTest.cc
@@ -2,6 +2,8 @@
 #include "Exception.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTConnectionImplTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTConnectionImplTest);
@@ -26,22 +28,24 @@ void DHTConnectionImplTest::testWriteAndReadData()
     DHTConnectionImpl con2;
     uint16_t con2port = con2.bind(0);
 
-    string message1 = "hello world.";
+    std::string message1 = "hello world.";
     con1.sendMessage(message1.c_str(), message1.size(), "localhost", con2port);
 
     char readbuffer[100];
-    string remoteHost;
+    std::string remoteHost;
     uint16_t remotePort;
     {
       ssize_t rlength = con2.receiveMessage(readbuffer, sizeof(readbuffer), remoteHost, remotePort);
-      CPPUNIT_ASSERT_EQUAL(string("127.0.0.1"), remoteHost);
+      CPPUNIT_ASSERT_EQUAL(std::string("127.0.0.1"), remoteHost);
       CPPUNIT_ASSERT_EQUAL((ssize_t)message1.size(), rlength);
       readbuffer[rlength] = '\0';
-      CPPUNIT_ASSERT_EQUAL(message1, string(readbuffer));
+      CPPUNIT_ASSERT_EQUAL(message1, std::string(readbuffer));
     }
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
     CPPUNIT_FAIL("exception thrown");
   }
 }
+
+} // namespace aria2
diff --git a/test/DHTFindNodeMessageTest.cc b/test/DHTFindNodeMessageTest.cc
index cdcee77a..3193c627 100644
--- a/test/DHTFindNodeMessageTest.cc
+++ b/test/DHTFindNodeMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTFindNodeMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTFindNodeMessageTest);
@@ -26,18 +28,18 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeMessageTest);
 
 void DHTFindNodeMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
-  DHTNodeHandle targetNode = new DHTNode();
+  SharedHandle<DHTNode> targetNode = new DHTNode();
 
   DHTFindNodeMessage msg(localNode, remoteNode, targetNode->getID(), transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -53,3 +55,5 @@ void DHTFindNodeMessageTest::testGetBencodedMessage()
 
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
+
+} // namespace aria2
diff --git a/test/DHTFindNodeReplyMessageTest.cc b/test/DHTFindNodeReplyMessageTest.cc
index b683203f..5a790a26 100644
--- a/test/DHTFindNodeReplyMessageTest.cc
+++ b/test/DHTFindNodeReplyMessageTest.cc
@@ -10,6 +10,8 @@
 #include "PeerMessageUtil.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTFindNodeReplyMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTFindNodeReplyMessageTest);
@@ -28,17 +30,17 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeReplyMessageTest);
 
 void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   DHTFindNodeReplyMessage msg(localNode, remoteNode, transactionID);
 
-  string compactNodeInfo;
-  DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  std::string compactNodeInfo;
+  SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     nodes[i] = new DHTNode();
     nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
@@ -47,12 +49,12 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
     char buf[6];
     CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
     compactNodeInfo +=
-      string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
-      string(&buf[0], &buf[sizeof(buf)]);
+      std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
+      std::string(&buf[0], &buf[sizeof(buf)]);
   }
-  msg.setClosestKNodes(DHTNodes(&nodes[0], &nodes[DHTBucket::K]));
+  msg.setClosestKNodes(std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -67,3 +69,5 @@ void DHTFindNodeReplyMessageTest::testGetBencodedMessage()
 
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
+
+} // namespace aria2
diff --git a/test/DHTGetPeersMessageTest.cc b/test/DHTGetPeersMessageTest.cc
index 0fbbe0f0..dae2d66e 100644
--- a/test/DHTGetPeersMessageTest.cc
+++ b/test/DHTGetPeersMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTGetPeersMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTGetPeersMessageTest);
@@ -26,19 +28,19 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersMessageTest);
 
 void DHTGetPeersMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   unsigned char infoHash[DHT_ID_LENGTH];
   DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH);
 
   DHTGetPeersMessage msg(localNode, remoteNode, infoHash, transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -55,3 +57,5 @@ void DHTGetPeersMessageTest::testGetBencodedMessage()
   CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 		       Util::urlencode(msgbody));
 }
+
+} // namespace aria2
diff --git a/test/DHTGetPeersReplyMessageTest.cc b/test/DHTGetPeersReplyMessageTest.cc
index 537dd5f1..b8b40f46 100644
--- a/test/DHTGetPeersReplyMessageTest.cc
+++ b/test/DHTGetPeersReplyMessageTest.cc
@@ -12,6 +12,8 @@
 #include "Peer.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTGetPeersReplyMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTGetPeersReplyMessageTest);
@@ -30,14 +32,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersReplyMessageTest);
 
 void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
-  string token = "token";
+  std::string token = "token";
 
   DHTGetPeersReplyMessage msg(localNode, remoteNode, token, transactionID);
 
@@ -50,8 +52,8 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
   r->put("token", new Data(token));
 
   {
-    string compactNodeInfo;
-    DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+    std::string compactNodeInfo;
+    SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i] = new DHTNode();
       nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
@@ -60,12 +62,12 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
       char buf[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
-	string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
-	string(&buf[0], &buf[sizeof(buf)]);
+	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
+	std::string(&buf[0], &buf[sizeof(buf)]);
     }
-    msg.setClosestKNodes(DHTNodes(&nodes[0], &nodes[DHTBucket::K]));
+    msg.setClosestKNodes(std::deque<SharedHandle<DHTNode> >(&nodes[0], &nodes[DHTBucket::K]));
 
-    string msgbody = msg.getBencodedMessage();
+    std::string msgbody = msg.getBencodedMessage();
 
     r->put("nodes", new Data(compactNodeInfo));
 
@@ -77,21 +79,23 @@ void DHTGetPeersReplyMessageTest::testGetBencodedMessage()
   }
   r->remove("nodes");
   {
-    Peers peers;
+    std::deque<SharedHandle<Peer> > peers;
     List* values = new List();
     r->put("values", values);
     for(size_t i = 0; i < 4; ++i) {
-      PeerHandle peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i);
+      SharedHandle<Peer> peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i);
       char buffer[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port));
       values->add(new Data(buffer, sizeof(buffer)));
       peers.push_back(peer);
     }
     msg.setValues(peers);
-    string msgbody  = msg.getBencodedMessage();
+    std::string msgbody  = msg.getBencodedMessage();
     BencodeVisitor v;
     cm->accept(&v);
     CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()),
 			 Util::urlencode(msgbody));
   }
 }
+
+} // namespace aria2
diff --git a/test/DHTIDCloserTest.cc b/test/DHTIDCloserTest.cc
index 3851742f..f470901b 100644
--- a/test/DHTIDCloserTest.cc
+++ b/test/DHTIDCloserTest.cc
@@ -3,8 +3,11 @@
 #include "DHTIDCloser.h"
 #include "Exception.h"
 #include "Util.h"
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTIDCloserTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTIDCloserTest);
@@ -26,21 +29,21 @@ void DHTIDCloserTest::testOperator()
   unsigned char id[DHT_ID_LENGTH];
   memset(id, 0xf0, DHT_ID_LENGTH);
 
-  DHTNodeLookupEntryHandle e1 = new DHTNodeLookupEntry(new DHTNode(id));
+  SharedHandle<DHTNodeLookupEntry> e1 = new DHTNodeLookupEntry(new DHTNode(id));
 
   id[0] = 0xb0;
-  DHTNodeLookupEntryHandle e2 = new DHTNodeLookupEntry(new DHTNode(id));
+  SharedHandle<DHTNodeLookupEntry> e2 = new DHTNodeLookupEntry(new DHTNode(id));
 
   id[0] = 0xa0;
-  DHTNodeLookupEntryHandle e3 = new DHTNodeLookupEntry(new DHTNode(id));
+  SharedHandle<DHTNodeLookupEntry> e3 = new DHTNodeLookupEntry(new DHTNode(id));
 
   id[0] = 0x80;
-  DHTNodeLookupEntryHandle e4 = new DHTNodeLookupEntry(new DHTNode(id));
+  SharedHandle<DHTNodeLookupEntry> e4 = new DHTNodeLookupEntry(new DHTNode(id));
 
   id[0] = 0x00;
-  DHTNodeLookupEntryHandle e5 = new DHTNodeLookupEntry(new DHTNode(id));
+  SharedHandle<DHTNodeLookupEntry> e5 = new DHTNodeLookupEntry(new DHTNode(id));
 
-  DHTNodeLookupEntries entries;
+  std::deque<SharedHandle<DHTNodeLookupEntry> > entries;
   entries.push_back(e1);
   entries.push_back(e2);
   entries.push_back(e3);
@@ -55,3 +58,5 @@ void DHTIDCloserTest::testOperator()
   CPPUNIT_ASSERT(e1 == entries[3]);
   CPPUNIT_ASSERT(e5 == entries[4]);
 }
+
+} // namespace aria2
diff --git a/test/DHTMessageFactoryImplTest.cc b/test/DHTMessageFactoryImplTest.cc
index 4dcdf1c9..e1f583c6 100644
--- a/test/DHTMessageFactoryImplTest.cc
+++ b/test/DHTMessageFactoryImplTest.cc
@@ -19,6 +19,8 @@
 #include "DHTAnnouncePeerReplyMessage.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTMessageFactoryImplTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTMessageFactoryImplTest);
@@ -37,9 +39,9 @@ public:
 
   DHTMessageFactoryImpl* factory;
 
-  DHTRoutingTableHandle routingTable;
+  SharedHandle<DHTRoutingTable> routingTable;
 
-  DHTNodeHandle localNode;
+  SharedHandle<DHTNode> localNode;
 
   unsigned char transactionID[DHT_TRANSACTION_ID_LENGTH];
 
@@ -86,7 +88,7 @@ void DHTMessageFactoryImplTest::testCreatePingMessage()
   d->put("a", a);
   
   SharedHandle<DHTPingMessage> m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881);
-  DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+  SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -105,7 +107,7 @@ void DHTMessageFactoryImplTest::testCreatePingReplyMessage()
   r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
   d->put("r", r);
 
-  DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+  SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
   
@@ -131,7 +133,7 @@ void DHTMessageFactoryImplTest::testCreateFindNodeMessage()
   d->put("a", a);
   
   SharedHandle<DHTFindNodeMessage> m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881);
-  DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+  SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -151,8 +153,8 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
     d->put("y", new Data("r"));
     Dictionary* r = new Dictionary();
     r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
-    string compactNodeInfo;
-    DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+    std::string compactNodeInfo;
+    SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i] = new DHTNode();
       nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
@@ -161,13 +163,13 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
       char buf[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
-	string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
-	string(&buf[0], &buf[sizeof(buf)]);
+	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
+	std::string(&buf[0], &buf[sizeof(buf)]);
     }
     r->put("nodes", new Data(compactNodeInfo));
     d->put("r", r);
 
-    DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+    SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6881);
   
@@ -181,7 +183,7 @@ void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage()
     CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH),
 			 Util::toHex(m->getTransactionID()));
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     CPPUNIT_FAIL("exception thrown.");
   }
 }
@@ -200,7 +202,7 @@ void DHTMessageFactoryImplTest::testCreateGetPeersMessage()
   d->put("a", a);
   
   SharedHandle<DHTGetPeersMessage> m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881);
-  DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+  SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
 
@@ -220,8 +222,8 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
     d->put("y", new Data("r"));
     Dictionary* r = new Dictionary();
     r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
-    string compactNodeInfo;
-    DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+    std::string compactNodeInfo;
+    SharedHandle<DHTNode> nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
     for(size_t i = 0; i < DHTBucket::K; ++i) {
       nodes[i] = new DHTNode();
       nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
@@ -230,14 +232,14 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
       char buf[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort()));
       compactNodeInfo +=
-	string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
-	string(&buf[0], &buf[sizeof(buf)]);
+	std::string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+
+	std::string(&buf[0], &buf[sizeof(buf)]);
     }
     r->put("nodes", new Data(compactNodeInfo));
     r->put("token", new Data("token"));
     d->put("r", r);
 
-    DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+    SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6881);
   
@@ -245,14 +247,14 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes()
 
     CPPUNIT_ASSERT(localNode == m->getLocalNode());
     CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
-    CPPUNIT_ASSERT_EQUAL(string("token"), m->getToken());
+    CPPUNIT_ASSERT_EQUAL(std::string("token"), m->getToken());
     CPPUNIT_ASSERT_EQUAL((size_t)DHTBucket::K, m->getClosestKNodes().size());
     CPPUNIT_ASSERT(nodes[0] == m->getClosestKNodes()[0]);
     CPPUNIT_ASSERT(nodes[7] == m->getClosestKNodes()[7]);
     CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH),
 			 Util::toHex(m->getTransactionID()));
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     CPPUNIT_FAIL("exception thrown.");
   }
 }
@@ -266,11 +268,11 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
     Dictionary* r = new Dictionary();
     r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
 
-    Peers peers;
+    std::deque<SharedHandle<Peer> > peers;
     List* values = new List();
     r->put("values", values);
     for(size_t i = 0; i < 4; ++i) {
-      PeerHandle peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i);
+      SharedHandle<Peer> peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i);
       char buffer[6];
       CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port));
       values->add(new Data(buffer, sizeof(buffer)));
@@ -280,7 +282,7 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
     r->put("token", new Data("token"));
     d->put("r", r);
 
-    DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+    SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6881);
   
@@ -288,14 +290,14 @@ void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values()
 
     CPPUNIT_ASSERT(localNode == m->getLocalNode());
     CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
-    CPPUNIT_ASSERT_EQUAL(string("token"), m->getToken());
+    CPPUNIT_ASSERT_EQUAL(std::string("token"), m->getToken());
     CPPUNIT_ASSERT_EQUAL((size_t)4, m->getValues().size());
     CPPUNIT_ASSERT(peers[0] == m->getValues()[0]);
     CPPUNIT_ASSERT(peers[3] == m->getValues()[3]);
     CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH),
 			 Util::toHex(m->getTransactionID()));
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     CPPUNIT_FAIL("exception thrown.");
   }
 }
@@ -312,14 +314,14 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
     unsigned char infoHash[DHT_ID_LENGTH];
     memset(infoHash, 0x11, DHT_ID_LENGTH);
     a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH));
-    string token = "ffff";
+    std::string token = "ffff";
     uint16_t port = 6881;
     a->put("port", new Data(Util::uitos(port), true));
     a->put("token", new Data(token));
     d->put("a", a);
   
     SharedHandle<DHTAnnouncePeerMessage> m = factory->createQueryMessage(d.get(), "192.168.0.1", 6882);
-    DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+    SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
     remoteNode->setIPAddress("192.168.0.1");
     remoteNode->setPort(6882);
 
@@ -332,8 +334,8 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage()
 			 Util::toHex(m->getInfoHash(), DHT_ID_LENGTH));
     CPPUNIT_ASSERT_EQUAL(port, m->getTCPPort());
   } catch(Exception* e) {
-    cerr << *e << endl;
-    string msg = e->getMsg();
+    std::cerr << *e << std::endl;
+    std::string msg = e->getMsg();
     delete e;
     CPPUNIT_FAIL(msg);
   }
@@ -348,7 +350,7 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
   r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH));
   d->put("r", r);
 
-  DHTNodeHandle remoteNode = new DHTNode(remoteNodeID);
+  SharedHandle<DHTNode> remoteNode = new DHTNode(remoteNodeID);
   remoteNode->setIPAddress("192.168.0.1");
   remoteNode->setPort(6881);
   
@@ -359,3 +361,5 @@ void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage()
   CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH),
 		       Util::toHex(m->getTransactionID()));
 }
+
+} // namespace aria2
diff --git a/test/DHTMessageTrackerEntryTest.cc b/test/DHTMessageTrackerEntryTest.cc
index c53bd5e9..ed2e5784 100644
--- a/test/DHTMessageTrackerEntryTest.cc
+++ b/test/DHTMessageTrackerEntryTest.cc
@@ -7,6 +7,8 @@
 #include "DHTMessageCallback.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTMessageTrackerEntryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTMessageTrackerEntryTest);
@@ -28,10 +30,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerEntryTest);
 
 void DHTMessageTrackerEntryTest::testMatch()
 {
-  DHTNodeHandle localNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
   try {
-    MockDHTMessageHandle msg1 = new MockDHTMessage(localNode, new DHTNode());
-    MockDHTMessageHandle msg2 = new MockDHTMessage(localNode, new DHTNode());
+    SharedHandle<MockDHTMessage> msg1 = new MockDHTMessage(localNode, new DHTNode());
+    SharedHandle<MockDHTMessage> msg2 = new MockDHTMessage(localNode, new DHTNode());
     
     DHTMessageTrackerEntry entry(msg1, 30);
     
@@ -42,11 +44,15 @@ void DHTMessageTrackerEntryTest::testMatch()
 				msg2->getRemoteNode()->getIPAddress(),
 				msg2->getRemoteNode()->getPort()));
   } catch(Exception* e) {
-    cerr << *e << endl;
-    CPPUNIT_FAIL("exception thrown.");
+    std::cerr << *e << std::endl;
+    std::string msg = e->getMsg();
+    delete e;
+    CPPUNIT_FAIL(msg);
   }
 }
 
 void DHTMessageTrackerEntryTest::testHandleTimeout()
 {
 }
+
+} // namespace aria2
diff --git a/test/DHTMessageTrackerTest.cc b/test/DHTMessageTrackerTest.cc
index 17a4a007..800e2556 100644
--- a/test/DHTMessageTrackerTest.cc
+++ b/test/DHTMessageTrackerTest.cc
@@ -12,6 +12,8 @@
 #include "Data.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTMessageTrackerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTMessageTrackerTest);
@@ -33,13 +35,11 @@ public:
 
     MockDHTMessageCallback2():_countOnRecivedCalled(0) {}
 
-    virtual void onReceived(const DHTMessageHandle& message)
+    virtual void onReceived(const SharedHandle<DHTMessage>& message)
     {
       ++_countOnRecivedCalled;
     }
   };
-
-  typedef SharedHandle<MockDHTMessageCallback2> MockDHTMessageCallback2Handle;
 };
 
 
@@ -47,14 +47,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerTest);
 
 void DHTMessageTrackerTest::testMessageArrived()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTRoutingTableHandle routingTable = new DHTRoutingTable(localNode);
-  MockDHTMessageFactoryHandle factory = new MockDHTMessageFactory();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTRoutingTable> routingTable = new DHTRoutingTable(localNode);
+  SharedHandle<MockDHTMessageFactory> factory = new MockDHTMessageFactory();
   factory->setLocalNode(localNode);
 
-  MockDHTMessageHandle m1 = new MockDHTMessage(localNode, new DHTNode());
-  MockDHTMessageHandle m2 = new MockDHTMessage(localNode, new DHTNode());
-  MockDHTMessageHandle m3 = new MockDHTMessage(localNode, new DHTNode());
+  SharedHandle<MockDHTMessage> m1 = new MockDHTMessage(localNode, new DHTNode());
+  SharedHandle<MockDHTMessage> m2 = new MockDHTMessage(localNode, new DHTNode());
+  SharedHandle<MockDHTMessage> m3 = new MockDHTMessage(localNode, new DHTNode());
 
   m1->getRemoteNode()->setIPAddress("192.168.0.1");
   m1->getRemoteNode()->setPort(6881);
@@ -63,7 +63,7 @@ void DHTMessageTrackerTest::testMessageArrived()
   m3->getRemoteNode()->setIPAddress("192.168.0.3");
   m3->getRemoteNode()->setPort(6883);
 
-  MockDHTMessageCallback2Handle c2 = new MockDHTMessageCallback2();
+  SharedHandle<MockDHTMessageCallback2> c2 = new MockDHTMessageCallback2();
   
   DHTMessageTracker tracker;
   tracker.setRoutingTable(routingTable);
@@ -76,9 +76,9 @@ void DHTMessageTrackerTest::testMessageArrived()
     SharedHandle<Dictionary> res = new Dictionary();
     res->put("t", new Data(m2->getTransactionID()));
     
-    std::pair<DHTMessageHandle, DHTMessageCallbackHandle> p =
+    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p =
       tracker.messageArrived(res.get(), m2->getRemoteNode()->getIPAddress(), m2->getRemoteNode()->getPort());
-    DHTMessageHandle reply = p.first;
+    SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(!reply.isNull());
     CPPUNIT_ASSERT_EQUAL((uint32_t)0, c2->_countOnRecivedCalled);
@@ -89,8 +89,8 @@ void DHTMessageTrackerTest::testMessageArrived()
     SharedHandle<Dictionary> res = new Dictionary();
     res->put("t", new Data(m3->getTransactionID()));
 
-    std::pair<DHTMessageHandle, DHTMessageCallbackHandle> p = tracker.messageArrived(res.get(), m3->getRemoteNode()->getIPAddress(), m3->getRemoteNode()->getPort());
-    DHTMessageHandle reply = p.first;
+    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = tracker.messageArrived(res.get(), m3->getRemoteNode()->getIPAddress(), m3->getRemoteNode()->getPort());
+    SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(!reply.isNull());
     CPPUNIT_ASSERT(tracker.getEntryFor(m3).isNull());
@@ -100,8 +100,8 @@ void DHTMessageTrackerTest::testMessageArrived()
     SharedHandle<Dictionary> res = new Dictionary();
     res->put("t", new Data(m1->getTransactionID()));
 
-    std::pair<DHTMessageHandle, DHTMessageCallbackHandle> p = tracker.messageArrived(res.get(), "192.168.1.100", 6889);
-    DHTMessageHandle reply = p.first;
+    std::pair<SharedHandle<DHTMessage>, SharedHandle<DHTMessageCallback> > p = tracker.messageArrived(res.get(), "192.168.1.100", 6889);
+    SharedHandle<DHTMessage> reply = p.first;
 
     CPPUNIT_ASSERT(reply.isNull());
   }
@@ -110,3 +110,5 @@ void DHTMessageTrackerTest::testMessageArrived()
 void DHTMessageTrackerTest::testHandleTimeout()
 {
 }
+
+} // namespace aria2
diff --git a/test/DHTNodeTest.cc b/test/DHTNodeTest.cc
index cd24544c..d8d2b6cf 100644
--- a/test/DHTNodeTest.cc
+++ b/test/DHTNodeTest.cc
@@ -3,6 +3,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTNodeTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTNodeTest);
@@ -22,5 +24,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTNodeTest);
 void DHTNodeTest::testGenerateID()
 {
   DHTNode node;
-  cerr << Util::toHex(node.getID(), DHT_ID_LENGTH) << endl;
+  std::cerr << Util::toHex(node.getID(), DHT_ID_LENGTH) << std::endl;
 }
+
+} // namespace aria2
diff --git a/test/DHTPeerAnnounceEntryTest.cc b/test/DHTPeerAnnounceEntryTest.cc
index a8222102..83ef477d 100644
--- a/test/DHTPeerAnnounceEntryTest.cc
+++ b/test/DHTPeerAnnounceEntryTest.cc
@@ -4,8 +4,11 @@
 #include "MockBtContext.h"
 #include "MockPeerStorage.h"
 #include "BtRegistry.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTPeerAnnounceEntryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTPeerAnnounceEntryTest);
@@ -49,9 +52,9 @@ void DHTPeerAnnounceEntryTest::testRemoveStalePeerAddrEntry()
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, entry.countPeerAddrEntry());
 
-  const PeerAddrEntries& peerAdderEntries = entry.getPeerAddrEntries();
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peerAdderEntries[0].getIPAddress());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peerAdderEntries[1].getIPAddress());
+  const std::deque<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());
 }
 
 
@@ -97,20 +100,20 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
   unsigned char infohash[DHT_ID_LENGTH];
   memset(infohash, 0xff, DHT_ID_LENGTH);
 
-  MockBtContextHandle ctx = new MockBtContext();
+  SharedHandle<MockBtContext> ctx = new MockBtContext();
   ctx->setInfoHash(infohash);
-  MockPeerStorageHandle peerStorage = new MockPeerStorage();
+  SharedHandle<MockPeerStorage> peerStorage = new MockPeerStorage();
   {
-    PeerHandle activePeers[] = { new Peer("192.168.0.3", 6883),
+    SharedHandle<Peer> activePeers[] = { new Peer("192.168.0.3", 6883),
 				 new Peer("192.168.0.4", 6884) };
-    peerStorage->setActivePeers(Peers(&activePeers[0],
-				      &activePeers[2]));
+    peerStorage->setActivePeers(std::deque<SharedHandle<Peer> >(&activePeers[0],
+								&activePeers[2]));
   }
   BtRegistry::registerPeerStorage(ctx->getInfoHashAsString(), peerStorage);
 
   DHTPeerAnnounceEntry entry(infohash);
   {
-    Peers peers = entry.getPeers();
+    std::deque<SharedHandle<Peer> > peers = entry.getPeers();
     CPPUNIT_ASSERT_EQUAL((size_t)0, peers.size());
   }
 
@@ -118,24 +121,26 @@ void DHTPeerAnnounceEntryTest::testGetPeers()
   entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.2", 6882));
 
   {
-    Peers peers = entry.getPeers();
+    std::deque<SharedHandle<Peer> > peers = entry.getPeers();
     CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peers[0]->ipaddr);
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peers[0]->ipaddr);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peers[0]->port);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), peers[1]->ipaddr); 
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), peers[1]->ipaddr); 
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peers[1]->port);
   }
   entry.setBtContext(ctx);
   {
-    Peers peers = entry.getPeers();
+    std::deque<SharedHandle<Peer> > peers = entry.getPeers();
     CPPUNIT_ASSERT_EQUAL((size_t)4, peers.size());
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peers[0]->ipaddr);
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peers[0]->ipaddr);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peers[0]->port);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), peers[1]->ipaddr); 
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), peers[1]->ipaddr); 
     CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peers[1]->port);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peers[2]->ipaddr);
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"), peers[2]->ipaddr);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6883, peers[2]->port);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.4"), peers[3]->ipaddr); 
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.4"), peers[3]->ipaddr); 
     CPPUNIT_ASSERT_EQUAL((uint16_t)6884, peers[3]->port);
   }
 }
+
+} // namespace aria2
diff --git a/test/DHTPeerAnnounceStorageTest.cc b/test/DHTPeerAnnounceStorageTest.cc
index 19b51214..071939c2 100644
--- a/test/DHTPeerAnnounceStorageTest.cc
+++ b/test/DHTPeerAnnounceStorageTest.cc
@@ -4,8 +4,11 @@
 #include "MockBtContext.h"
 #include "DHTConstants.h"
 #include "Peer.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTPeerAnnounceStorageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTPeerAnnounceStorageTest);
@@ -37,11 +40,11 @@ void DHTPeerAnnounceStorageTest::testAddAnnounce()
   storage.addPeerAnnounce(infohash2, "192.168.0.3", 6883);
   storage.addPeerAnnounce(infohash2, "192.168.0.4", 6884);
   
-  Peers peers = storage.getPeers(infohash2);
+  std::deque<SharedHandle<Peer> > peers = storage.getPeers(infohash2);
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peers[0]->ipaddr);
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.4"), peers[1]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"), peers[0]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.4"), peers[1]->ipaddr);
 }
 
 void DHTPeerAnnounceStorageTest::testRemovePeerAnnounce()
@@ -52,10 +55,10 @@ void DHTPeerAnnounceStorageTest::testRemovePeerAnnounce()
   memset(infohash2, 0xf0, DHT_ID_LENGTH);
   DHTPeerAnnounceStorage storage;
 
-  MockBtContextHandle ctx1 = new MockBtContext();
+  SharedHandle<MockBtContext> ctx1 = new MockBtContext();
   ctx1->setInfoHash(infohash1);
 
-  MockBtContextHandle ctx2 = new MockBtContext();
+  SharedHandle<MockBtContext> ctx2 = new MockBtContext();
   ctx2->setInfoHash(infohash2);
 
   storage.addPeerAnnounce(infohash1, "192.168.0.1", 6881);
@@ -68,3 +71,5 @@ void DHTPeerAnnounceStorageTest::testRemovePeerAnnounce()
   storage.removePeerAnnounce(ctx1);
   CPPUNIT_ASSERT(storage.contains(infohash1));
 }
+
+} // namespace aria2
diff --git a/test/DHTPingMessageTest.cc b/test/DHTPingMessageTest.cc
index 091ab85c..71186dca 100644
--- a/test/DHTPingMessageTest.cc
+++ b/test/DHTPingMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTPingMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTPingMessageTest);
@@ -26,16 +28,16 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingMessageTest);
 
 void DHTPingMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   DHTPingMessage msg(localNode, remoteNode, transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -50,3 +52,5 @@ void DHTPingMessageTest::testGetBencodedMessage()
 
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
+
+} // namespace aria2
diff --git a/test/DHTPingReplyMessageTest.cc b/test/DHTPingReplyMessageTest.cc
index 7d5ce4cb..df4e9ca5 100644
--- a/test/DHTPingReplyMessageTest.cc
+++ b/test/DHTPingReplyMessageTest.cc
@@ -8,6 +8,8 @@
 #include "Util.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTPingReplyMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTPingReplyMessageTest);
@@ -26,19 +28,19 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingReplyMessageTest);
 
 void DHTPingReplyMessageTest::testGetBencodedMessage()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  DHTNodeHandle remoteNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
 
   char tid[DHT_TRANSACTION_ID_LENGTH];
   DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
-  string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
 
   char id[DHT_ID_LENGTH];
   DHTUtil::generateRandomData(id, DHT_ID_LENGTH);
 
   DHTPingReplyMessage msg(localNode, remoteNode, (const unsigned char*)id, transactionID);
 
-  string msgbody = msg.getBencodedMessage();
+  std::string msgbody = msg.getBencodedMessage();
 
   SharedHandle<Dictionary> cm = new Dictionary();
   cm->put("t", new Data(transactionID));
@@ -52,3 +54,5 @@ void DHTPingReplyMessageTest::testGetBencodedMessage()
 
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
+
+} // namespace aria2
diff --git a/test/DHTRoutingTableDeserializerTest.cc b/test/DHTRoutingTableDeserializerTest.cc
index 5008b648..2bfc69e4 100644
--- a/test/DHTRoutingTableDeserializerTest.cc
+++ b/test/DHTRoutingTableDeserializerTest.cc
@@ -3,7 +3,7 @@
 #include "Exception.h"
 #include "Util.h"
 #include "DHTNode.h"
-#include "a2functional.h"
+#include "array_fun.h"
 #include "DHTConstants.h"
 #include "PeerMessageUtil.h"
 #include <arpa/inet.h>
@@ -11,6 +11,8 @@
 #include <sstream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTRoutingTableDeserializerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTRoutingTableDeserializerTest);
@@ -29,22 +31,22 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableDeserializerTest);
 
 void DHTRoutingTableDeserializerTest::testDeserialize()
 {
-  DHTNodeHandle localNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
 
-  DHTNodeHandle nodesSrc[] = { 0, 0, 0 };
+  SharedHandle<DHTNode> nodesSrc[] = { 0, 0, 0 };
   for(size_t i = 0; i < arrayLength(nodesSrc); ++i) {
     nodesSrc[i] = new DHTNode();
     nodesSrc[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  DHTNodes nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
+  std::deque<SharedHandle<DHTNode> > nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
   
   DHTRoutingTableSerializer s;
   s.setLocalNode(localNode);
   s.setNodes(nodes);
 
-  stringstream ss;
+  std::stringstream ss;
   s.serialize(ss);
 
   DHTRoutingTableDeserializer d;
@@ -53,14 +55,16 @@ void DHTRoutingTableDeserializerTest::testDeserialize()
   CPPUNIT_ASSERT(memcmp(localNode->getID(), d.getLocalNode()->getID(),
 			DHT_ID_LENGTH) == 0);
 
-  cout << d.getSerializedTime().getTime() << endl;
+  std::cout << d.getSerializedTime().getTime() << std::endl;
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, d.getNodes().size());
-  const DHTNodes& dsnodes = d.getNodes();
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), dsnodes[0]->getIPAddress());
+  const std::deque<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);
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), dsnodes[1]->getIPAddress());
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"), dsnodes[1]->getIPAddress());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6883, dsnodes[1]->getPort());
   CPPUNIT_ASSERT(memcmp(nodes[2]->getID(), dsnodes[1]->getID(), DHT_ID_LENGTH) == 0);
 }
+
+} // namespace aria2
diff --git a/test/DHTRoutingTableSerializerTest.cc b/test/DHTRoutingTableSerializerTest.cc
index 025f336d..18957c79 100644
--- a/test/DHTRoutingTableSerializerTest.cc
+++ b/test/DHTRoutingTableSerializerTest.cc
@@ -2,7 +2,7 @@
 #include "Exception.h"
 #include "Util.h"
 #include "DHTNode.h"
-#include "a2functional.h"
+#include "array_fun.h"
 #include "DHTConstants.h"
 #include "PeerMessageUtil.h"
 #include <arpa/inet.h>
@@ -10,6 +10,8 @@
 #include <sstream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTRoutingTableSerializerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTRoutingTableSerializerTest);
@@ -28,22 +30,22 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableSerializerTest);
 
 void DHTRoutingTableSerializerTest::testSerialize()
 {
-  DHTNodeHandle localNode = new DHTNode();
+  SharedHandle<DHTNode> localNode = new DHTNode();
 
-  DHTNodeHandle nodesSrc[] = { 0, 0, 0 };
+  SharedHandle<DHTNode> nodesSrc[] = { 0, 0, 0 };
   for(size_t i = 0; i < arrayLength(nodesSrc); ++i) {
     nodesSrc[i] = new DHTNode();
     nodesSrc[i]->setIPAddress("192.168.0."+Util::uitos(i+1));
     nodesSrc[i]->setPort(6881+i);
   }
   nodesSrc[1]->setIPAddress("non-numerical-name");
-  DHTNodes nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
+  std::deque<SharedHandle<DHTNode> > nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]);
   
   DHTRoutingTableSerializer s;
   s.setLocalNode(localNode);
   s.setNodes(nodes);
 
-  stringstream ss;
+  std::stringstream ss;
   s.serialize(ss);
 
   char zero[8];
@@ -68,7 +70,7 @@ void DHTRoutingTableSerializerTest::testSerialize()
   // time
   ss.read(buf, 4);
   time_t time = ntohl(*reinterpret_cast<uint32_t*>(buf));
-  cerr << time << endl;
+  std::cerr << time << std::endl;
   // 4bytes reserved
   ss.read(buf, 4);
   CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0);
@@ -96,8 +98,8 @@ void DHTRoutingTableSerializerTest::testSerialize()
   // 6bytes compact peer info
   ss.read(buf, 6);
   {
-    pair<string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peer.first);
+    std::pair<std::string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer.first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peer.second);
   }
   // 2bytes reserved
@@ -130,8 +132,8 @@ void DHTRoutingTableSerializerTest::testSerialize()
   // 6bytes compact peer info
   ss.read(buf, 6);
   {
-    pair<string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peer.first);
+    std::pair<std::string, uint16_t> peer = PeerMessageUtil::unpackcompact(buf);
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"), peer.first);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6883, peer.second);
   }
   // 2bytes reserved
@@ -149,3 +151,5 @@ void DHTRoutingTableSerializerTest::testSerialize()
   CPPUNIT_ASSERT_EQUAL((std::streamsize)0, ss.gcount());
   CPPUNIT_ASSERT(ss.eof());
 }
+
+} // namespace aria2
diff --git a/test/DHTRoutingTableTest.cc b/test/DHTRoutingTableTest.cc
index 421ae220..f77ed24f 100644
--- a/test/DHTRoutingTableTest.cc
+++ b/test/DHTRoutingTableTest.cc
@@ -6,8 +6,11 @@
 #include "MockDHTTaskQueue.h"
 #include "MockDHTTaskFactory.h"
 #include "DHTTask.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTRoutingTableTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTRoutingTableTest);
@@ -51,13 +54,13 @@ void DHTRoutingTableTest::testGetClosestKNodes()
 {
   unsigned char id[DHT_ID_LENGTH];
   createID(id, 0x81, 0);
-  DHTNodeHandle localNode = new DHTNode(id);
+  SharedHandle<DHTNode> localNode = new DHTNode(id);
 
   DHTRoutingTable table(localNode);
 
-  DHTNodeHandle nodes1[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-  DHTNodeHandle nodes2[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-  DHTNodeHandle nodes3[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes1[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes2[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+  SharedHandle<DHTNode> nodes3[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   for(size_t i = 0; i < DHTBucket::K; ++i) {
     createID(id, 0xf0, i);
     nodes1[i] = new DHTNode(id);
@@ -75,10 +78,12 @@ void DHTRoutingTableTest::testGetClosestKNodes()
   }
   {
     createID(id, 0x80, 0x10);
-    DHTNodes nodes = table.getClosestKNodes(id);
+    std::deque<SharedHandle<DHTNode> > nodes = table.getClosestKNodes(id);
     CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size());
     for(size_t i = 0; i < nodes.size(); ++i) {
       CPPUNIT_ASSERT(memcmp(nodes2[0]->getID(), nodes[0]->getID(), DHT_ID_LENGTH) == 0);
     }
   }
 }
+
+} // namespace aria2
diff --git a/test/DHTTokenTrackerTest.cc b/test/DHTTokenTrackerTest.cc
index 4f4d65fc..3c7c29cc 100644
--- a/test/DHTTokenTrackerTest.cc
+++ b/test/DHTTokenTrackerTest.cc
@@ -5,6 +5,8 @@
 #include "DHTConstants.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTTokenTrackerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTTokenTrackerTest);
@@ -25,17 +27,19 @@ void DHTTokenTrackerTest::testGenerateToken()
 {
   unsigned char infohash[DHT_ID_LENGTH];
   DHTUtil::generateRandomData(reinterpret_cast<char*>(infohash), DHT_ID_LENGTH);
-  string ipaddr = "192.168.0.1";
+  std::string ipaddr = "192.168.0.1";
   uint16_t port = 6881;
   
   DHTTokenTracker tracker;
-  string token = tracker.generateToken(infohash, ipaddr, port);
+  std::string token = tracker.generateToken(infohash, ipaddr, port);
   CPPUNIT_ASSERT(tracker.validateToken(token, infohash, ipaddr, port));
 
   tracker.updateTokenSecret();
   CPPUNIT_ASSERT(tracker.validateToken(token, infohash, ipaddr, port));
-  string newtoken = tracker.generateToken(infohash, ipaddr, port);
+  std::string newtoken = tracker.generateToken(infohash, ipaddr, port);
   tracker.updateTokenSecret();
   CPPUNIT_ASSERT(!tracker.validateToken(token, infohash, ipaddr, port));
   CPPUNIT_ASSERT(tracker.validateToken(newtoken, infohash, ipaddr, port));
 }
+
+} // namespace aria2
diff --git a/test/DHTUnknownMessageTest.cc b/test/DHTUnknownMessageTest.cc
index b9f966f6..b3597684 100644
--- a/test/DHTUnknownMessageTest.cc
+++ b/test/DHTUnknownMessageTest.cc
@@ -3,6 +3,8 @@
 #include "Exception.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DHTUnknownMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTUnknownMessageTest);
@@ -21,24 +23,26 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DHTUnknownMessageTest);
 
 void DHTUnknownMessageTest::testToString()
 {
-  DHTNodeHandle localNode = new DHTNode();
-  string ipaddr = "192.168.0.1";
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  std::string ipaddr = "192.168.0.1";
   uint16_t port = 6881;
 
   {
     // data.size() > 8
-    string data = "chocolate";
-    DHTUnknownMessage msg(localNode, remoteNode, data.c_str(), data.size(),
+    std::string data = "chocolate";
+    DHTUnknownMessage msg(localNode, data.c_str(), data.size(),
 			  ipaddr, port);
 
-    CPPUNIT_ASSERT_EQUAL(string("dht unknown Remote:192.168.0.1:6881 length=9, first 8 bytes(hex)=63686f636f6c617465"), msg.toString());
+    CPPUNIT_ASSERT_EQUAL(std::string("dht unknown Remote:192.168.0.1:6881 length=9, first 8 bytes(hex)=63686f636f6c6174"), msg.toString());
   }
   {
     // data.size() == 3
-    string data = "foo";
-    DHTUnknownMessage msg(localNode, remoteNode, data.c_str(), data.size(),
+    std::string data = "foo";
+    DHTUnknownMessage msg(localNode, data.c_str(), data.size(),
 			  ipaddr, port);
 
-    CPPUNIT_ASSERT_EQUAL(string("dht unknown Remote:192.168.0.1:6881 length=9, first 8 bytes(hex)=66666f"), msg.toString());
+    CPPUNIT_ASSERT_EQUAL(std::string("dht unknown Remote:192.168.0.1:6881 length=3, first 8 bytes(hex)=666f6f"), msg.toString());
   }
 }
+
+} // namespace aria2
diff --git a/test/DataTest.cc b/test/DataTest.cc
index 65de34c9..e8a10b9e 100644
--- a/test/DataTest.cc
+++ b/test/DataTest.cc
@@ -1,8 +1,8 @@
 #include "Data.h"
-#include <string>
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DataTest:public CppUnit::TestFixture {
 
@@ -29,10 +29,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DataTest );
 
 void DataTest::testToString() {
   Data data("aria2", 5);
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), data.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), data.toString());
 
   Data null(reinterpret_cast<const char*>(0), 0);
-  CPPUNIT_ASSERT_EQUAL(string(""), null.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), null.toString());
 }
 
 void DataTest::testGetData() {
@@ -67,3 +67,5 @@ void DataTest::testToLLInt() {
   Data alpha("abc", 3);
   CPPUNIT_ASSERT_EQUAL(0, (int)alpha.toLLInt());
 }
+
+} // namespace aria2
diff --git a/test/DefaultAuthResolverTest.cc b/test/DefaultAuthResolverTest.cc
index 7cc04cba..0f5e8fce 100644
--- a/test/DefaultAuthResolverTest.cc
+++ b/test/DefaultAuthResolverTest.cc
@@ -1,8 +1,9 @@
 #include "DefaultAuthResolver.h"
 #include "prefs.h"
+#include "AuthConfig.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultAuthResolverTest : public CppUnit::TestFixture {
 
@@ -13,7 +14,7 @@ class DefaultAuthResolverTest : public CppUnit::TestFixture {
 private:
   //NetrcHandle _netrc;
   //SharedHandle<Option> _option;
-  DefaultAuthResolverHandle _resolver;
+  SharedHandle<DefaultAuthResolver> _resolver;
 public:
   void setUp()
   {
@@ -33,13 +34,15 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DefaultAuthResolverTest );
 
 void DefaultAuthResolverTest::testResolveAuthConfig_without_userDefined()
 {
-  AuthConfigHandle authConfig = _resolver->resolveAuthConfig("localhost");
-  CPPUNIT_ASSERT_EQUAL(string("foo:bar"), authConfig->getAuthText());
+  SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost");
+  CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText());
 }
 
 void DefaultAuthResolverTest::testResolveAuthConfig_with_userDefined()
 {
   _resolver->setUserDefinedAuthConfig(new AuthConfig("myname", "mypasswd"));
-  AuthConfigHandle authConfig = _resolver->resolveAuthConfig("localhost");
-  CPPUNIT_ASSERT_EQUAL(string("myname:mypasswd"), authConfig->getAuthText());
+  SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost");
+  CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtAnnounceTest.cc b/test/DefaultBtAnnounceTest.cc
index da07d0cf..2b1548d7 100644
--- a/test/DefaultBtAnnounceTest.cc
+++ b/test/DefaultBtAnnounceTest.cc
@@ -9,9 +9,10 @@
 #include "BtRuntime.h"
 #include "AnnounceTier.h"
 #include "FixedNumberRandomizer.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultBtAnnounceTest:public CppUnit::TestFixture {
 
@@ -26,10 +27,10 @@ class DefaultBtAnnounceTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testProcessAnnounceResponse);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MockBtContextHandle _btContext;
-  MockPieceStorageHandle _pieceStorage;
-  MockPeerStorageHandle _peerStorage;
-  BtRuntimeHandle _btRuntime;
+  SharedHandle<MockBtContext> _btContext;
+  SharedHandle<MockPieceStorage> _pieceStorage;
+  SharedHandle<MockPeerStorage> _peerStorage;
+  SharedHandle<BtRuntime> _btRuntime;
   Option* _option;
 public:
   DefaultBtAnnounceTest():_btContext(0),
@@ -49,7 +50,7 @@ public:
 					       0x89, 0xab, 0xcd, 0xef,
 					       0x01, 0x23, 0x45, 0x67 };
     
-    string peerId = "-aria2-ultrafastdltl";
+    std::string peerId = "-aria2-ultrafastdltl";
 
     _btContext = new MockBtContext();
     _btContext->setInfoHash(infoHash);
@@ -91,15 +92,15 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtAnnounceTest);
 
 void DefaultBtAnnounceTest::testNoMoreAnnounce()
 {
-  string trackerURI1 = "http://localhost/announce";
-  Strings uris1;
+  std::string trackerURI1 = "http://localhost/announce";
+  std::deque<std::string> uris1;
   uris1.push_back(trackerURI1);
-  AnnounceTierHandle announceTier1 = new AnnounceTier(uris1);
+  SharedHandle<AnnounceTier> announceTier1 = new AnnounceTier(uris1);
 
-  string trackerURI2 = "http://backup/announce";
-  Strings uris2;
+  std::string trackerURI2 = "http://backup/announce";
+  std::deque<std::string> uris2;
   uris2.push_back(trackerURI2);
-  AnnounceTierHandle announceTier2 = new AnnounceTier(uris2);
+  SharedHandle<AnnounceTier> announceTier2 = new AnnounceTier(uris2);
 
 
   _btContext->addAnnounceTier(announceTier1);
@@ -112,35 +113,35 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce()
   btAnnounce.setRandomizer(new FixedNumberRandomizer());
   btAnnounce.generateKey();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceFailure();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _pieceStorage->setAllDownloadFinished(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _btRuntime->setHalt(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
@@ -149,10 +150,10 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce()
 
 void DefaultBtAnnounceTest::testGetAnnounceUrl()
 {
-  string trackerURI = "http://localhost/announce";
-  Strings uris;
+  std::string trackerURI = "http://localhost/announce";
+  std::deque<std::string> uris;
   uris.push_back(trackerURI);
-  AnnounceTierHandle announceTier = new AnnounceTier(uris);
+  SharedHandle<AnnounceTier> announceTier = new AnnounceTier(uris);
 
   _btContext->addAnnounceTier(announceTier);
 
@@ -163,36 +164,36 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl()
   btAnnounce.setRandomizer(new FixedNumberRandomizer());
   btAnnounce.generateKey();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _pieceStorage->setAllDownloadFinished(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _btRuntime->setHalt(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
 }
 
 void DefaultBtAnnounceTest::testIsAllAnnounceFailed()
 {
-  string trackerURI1 = "http://localhost/announce";
-  Strings uris1;
+  std::string trackerURI1 = "http://localhost/announce";
+  std::deque<std::string> uris1;
   uris1.push_back(trackerURI1);
-  AnnounceTierHandle announceTier1 = new AnnounceTier(uris1);
+  SharedHandle<AnnounceTier> announceTier1 = new AnnounceTier(uris1);
 
-  string trackerURI2 = "http://backup/announce";
-  Strings uris2;
+  std::string trackerURI2 = "http://backup/announce";
+  std::deque<std::string> uris2;
   uris2.push_back(trackerURI2);
-  AnnounceTierHandle announceTier2 = new AnnounceTier(uris2);
+  SharedHandle<AnnounceTier> announceTier2 = new AnnounceTier(uris2);
 
 
   _btContext->addAnnounceTier(announceTier1);
@@ -205,16 +206,16 @@ void DefaultBtAnnounceTest::testIsAllAnnounceFailed()
   btAnnounce.setRandomizer(new FixedNumberRandomizer());
   btAnnounce.generateKey();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceFailure();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://backup/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceFailure();
 
   CPPUNIT_ASSERT(!btAnnounce.isAnnounceReady());
-  CPPUNIT_ASSERT_EQUAL(string(""), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), btAnnounce.getAnnounceUrl());
   CPPUNIT_ASSERT(btAnnounce.isAllAnnounceFailed());
   
   btAnnounce.resetAnnounce();
@@ -226,7 +227,7 @@ void DefaultBtAnnounceTest::testURLOrderInStoppedEvent()
 {
   const char* urls[] = { "http://localhost1/announce",
 			 "http://localhost2/announce" };
-  AnnounceTierHandle announceTier = new AnnounceTier(Strings(&urls[0], &urls[2]));
+  SharedHandle<AnnounceTier> announceTier = new AnnounceTier(std::deque<std::string>(&urls[0], &urls[2]));
 
   _btContext->addAnnounceTier(announceTier);
 
@@ -237,17 +238,17 @@ void DefaultBtAnnounceTest::testURLOrderInStoppedEvent()
   btAnnounce.setRandomizer(new FixedNumberRandomizer());
   btAnnounce.generateKey();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _btRuntime->setHalt(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceFailure();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost2/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost2/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=0&no_peer_id=1&port=6989&event=stopped"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 }
@@ -256,7 +257,7 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent()
 {
   const char* urls[] = { "http://localhost1/announce",
 			 "http://localhost2/announce" };
-  AnnounceTierHandle announceTier = new AnnounceTier(Strings(&urls[0], &urls[2]));
+  SharedHandle<AnnounceTier> announceTier = new AnnounceTier(std::deque<std::string>(&urls[0], &urls[2]));
 
   _btContext->addAnnounceTier(announceTier);
 
@@ -267,17 +268,17 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent()
   btAnnounce.setRandomizer(new FixedNumberRandomizer());
   btAnnounce.generateKey();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=started"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 
   _pieceStorage->setAllDownloadFinished(true);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceFailure();
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost2/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost2/announce?info_hash=%01%23Eg%89%ab%cd%ef%01%23Eg%89%ab%cd%ef%01%23Eg&peer_id=%2daria2%2dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=AAAAAAAA&numwant=50&no_peer_id=1&port=6989&event=completed"), btAnnounce.getAnnounceUrl());
 
   btAnnounce.announceSuccess();
 }
@@ -285,11 +286,11 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent()
 void DefaultBtAnnounceTest::testProcessAnnounceResponse_malformed()
 {
   try {
-    string res = "i123e";
+    std::string res = "i123e";
     DefaultBtAnnounce(new MockBtContext(), _option).processAnnounceResponse(res.c_str(), res.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
@@ -297,18 +298,18 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse_malformed()
 void DefaultBtAnnounceTest::testProcessAnnounceResponse_failureReason()
 {
   try {
-    string res = "d14:failure reason11:hello worlde";
+    std::string res = "d14:failure reason11:hello worlde";
     DefaultBtAnnounce(new MockBtContext(), _option).processAnnounceResponse(res.c_str(), res.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
 
 void DefaultBtAnnounceTest::testProcessAnnounceResponse()
 {
-  string res = "d"
+  std::string res = "d"
     "15:warning message11:hello world"
     "10:tracker id3:foo"
     "8:intervali3000e"
@@ -319,9 +320,11 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse()
   
   DefaultBtAnnounce an(new MockBtContext(), _option);
   an.processAnnounceResponse(res.c_str(), res.size());
-  CPPUNIT_ASSERT_EQUAL(string("foo"), an.getTrackerID());
+  CPPUNIT_ASSERT_EQUAL(std::string("foo"), an.getTrackerID());
   CPPUNIT_ASSERT_EQUAL(3000, an.getInterval());
   CPPUNIT_ASSERT_EQUAL(1800, an.getMinInterval());
   CPPUNIT_ASSERT_EQUAL(100, an.getComplete());
   CPPUNIT_ASSERT_EQUAL(200, an.getIncomplete());
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtContextTest.cc b/test/DefaultBtContextTest.cc
index 68501a37..3ec7852b 100644
--- a/test/DefaultBtContextTest.cc
+++ b/test/DefaultBtContextTest.cc
@@ -3,9 +3,10 @@
 #include "Exception.h"
 #include "AnnounceTier.h"
 #include "FixedNumberRandomizer.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultBtContextTest:public CppUnit::TestFixture {
 
@@ -64,7 +65,7 @@ void DefaultBtContextTest::testGetInfoHash() {
   DefaultBtContext btContext;
   btContext.load("test.torrent");
 
-  string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
+  std::string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
 
   CPPUNIT_ASSERT_EQUAL((int32_t)20, btContext.getInfoHashLength());
   CPPUNIT_ASSERT_EQUAL(correctHash, Util::toHex(btContext.getInfoHash(),
@@ -81,9 +82,9 @@ void DefaultBtContextTest::testGetPieceHash() {
 		       btContext.getPieceHash(1));
   CPPUNIT_ASSERT_EQUAL(Util::toHex((const unsigned char*)"CCCCCCCCCCCCCCCCCCCC", 20),
 		       btContext.getPieceHash(2));
-  CPPUNIT_ASSERT_EQUAL(string(""),
+  CPPUNIT_ASSERT_EQUAL(std::string(""),
 		       btContext.getPieceHash(-1));
-  CPPUNIT_ASSERT_EQUAL(string(""),
+  CPPUNIT_ASSERT_EQUAL(std::string(""),
 		       btContext.getPieceHash(3));
 }
 
@@ -91,17 +92,17 @@ void DefaultBtContextTest::testGetFileEntries() {
   DefaultBtContext btContext;
   btContext.load("test.torrent");
   // This is multi-file torrent.
-  FileEntries fileEntries = btContext.getFileEntries();
+  std::deque<SharedHandle<FileEntry> > fileEntries = btContext.getFileEntries();
   // There are 2 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntries.size());
-  FileEntries::iterator itr = fileEntries.begin();
+  std::deque<SharedHandle<FileEntry> >::iterator itr = fileEntries.begin();
 
-  FileEntryHandle fileEntry1 = *itr;
-  CPPUNIT_ASSERT_EQUAL(string("aria2/src/aria2c"),
+  SharedHandle<FileEntry> fileEntry1 = *itr;
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2/src/aria2c"),
 		       fileEntry1->getPath());
   itr++;
-  FileEntryHandle fileEntry2 = *itr;
-  CPPUNIT_ASSERT_EQUAL(string("aria2-0.2.2.tar.bz2"),
+  SharedHandle<FileEntry> fileEntry2 = *itr;
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.2.2.tar.bz2"),
 		       fileEntry2->getPath());
 }
 
@@ -109,13 +110,13 @@ void DefaultBtContextTest::testGetFileEntriesSingle() {
   DefaultBtContext btContext;
   btContext.load("single.torrent");
   // This is multi-file torrent.
-  FileEntries fileEntries = btContext.getFileEntries();
+  std::deque<SharedHandle<FileEntry> > fileEntries = btContext.getFileEntries();
   // There is 1 file entry.
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
-  FileEntries::iterator itr = fileEntries.begin();
+  std::deque<SharedHandle<FileEntry> >::iterator itr = fileEntries.begin();
 
-  FileEntryHandle fileEntry1 = *itr;
-  CPPUNIT_ASSERT_EQUAL(string("aria2-0.8.2.tar.bz2"),
+  SharedHandle<FileEntry> fileEntry1 = *itr;
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.8.2.tar.bz2"),
 		       fileEntry1->getPath());
 }
 
@@ -155,7 +156,7 @@ void DefaultBtContextTest::testGetNameMulti() {
   DefaultBtContext btContext;
   btContext.load("test.torrent");
 
-  CPPUNIT_ASSERT_EQUAL(string("aria2-test"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-test"),
 		       btContext.getName());
 }
 
@@ -163,7 +164,7 @@ void DefaultBtContextTest::testGetNameSingle() {
   DefaultBtContext btContext;
   btContext.load("single.torrent");
 
-  CPPUNIT_ASSERT_EQUAL(string("aria2-0.8.2.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.8.2.tar.bz2"),
 		       btContext.getName());
 }
 
@@ -171,17 +172,17 @@ void DefaultBtContextTest::testGetAnnounceTier() {
   DefaultBtContext btContext;
   btContext.load("single.torrent");
 
-  AnnounceTiers tiers = btContext.getAnnounceTiers();
+  std::deque<SharedHandle<AnnounceTier> > tiers = btContext.getAnnounceTiers();
   
   // There is 1 tier.
   CPPUNIT_ASSERT_EQUAL((size_t)1,
 		       tiers.size());
 
-  AnnounceTiers::iterator itr = tiers.begin();
-  AnnounceTierHandle tier1 = *itr;
+  std::deque<SharedHandle<AnnounceTier> >::iterator itr = tiers.begin();
+  SharedHandle<AnnounceTier> tier1 = *itr;
   CPPUNIT_ASSERT_EQUAL((size_t)1,
 		       tier1->urls.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com/announce.php"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/announce.php"),
 		       tier1->urls.at(0));
 
 }
@@ -190,28 +191,28 @@ void DefaultBtContextTest::testGetAnnounceTierAnnounceList() {
   DefaultBtContext btContext;
   btContext.load("test.torrent");
 
-  AnnounceTiers tiers = btContext.getAnnounceTiers();
+  std::deque<SharedHandle<AnnounceTier> > tiers = btContext.getAnnounceTiers();
   
   // There are 3 tiers.
   CPPUNIT_ASSERT_EQUAL((size_t)3,
 		       tiers.size());
 
-  AnnounceTierHandle tier1 = tiers.at(0);
+  SharedHandle<AnnounceTier> tier1 = tiers.at(0);
   CPPUNIT_ASSERT_EQUAL((size_t)1,
 		       tier1->urls.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://tracker1"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://tracker1"),
 		       tier1->urls.at(0));
 
-  AnnounceTierHandle tier2 = tiers.at(1);
+  SharedHandle<AnnounceTier> tier2 = tiers.at(1);
   CPPUNIT_ASSERT_EQUAL((size_t)1,
 		       tier2->urls.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://tracker2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://tracker2"),
 		       tier2->urls.at(0));
 
-  AnnounceTierHandle tier3 = tiers.at(2);
+  SharedHandle<AnnounceTier> tier3 = tiers.at(2);
   CPPUNIT_ASSERT_EQUAL((size_t)1,
 		       tier3->urls.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://tracker3"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://tracker3"),
 		       tier3->urls.at(0));
   
 }
@@ -228,19 +229,19 @@ void DefaultBtContextTest::testGetInfoHashAsString() {
   DefaultBtContext btContext;
   btContext.load("test.torrent");
 
-  CPPUNIT_ASSERT_EQUAL(string("248d0a1cd08284299de78d5c1ed359bb46717d8c"),
+  CPPUNIT_ASSERT_EQUAL(std::string("248d0a1cd08284299de78d5c1ed359bb46717d8c"),
 		       btContext.getInfoHashAsString());
 }
 
 void DefaultBtContextTest::testGetPeerId() {
   DefaultBtContext btContext;
   btContext.setRandomizer(new FixedNumberRandomizer());
-  CPPUNIT_ASSERT_EQUAL(string("%2daria2%2dAAAAAAAAAAAAA"), Util::torrentUrlencode(btContext.getPeerId(), 20));
+  CPPUNIT_ASSERT_EQUAL(std::string("%2daria2%2dAAAAAAAAAAAAA"), Util::torrentUrlencode(btContext.getPeerId(), 20));
 }
 
 void DefaultBtContextTest::testComputeFastSet()
 {
-  string ipaddr = "192.168.0.1";
+  std::string ipaddr = "192.168.0.1";
   unsigned char infoHash[20];
   memset(infoHash, 0, sizeof(infoHash));
   infoHash[0] = 0xff;
@@ -252,17 +253,17 @@ void DefaultBtContextTest::testComputeFastSet()
   btContext.setInfoHash(infoHash);
   btContext.setNumPieces(pieces);
 
-  Integers fastSet = btContext.computeFastSet(ipaddr, fastSetSize);
+  std::deque<int32_t> fastSet = btContext.computeFastSet(ipaddr, fastSetSize);
   //for_each(fastSet.begin(), fastSet.end(), Printer());
   //cerr << endl;
   int ans1[] = { 686, 459, 278, 200, 404, 834, 64, 203, 760, 950 };
-  Integers ansSet1(&ans1[0], &ans1[10]);
+  std::deque<int32_t> ansSet1(&ans1[0], &ans1[10]);
   CPPUNIT_ASSERT(equal(fastSet.begin(), fastSet.end(), ansSet1.begin()));
 
   ipaddr = "10.0.0.1";
   fastSet = btContext.computeFastSet(ipaddr, fastSetSize);
   int ans2[] = { 568, 188, 466, 452, 550, 662, 109, 226, 398, 11 };
-  Integers ansSet2(&ans2[0], &ans2[10]);
+  std::deque<int32_t> ansSet2(&ans2[0], &ans2[10]);
   CPPUNIT_ASSERT(equal(fastSet.begin(), fastSet.end(), ansSet2.begin()));
 }
 
@@ -270,30 +271,30 @@ void DefaultBtContextTest::testGetFileEntries_multiFileUrlList() {
   DefaultBtContext btContext;
   btContext.load("url-list-multiFile.torrent");
   // This is multi-file torrent.
-  FileEntries fileEntries = btContext.getFileEntries();
+  std::deque<SharedHandle<FileEntry> > fileEntries = btContext.getFileEntries();
   // There are 2 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntries.size());
-  FileEntries::iterator itr = fileEntries.begin();
+  std::deque<SharedHandle<FileEntry> >::iterator itr = fileEntries.begin();
 
-  FileEntryHandle fileEntry1 = *itr;
-  CPPUNIT_ASSERT_EQUAL(string("aria2/src/aria2c"),
+  SharedHandle<FileEntry> fileEntry1 = *itr;
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2/src/aria2c"),
 		       fileEntry1->getPath());
-  Strings uris1 = fileEntry1->getAssociatedUris();
+  std::deque<std::string> uris1 = fileEntry1->getAssociatedUris();
   CPPUNIT_ASSERT_EQUAL((size_t)2, uris1.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/dist/aria2-test/aria2/src/aria2c"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/dist/aria2-test/aria2/src/aria2c"),
 		       uris1[0]);
-  CPPUNIT_ASSERT_EQUAL(string("http://mirror/dist/aria2-test/aria2/src/aria2c"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/dist/aria2-test/aria2/src/aria2c"),
 		       uris1[1]);
 
   itr++;
-  FileEntryHandle fileEntry2 = *itr;
-  CPPUNIT_ASSERT_EQUAL(string("aria2-0.2.2.tar.bz2"),
+  SharedHandle<FileEntry> fileEntry2 = *itr;
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.2.2.tar.bz2"),
 		       fileEntry2->getPath());
-  Strings uris2 = fileEntry2->getAssociatedUris();
+  std::deque<std::string> uris2 = fileEntry2->getAssociatedUris();
   CPPUNIT_ASSERT_EQUAL((size_t)2, uris2.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/dist/aria2-test/aria2-0.2.2.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/dist/aria2-test/aria2-0.2.2.tar.bz2"),
 		       uris2[0]);
-  CPPUNIT_ASSERT_EQUAL(string("http://mirror/dist/aria2-test/aria2-0.2.2.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/dist/aria2-test/aria2-0.2.2.tar.bz2"),
 		       uris2[1]);
 }
 
@@ -301,27 +302,27 @@ void DefaultBtContextTest::testGetFileEntries_singleFileUrlList() {
   DefaultBtContext btContext;
   btContext.load("url-list-singleFile.torrent");
   // This is multi-file torrent.
-  FileEntries fileEntries = btContext.getFileEntries();
+  std::deque<SharedHandle<FileEntry> > fileEntries = btContext.getFileEntries();
   // There are 1 file entries.
   CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntries.size());
 
-  FileEntryHandle fileEntry1 = fileEntries.front();
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"),
+  SharedHandle<FileEntry> fileEntry1 = fileEntries.front();
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"),
 		       fileEntry1->getPath());
-  Strings uris1 = fileEntry1->getAssociatedUris();
+  std::deque<std::string> uris1 = fileEntry1->getAssociatedUris();
   CPPUNIT_ASSERT_EQUAL((size_t)1, uris1.size());
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/dist/aria2.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/dist/aria2.tar.bz2"),
 		       uris1[0]);
 }
 
 void DefaultBtContextTest::testLoadFromMemory()
 {
-  string memory = "d8:announce36:http://aria.rednoah.com/announce.php13:announce-listll16:http://tracker1 el15:http://tracker2el15:http://tracker3ee7:comment17:REDNOAH.COM RULES13:creation datei1123456789e4:infod5:filesld6:lengthi284e4:pathl5:aria23:src6:aria2ceed6:lengthi100e4:pathl19:aria2-0.2.2.tar.bz2eee4:name10:aria2-test12:piece lengthi128e6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCee";
+  std::string memory = "d8:announce36:http://aria.rednoah.com/announce.php13:announce-listll16:http://tracker1 el15:http://tracker2el15:http://tracker3ee7:comment17:REDNOAH.COM RULES13:creation datei1123456789e4:infod5:filesld6:lengthi284e4:pathl5:aria23:src6:aria2ceed6:lengthi100e4:pathl19:aria2-0.2.2.tar.bz2eee4:name10:aria2-test12:piece lengthi128e6:pieces60:AAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCee";
 
   DefaultBtContext btContext;
   btContext.loadFromMemory(memory.c_str(), memory.size(), "default");
 
-  string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
+  std::string correctHash = "248d0a1cd08284299de78d5c1ed359bb46717d8c";
 
   CPPUNIT_ASSERT_EQUAL((int32_t)20, btContext.getInfoHashLength());
   CPPUNIT_ASSERT_EQUAL(correctHash, Util::toHex(btContext.getInfoHash(),
@@ -332,12 +333,14 @@ void DefaultBtContextTest::testLoadFromMemory_somethingMissing()
 {
   // pieces missing
   try {
-    string memory = "d8:announce36:http://aria.rednoah.com/announce.php4:infod4:name13:aria2.tar.bz26:lengthi262144eee";
+    std::string memory = "d8:announce36:http://aria.rednoah.com/announce.php4:infod4:name13:aria2.tar.bz26:lengthi262144eee";
     DefaultBtContext btContext;
     btContext.loadFromMemory(memory.c_str(), memory.size(), "default");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc
index ef9b36d5..253b4681 100644
--- a/test/DefaultBtMessageDispatcherTest.cc
+++ b/test/DefaultBtMessageDispatcherTest.cc
@@ -9,9 +9,15 @@
 #include "MockBtMessageFactory.h"
 #include "prefs.h"
 #include "BtCancelSendingPieceEvent.h"
+#include "PeerObject.h"
+#include "BtRequestFactory.h"
+#include "BtMessageReceiver.h"
+#include "ExtensionMessageFactory.h"
+#include "PeerConnection.h"
 #include <cppunit/extensions/HelperMacros.h>
+#include <cassert>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture {
 
@@ -32,11 +38,11 @@ class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testRemoveOutstandingRequest);
   CPPUNIT_TEST_SUITE_END();
 private:
-  BtContextHandle btContext;
-  PeerHandle peer;
-  DefaultBtMessageDispatcherHandle btMessageDispatcher;
-  MockPeerStorageHandle peerStorage;
-  MockPieceStorageHandle pieceStorage;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<Peer> peer;
+  SharedHandle<DefaultBtMessageDispatcher> btMessageDispatcher;
+  SharedHandle<MockPeerStorage> peerStorage;
+  SharedHandle<MockPieceStorage> pieceStorage;
 public:
   DefaultBtMessageDispatcherTest():btContext(0), peer(0), btMessageDispatcher(0) {}
 
@@ -63,7 +69,7 @@ public:
     bool sendCalled;
     bool doCancelActionCalled;
   public:
-    string type;
+    std::string type;
   public:
     MockBtMessage2():onQueuedCalled(false),
 		     sendCalled(false),
@@ -88,7 +94,7 @@ public:
       return sendCalled;
     }
 
-    virtual void handleEvent(const BtEventHandle& event) {
+    virtual void handleEvent(const SharedHandle<BtEvent>& event) {
       BtCancelSendingPieceEvent* e =
 	dynamic_cast<BtCancelSendingPieceEvent*>(event.get());
       if(e) {
@@ -101,26 +107,24 @@ public:
     }  
   };
 
-  typedef SharedHandle<MockBtMessage2> MockBtMessage2Handle;
-
   class MockPieceStorage2 : public MockPieceStorage {
   private:
-    PieceHandle piece;
+    SharedHandle<Piece> piece;
   public:
-    virtual PieceHandle getPiece(int index) {
+    virtual SharedHandle<Piece> getPiece(int index) {
       return piece;
     }
 
-    void setPiece(const PieceHandle& piece) {
+    void setPiece(const SharedHandle<Piece>& piece) {
       this->piece = piece;
     }
   };
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual BtMessageHandle
+    virtual SharedHandle<BtMessage>
     createCancelMessage(int32_t index, int32_t begin, int32_t length) {
-      MockBtMessage2Handle btMsg = new MockBtMessage2();
+      SharedHandle<MockBtMessage2> btMsg = new MockBtMessage2();
       btMsg->type = "cancel";
       return btMsg;
     }
@@ -140,7 +144,7 @@ public:
     BtRegistry::registerPeerObjectCluster(btContext->getInfoHashAsString(),
 					  new PeerObjectCluster());
 
-    PeerObjectHandle peerObject = new PeerObject();
+    SharedHandle<PeerObject> peerObject = new PeerObject();
     peerObject->btMessageFactory = new MockBtMessageFactory2();
 
     PEER_OBJECT_CLUSTER(btContext)->registerHandle(peer->getId(), peerObject);
@@ -158,7 +162,7 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtMessageDispatcherTest);
 
 void DefaultBtMessageDispatcherTest::testAddMessage() {
-  MockBtMessage2Handle msg = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg = new MockBtMessage2();
   CPPUNIT_ASSERT_EQUAL(false, msg->isOnQueuedCalled());
   btMessageDispatcher->addMessageToQueue(msg);
   CPPUNIT_ASSERT_EQUAL(true, msg->isOnQueuedCalled());
@@ -171,10 +175,10 @@ void DefaultBtMessageDispatcherTest::testSendMessages() {
   stat.setUploadSpeed(0);
   peerStorage->setStat(stat);
 
-  MockBtMessage2Handle msg1 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg1 = new MockBtMessage2();
   msg1->setSendingInProgress(false);
   msg1->setUploading(false);
-  MockBtMessage2Handle msg2 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg2 = new MockBtMessage2();
   msg2->setSendingInProgress(false);
   msg2->setUploading(false);
   btMessageDispatcher->addMessageToQueue(msg1);
@@ -190,10 +194,10 @@ void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
   stat.setUploadSpeed(0);
   peerStorage->setStat(stat);
 
-  MockBtMessage2Handle msg1 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg1 = new MockBtMessage2();
   msg1->setSendingInProgress(false);
   msg1->setUploading(true);
-  MockBtMessage2Handle msg2 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg2 = new MockBtMessage2();
   msg2->setSendingInProgress(false);
   msg2->setUploading(true);
   btMessageDispatcher->addMessageToQueue(msg1);
@@ -210,13 +214,13 @@ void DefaultBtMessageDispatcherTest::testSendMessages_overUploadLimit() {
   stat.setUploadSpeed(150);
   peerStorage->setStat(stat);
 
-  MockBtMessage2Handle msg1 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg1 = new MockBtMessage2();
   msg1->setSendingInProgress(false);
   msg1->setUploading(true);
-  MockBtMessage2Handle msg2 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg2 = new MockBtMessage2();
   msg2->setSendingInProgress(false);
   msg2->setUploading(true);
-  MockBtMessage2Handle msg3 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg3 = new MockBtMessage2();
   msg3->setSendingInProgress(false);
   msg3->setUploading(false);
 
@@ -233,13 +237,13 @@ void DefaultBtMessageDispatcherTest::testSendMessages_overUploadLimit() {
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages_sendingInProgress() {
-  MockBtMessage2Handle msg1 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg1 = new MockBtMessage2();
   msg1->setSendingInProgress(false);
   msg1->setUploading(false);
-  MockBtMessage2Handle msg2 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg2 = new MockBtMessage2();
   msg2->setSendingInProgress(true);
   msg2->setUploading(false);
-  MockBtMessage2Handle msg3 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg3 = new MockBtMessage2();
   msg3->setSendingInProgress(false);
   msg3->setUploading(false);
 
@@ -257,8 +261,8 @@ void DefaultBtMessageDispatcherTest::testSendMessages_sendingInProgress() {
 }
 
 void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction() {
-  MockBtMessage2Handle msg1 = new MockBtMessage2();
-  MockBtMessage2Handle msg2 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg1 = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg2 = new MockBtMessage2();
 
   btMessageDispatcher->addMessageToQueue(msg1);
   btMessageDispatcher->addMessageToQueue(msg2);
@@ -274,7 +278,7 @@ int MY_PIECE_LENGTH = 16*1024;
 void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
   
-  PieceHandle piece = new Piece(0, MY_PIECE_LENGTH);
+  SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
   assert(piece->getMissingUnusedBlockIndex() == 0);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
@@ -301,7 +305,7 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
   // make this slot timeout
   slot.setDispatchedTime(0);
 
-  PieceHandle piece = new Piece(0, MY_PIECE_LENGTH);
+  SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
   assert(piece->getMissingUnusedBlockIndex() == 0);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
@@ -330,7 +334,7 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_tim
 void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_completeBlock() {
   RequestSlot slot(0, 0, MY_PIECE_LENGTH, 0);
   
-  PieceHandle piece = new Piece(0, MY_PIECE_LENGTH);
+  SharedHandle<Piece> piece = new Piece(0, MY_PIECE_LENGTH);
   piece->completeBlock(0);
 
   SharedHandle<MockPieceStorage2> pieceStorage = new MockPieceStorage2();
@@ -357,7 +361,7 @@ void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing_com
 
 void DefaultBtMessageDispatcherTest::testIsSendingInProgress() {
   CPPUNIT_ASSERT(!btMessageDispatcher->isSendingInProgress());
-  MockBtMessage2Handle msg = new MockBtMessage2();
+  SharedHandle<MockBtMessage2> msg = new MockBtMessage2();
   msg->setSendingInProgress(false);
   btMessageDispatcher->addMessageToQueue(msg);
   CPPUNIT_ASSERT(!btMessageDispatcher->isSendingInProgress());
@@ -410,3 +414,5 @@ void DefaultBtMessageDispatcherTest::testRemoveOutstandingRequest() {
   RequestSlot s3 = btMessageDispatcher->getOutstandingRequest(1, 1024, 16*1024);
   CPPUNIT_ASSERT(RequestSlot::isNull(s3));  
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtMessageFactoryTest.cc b/test/DefaultBtMessageFactoryTest.cc
index 5b7660cb..3268b400 100644
--- a/test/DefaultBtMessageFactoryTest.cc
+++ b/test/DefaultBtMessageFactoryTest.cc
@@ -6,8 +6,18 @@
 #include "MockExtensionMessageFactory.h"
 #include "BtExtendedMessage.h"
 #include "BtPortMessage.h"
+#include "PeerObject.h"
+#include "BtRequestFactory.h"
+#include "BtMessageDispatcher.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "Exception.h"
+#include "FileEntry.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DefaultBtMessageFactoryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DefaultBtMessageFactoryTest);
@@ -15,15 +25,15 @@ class DefaultBtMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreatePortMessage);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MockBtContextHandle _btContext;
-  PeerHandle _peer;
+  SharedHandle<MockBtContext> _btContext;
+  SharedHandle<Peer> _peer;
 public:
   DefaultBtMessageFactoryTest():_btContext(0), _peer(0) {}
 
   void setUp()
   {
     BtRegistry::unregisterAll();
-    MockBtContextHandle btContext = new MockBtContext();
+    SharedHandle<MockBtContext> btContext = new MockBtContext();
     unsigned char infohash[20];
     memset(infohash, 0, sizeof(infohash));
     btContext->setInfoHash(infohash);
@@ -32,10 +42,11 @@ public:
     _peer = new Peer("192.168.0.1", 6969);
     _peer->setExtendedMessagingEnabled(true);
 
-    MockExtensionMessageFactoryHandle exmsgFactory = new MockExtensionMessageFactory();
+    SharedHandle<MockExtensionMessageFactory> exmsgFactory =
+      new MockExtensionMessageFactory();
     BtRegistry::registerPeerObjectCluster(_btContext->getInfoHashAsString(),
 					  new PeerObjectCluster());
-    PeerObjectHandle peerObject = new PeerObject();
+    SharedHandle<PeerObject> peerObject = new PeerObject();
     peerObject->extensionMessageFactory = exmsgFactory;
 
     PEER_OBJECT_CLUSTER(_btContext)->registerHandle(_peer->getId(), peerObject);
@@ -61,13 +72,14 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage()
   factory.setPeer(_peer);
   
   // payload:{4:name3:foo}->11bytes
-  string payload = "4:name3:foo";
+  std::string payload = "4:name3:foo";
   char msg[17];// 6+11bytes
   PeerMessageUtil::createPeerMessageString((unsigned char*)msg, sizeof(msg), 13, 20);
   msg[5] = 1; // Set dummy extended message ID 1
   memcpy(msg+6, payload.c_str(), payload.size());
   
-  BtExtendedMessageHandle m = factory.createBtMessage((const unsigned char*)msg+4, sizeof(msg));
+  SharedHandle<BtExtendedMessage> m =
+    factory.createBtMessage((const unsigned char*)msg+4, sizeof(msg));
 
   try {
     // disable extended messaging
@@ -75,7 +87,7 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage()
     factory.createBtMessage((const unsigned char*)msg+4, sizeof(msg));
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
@@ -95,8 +107,8 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
       CPPUNIT_ASSERT(!m.isNull());
       CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
     } catch(Exception* e) {
-      cerr << *e << endl;
-      string msg = e->getMsg();
+      std::cerr << *e << std::endl;
+      std::string msg = e->getMsg();
       delete e;
       CPPUNIT_FAIL(msg);
     }
@@ -106,3 +118,5 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
   }
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc
index d87c739e..f2cfa9cd 100644
--- a/test/DefaultBtProgressInfoFileTest.cc
+++ b/test/DefaultBtProgressInfoFileTest.cc
@@ -10,12 +10,11 @@
 #include "prefs.h"
 #include "SingleFileDownloadContext.h"
 #include "Piece.h"
-#include "AnnounceTier.h"
+#include "FileEntry.h"
 #include <fstream>
-#include <iomanip>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultBtProgressInfoFileTest:public CppUnit::TestFixture {
 
@@ -27,8 +26,8 @@ class DefaultBtProgressInfoFileTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testLoad_nonBt_pieceLengthShorter);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MockBtContextHandle _btContext;
-  MockPieceStorageHandle _pieceStorage;
+  SharedHandle<MockBtContext> _btContext;
+  SharedHandle<MockPieceStorage> _pieceStorage;
   SharedHandle<Option> _option;
   SharedHandle<BitfieldMan> _bitfield;
 public:
@@ -56,9 +55,9 @@ public:
     _pieceStorage = new MockPieceStorage();
     _pieceStorage->setBitfield(_bitfield.get());
 
-    MockPeerStorageHandle peerStorage = new MockPeerStorage();
+    SharedHandle<MockPeerStorage> peerStorage = new MockPeerStorage();
 
-    BtRuntimeHandle btRuntime = new BtRuntime();
+    SharedHandle<BtRuntime> btRuntime = new BtRuntime();
 
     BtRegistry::registerBtContext(_btContext->getInfoHashAsString(),
 				  _btContext);
@@ -97,7 +96,7 @@ void DefaultBtProgressInfoFileTest::testLoad()
   _btContext->setNumPieces(80);
 
   DefaultBtProgressInfoFile infoFile(_btContext, _pieceStorage, _option.get());
-  CPPUNIT_ASSERT_EQUAL(string("./load.aria2"), infoFile.getFilename());
+  CPPUNIT_ASSERT_EQUAL(std::string("./load.aria2"), infoFile.getFilename());
 
   infoFile.load();
 
@@ -107,7 +106,7 @@ void DefaultBtProgressInfoFileTest::testLoad()
   CPPUNIT_ASSERT_EQUAL((int64_t)1024, BT_RUNTIME(_btContext)->getUploadLengthAtStartup());
 
   // bitfield
-  CPPUNIT_ASSERT_EQUAL(string("fffffffffffffffffffe"),
+  CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
@@ -115,16 +114,16 @@ void DefaultBtProgressInfoFileTest::testLoad()
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  Pieces inFlightPieces = _pieceStorage->getInFlightPieces();
-  PieceHandle piece1 = inFlightPieces[0];
+  std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
+  SharedHandle<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
-  CPPUNIT_ASSERT_EQUAL(string("00"), Util::toHex(piece1->getBitfield(),
+  CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
-  PieceHandle piece2 = inFlightPieces[1];
+  SharedHandle<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
 }
@@ -133,17 +132,17 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
 {
   initializeMembers(1024, 81920);
 
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(1024, 81920, "load-nonBt");
   
   DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get());
-  CPPUNIT_ASSERT_EQUAL(string("./load-nonBt.aria2"), infoFile.getFilename());
+  CPPUNIT_ASSERT_EQUAL(std::string("./load-nonBt.aria2"), infoFile.getFilename());
   infoFile.load();
 
   // check the contents of objects
 
   // bitfield
-  CPPUNIT_ASSERT_EQUAL(string("fffffffffffffffffffe"),
+  CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
@@ -151,16 +150,16 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt()
 		       _pieceStorage->countInFlightPiece());
 
   // piece index 1
-  Pieces inFlightPieces = _pieceStorage->getInFlightPieces();
-  PieceHandle piece1 = inFlightPieces[0];
+  std::deque<SharedHandle<Piece> > inFlightPieces = _pieceStorage->getInFlightPieces();
+  SharedHandle<Piece> piece1 = inFlightPieces[0];
   CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)1024, piece1->getLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, piece1->getBitfieldLength());
-  CPPUNIT_ASSERT_EQUAL(string("00"), Util::toHex(piece1->getBitfield(),
+  CPPUNIT_ASSERT_EQUAL(std::string("00"), Util::toHex(piece1->getBitfield(),
 						 piece1->getBitfieldLength()));
 
   // piece index 2
-  PieceHandle piece2 = inFlightPieces[1];
+  SharedHandle<Piece> piece2 = inFlightPieces[1];
   CPPUNIT_ASSERT_EQUAL((int32_t)2, piece2->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)512, piece2->getLength());
 
@@ -171,17 +170,17 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter()
   initializeMembers(512, 81920);
   _option->put(PREF_ALLOW_PIECE_LENGTH_CHANGE, V_TRUE);
 
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(512, 81920, "load-nonBt");
 
   DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get());
-  CPPUNIT_ASSERT_EQUAL(string("./load-nonBt.aria2"), infoFile.getFilename());
+  CPPUNIT_ASSERT_EQUAL(std::string("./load-nonBt.aria2"), infoFile.getFilename());
   infoFile.load();
 
   // check the contents of objects
 
   // bitfield
-  CPPUNIT_ASSERT_EQUAL(string("fffffffffffffffffffffffffffffffffffffffc"),
+  CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffffffffffffffffffffffc"),
 		       Util::toHex(_bitfield->getBitfield(), _bitfield->getBitfieldLength()));
 
   // the number of in-flight pieces
@@ -193,37 +192,37 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 {
   initializeMembers(1024, 81920);
 
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(1024, 81920, "save-temp");
 
   _bitfield->setAllBit();
   _bitfield->unsetBit(79);
   _pieceStorage->setCompletedLength(80896);
 
-  PieceHandle p1 = new Piece(1, 1024);
-  PieceHandle p2 = new Piece(2, 512);
-  Pieces inFlightPieces;
+  SharedHandle<Piece> p1 = new Piece(1, 1024);
+  SharedHandle<Piece> p2 = new Piece(2, 512);
+  std::deque<SharedHandle<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   _pieceStorage->addInFlightPiece(inFlightPieces);
   
   DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get());
-  CPPUNIT_ASSERT_EQUAL(string("./save-temp.aria2"), infoFile.getFilename());
+  CPPUNIT_ASSERT_EQUAL(std::string("./save-temp.aria2"), infoFile.getFilename());
 
   infoFile.save();
   
   // read and validate
-  ifstream in(infoFile.getFilename().c_str());
+  std::ifstream in(infoFile.getFilename().c_str());
 
   //in.exceptions(ios::failbit);
 
   unsigned char version[2];
   in.read((char*)version, sizeof(version));
-  CPPUNIT_ASSERT_EQUAL(string("0000"), Util::toHex(version, sizeof(version)));
+  CPPUNIT_ASSERT_EQUAL(std::string("0000"), Util::toHex(version, sizeof(version)));
 
   unsigned char extension[4];
   in.read((char*)extension, sizeof(extension));
-  CPPUNIT_ASSERT_EQUAL(string("00000000"), Util::toHex(extension, sizeof(extension)));
+  CPPUNIT_ASSERT_EQUAL(std::string("00000000"), Util::toHex(extension, sizeof(extension)));
 
   int32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
@@ -247,7 +246,7 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
-  CPPUNIT_ASSERT_EQUAL(string("fffffffffffffffffffe"),
+  CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
   int32_t numInFlightPiece;
@@ -269,7 +268,7 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt()
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
-  CPPUNIT_ASSERT_EQUAL(string("00"),
+  CPPUNIT_ASSERT_EQUAL(std::string("00"),
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
@@ -295,32 +294,32 @@ void DefaultBtProgressInfoFileTest::testSave()
   _pieceStorage->setCompletedLength(80896);
   TransferStat stat;
   stat.setAllTimeUploadLength(1024);
-  MockPeerStorageHandle(PEER_STORAGE(_btContext))->setStat(stat);
+  SharedHandle<MockPeerStorage>(PEER_STORAGE(_btContext))->setStat(stat);
 
-  PieceHandle p1 = new Piece(1, 1024);
-  PieceHandle p2 = new Piece(2, 512);
-  Pieces inFlightPieces;
+  SharedHandle<Piece> p1 = new Piece(1, 1024);
+  SharedHandle<Piece> p2 = new Piece(2, 512);
+  std::deque<SharedHandle<Piece> > inFlightPieces;
   inFlightPieces.push_back(p1);
   inFlightPieces.push_back(p2);
   _pieceStorage->addInFlightPiece(inFlightPieces);
   
   DefaultBtProgressInfoFile infoFile(_btContext, _pieceStorage, _option.get());
-  CPPUNIT_ASSERT_EQUAL(string("./save-temp.aria2"), infoFile.getFilename());
+  CPPUNIT_ASSERT_EQUAL(std::string("./save-temp.aria2"), infoFile.getFilename());
 
   infoFile.save();
 
   // read and validate
-  ifstream in(infoFile.getFilename().c_str());
+  std::ifstream in(infoFile.getFilename().c_str());
 
   //in.exceptions(ios::failbit);
 
   unsigned char version[2];
   in.read((char*)version, sizeof(version));
-  CPPUNIT_ASSERT_EQUAL(string("0000"), Util::toHex(version, sizeof(version)));
+  CPPUNIT_ASSERT_EQUAL(std::string("0000"), Util::toHex(version, sizeof(version)));
 
   unsigned char extension[4];
   in.read((char*)extension, sizeof(extension));
-  CPPUNIT_ASSERT_EQUAL(string("00000001"), Util::toHex(extension, sizeof(extension)));
+  CPPUNIT_ASSERT_EQUAL(std::string("00000001"), Util::toHex(extension, sizeof(extension)));
 
   int32_t infoHashLength;
   in.read(reinterpret_cast<char*>(&infoHashLength), sizeof(infoHashLength));
@@ -328,7 +327,7 @@ void DefaultBtProgressInfoFileTest::testSave()
 
   unsigned char infoHashRead[20];
   in.read((char*)infoHashRead, sizeof(infoHashRead));
-  CPPUNIT_ASSERT_EQUAL(string("112233445566778899aabbccddeeff00ffffffff"),
+  CPPUNIT_ASSERT_EQUAL(std::string("112233445566778899aabbccddeeff00ffffffff"),
 		       Util::toHex(infoHashRead, sizeof(infoHashRead)));
 
   int32_t pieceLength;
@@ -349,7 +348,7 @@ void DefaultBtProgressInfoFileTest::testSave()
 
   unsigned char bitfieldRead[10];
   in.read((char*)bitfieldRead, sizeof(bitfieldRead));
-  CPPUNIT_ASSERT_EQUAL(string("fffffffffffffffffffe"),
+  CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),
 		       Util::toHex(bitfieldRead, sizeof(bitfieldRead)));
 
   int32_t numInFlightPiece;
@@ -371,7 +370,7 @@ void DefaultBtProgressInfoFileTest::testSave()
 
   unsigned char pieceBitfield1[1];
   in.read((char*)pieceBitfield1, sizeof(pieceBitfield1));
-  CPPUNIT_ASSERT_EQUAL(string("00"),
+  CPPUNIT_ASSERT_EQUAL(std::string("00"),
 		       Util::toHex(pieceBitfield1, sizeof(pieceBitfield1)));
 
   // piece index 2
@@ -385,3 +384,5 @@ void DefaultBtProgressInfoFileTest::testSave()
 
 
 }
+
+} // namespace aria2
diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc
index 33910d56..c53b5dec 100644
--- a/test/DefaultBtRequestFactoryTest.cc
+++ b/test/DefaultBtRequestFactoryTest.cc
@@ -5,9 +5,16 @@
 #include "MockBtContext.h"
 #include "BtRegistry.h"
 #include "MockPieceStorage.h"
+#include "Peer.h"
+#include "PeerObject.h"
+#include "BtMessageReceiver.h"
+#include "PeerConnection.h"
+#include "ExtensionMessageFactory.h"
+#include "FileEntry.h"
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultBtRequestFactoryTest:public CppUnit::TestFixture {
 
@@ -19,8 +26,8 @@ class DefaultBtRequestFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testRemoveTargetPiece);
   CPPUNIT_TEST_SUITE_END();
 private:
-  DefaultBtRequestFactoryHandle btRequestFactory;
-  MockBtContextHandle btContext;
+  SharedHandle<DefaultBtRequestFactory> btRequestFactory;
+  SharedHandle<MockBtContext> btContext;
 public:
   DefaultBtRequestFactoryTest():btRequestFactory(0), btContext(0) {}
 
@@ -42,8 +49,8 @@ public:
   
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual BtMessageHandle
-    createRequestMessage(const PieceHandle& piece, int32_t blockIndex) {
+    virtual SharedHandle<BtMessage>
+    createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex) {
       return new MockBtRequestMessage(piece->getIndex(), blockIndex);
     }
   };
@@ -84,11 +91,11 @@ public:
     BtRegistry::registerPieceStorage(btContext->getInfoHashAsString(),
 				     new MockPieceStorage());
 
-    PeerHandle peer = new Peer("host", 6969);
+    SharedHandle<Peer> peer = new Peer("host", 6969);
 
     BtRegistry::registerPeerObjectCluster(btContext->getInfoHashAsString(),
 					  new PeerObjectCluster());
-    PeerObjectHandle peerObject = new PeerObject();
+    SharedHandle<PeerObject> peerObject = new PeerObject();
     peerObject->btMessageFactory = new MockBtMessageFactory2();
     PEER_OBJECT_CLUSTER(btContext)->registerHandle(peer->getId(), peerObject);
 
@@ -105,14 +112,14 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest);
 
 void DefaultBtRequestFactoryTest::testAddTargetPiece() {
-  PieceHandle piece = new Piece(0, 16*1024);
+  SharedHandle<Piece> piece = new Piece(0, 16*1024);
   btRequestFactory->addTargetPiece(piece);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, btRequestFactory->countTargetPiece());
 }
 
 void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
-  PieceHandle piece1 = new Piece(0, 16*1024);
-  PieceHandle piece2 = new Piece(1, 16*1024);
+  SharedHandle<Piece> piece1 = new Piece(0, 16*1024);
+  SharedHandle<Piece> piece2 = new Piece(1, 16*1024);
   piece2->setAllBlock();
   btRequestFactory->addTargetPiece(piece1);
   btRequestFactory->addTargetPiece(piece2);
@@ -124,15 +131,15 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
 
 void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
   int PIECE_LENGTH = 16*1024*2;
-  PieceHandle piece1 = new Piece(0, PIECE_LENGTH);
-  PieceHandle piece2 = new Piece(1, PIECE_LENGTH);
+  SharedHandle<Piece> piece1 = new Piece(0, PIECE_LENGTH);
+  SharedHandle<Piece> piece2 = new Piece(1, PIECE_LENGTH);
   btRequestFactory->addTargetPiece(piece1);
   btRequestFactory->addTargetPiece(piece2);
 
-  BtMessages msgs = btRequestFactory->createRequestMessages(3);
+  std::deque<SharedHandle<BtMessage> > msgs = btRequestFactory->createRequestMessages(3);
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  BtMessages::iterator itr = msgs.begin();
+  std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
   CPPUNIT_ASSERT_EQUAL(0, msg->index);
   CPPUNIT_ASSERT_EQUAL(0, msg->blockIndex);
@@ -154,17 +161,17 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
   btRequestFactory->setBtMessageDispatcher(dispatcher);
 
   int PIECE_LENGTH = 16*1024*2;
-  PieceHandle piece1 = new Piece(0, PIECE_LENGTH);
-  PieceHandle piece2 = new Piece(1, PIECE_LENGTH);
+  SharedHandle<Piece> piece1 = new Piece(0, PIECE_LENGTH);
+  SharedHandle<Piece> piece2 = new Piece(1, PIECE_LENGTH);
   btRequestFactory->addTargetPiece(piece1);
   btRequestFactory->addTargetPiece(piece2);
 
-  BtMessages msgs = btRequestFactory->createRequestMessagesOnEndGame(3);
+  std::deque<SharedHandle<BtMessage> > msgs = btRequestFactory->createRequestMessagesOnEndGame(3);
 
-  sort(msgs.begin(), msgs.end(), SortMockBtRequestMessage());
+  std::sort(msgs.begin(), msgs.end(), SortMockBtRequestMessage());
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  BtMessages::iterator itr = msgs.begin();
+  std::deque<SharedHandle<BtMessage> >::iterator itr = msgs.begin();
   MockBtRequestMessage* msg = (MockBtRequestMessage*)itr->get();
   CPPUNIT_ASSERT_EQUAL(0, msg->index);
   CPPUNIT_ASSERT_EQUAL(1, msg->blockIndex);
@@ -179,17 +186,19 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
 }
 
 void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
-  PieceHandle piece1 = new Piece(0, 16*1024);
+  SharedHandle<Piece> piece1 = new Piece(0, 16*1024);
 
   btRequestFactory->addTargetPiece(piece1);
 
-  CPPUNIT_ASSERT(find(btRequestFactory->getTargetPieces().begin(),
-		      btRequestFactory->getTargetPieces().end(),
-		      piece1) != btRequestFactory->getTargetPieces().end());
+  CPPUNIT_ASSERT(std::find(btRequestFactory->getTargetPieces().begin(),
+			   btRequestFactory->getTargetPieces().end(),
+			   piece1) != btRequestFactory->getTargetPieces().end());
 
   btRequestFactory->removeTargetPiece(piece1);
 
-  CPPUNIT_ASSERT(find(btRequestFactory->getTargetPieces().begin(),
-		      btRequestFactory->getTargetPieces().end(),
-		      piece1) == btRequestFactory->getTargetPieces().end());
+  CPPUNIT_ASSERT(std::find(btRequestFactory->getTargetPieces().begin(),
+			   btRequestFactory->getTargetPieces().end(),
+			   piece1) == btRequestFactory->getTargetPieces().end());
 }
+
+} // namespace aria2
diff --git a/test/DefaultDiskWriterTest.cc b/test/DefaultDiskWriterTest.cc
index 417810b2..d9a93ab8 100644
--- a/test/DefaultDiskWriterTest.cc
+++ b/test/DefaultDiskWriterTest.cc
@@ -1,7 +1,7 @@
 #include "DefaultDiskWriter.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultDiskWriterTest:public CppUnit::TestFixture {
 
@@ -27,3 +27,4 @@ void DefaultDiskWriterTest::testSize()
   CPPUNIT_ASSERT_EQUAL((int64_t)4096, dw.size());
 }
 
+} // namespace aria2
diff --git a/test/DefaultExtensionMessageFactoryTest.cc b/test/DefaultExtensionMessageFactoryTest.cc
index da9d89ab..e9d310fc 100644
--- a/test/DefaultExtensionMessageFactoryTest.cc
+++ b/test/DefaultExtensionMessageFactoryTest.cc
@@ -7,8 +7,11 @@
 #include "Exception.h"
 #include "BtRegistry.h"
 #include "BtRuntime.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DefaultExtensionMessageFactoryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DefaultExtensionMessageFactoryTest);
@@ -17,21 +20,21 @@ class DefaultExtensionMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreateMessage_UTPex);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MockBtContextHandle _btContext;
-  PeerHandle _peer;
+  SharedHandle<MockBtContext> _btContext;
+  SharedHandle<Peer> _peer;
 public:
   DefaultExtensionMessageFactoryTest():_btContext(0), _peer(0) {}
 
   void setUp()
   {
     BtRegistry::unregisterAll();
-    MockBtContextHandle btContext = new MockBtContext();
+    SharedHandle<MockBtContext> btContext = new MockBtContext();
     unsigned char infohash[20];
     memset(infohash, 0, sizeof(infohash));
     btContext->setInfoHash(infohash);
     _btContext = btContext;
 
-    BtRuntimeHandle btRuntime = new BtRuntime();
+    SharedHandle<BtRuntime> btRuntime = new BtRuntime();
     BtRegistry::registerBtRuntime(_btContext->getInfoHashAsString(),
 				  btRuntime);
 
@@ -61,13 +64,13 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_unknown()
 
   char id[1] = { 255 };
 
-  string data = string(&id[0], &id[1]);
+  std::string data = std::string(&id[0], &id[1]);
   try {
     // this test fails because localhost doesn't have extension id = 255.
     factory.createMessage(data.c_str(), data.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
@@ -80,9 +83,10 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_Handshake()
 
   char id[1] = { 0 };
 
-  string data = string(&id[0], &id[1])+"d1:v5:aria2e";
-  HandshakeExtensionMessageHandle m = factory.createMessage(data.c_str(), data.size());
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), m->getClientVersion());
+  std::string data = std::string(&id[0], &id[1])+"d1:v5:aria2e";
+  SharedHandle<HandshakeExtensionMessage> m =
+    factory.createMessage(data.c_str(), data.size());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), m->getClientVersion());
 }
 
 void DefaultExtensionMessageFactoryTest::testCreateMessage_UTPex()
@@ -102,13 +106,16 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTPex()
 
   char id[1] = { factory.getExtensionMessageID("ut_pex") };
 
-  string data = string(&id[0], &id[1])+"d5:added12:"+
-    string(&c1[0], &c1[6])+string(&c2[0], &c2[6])+
+  std::string data = std::string(&id[0], &id[1])+"d5:added12:"+
+    std::string(&c1[0], &c1[6])+std::string(&c2[0], &c2[6])+
     "7:added.f2:207:dropped12:"+
-    string(&c3[0], &c3[6])+string(&c4[0], &c4[6])+
+    std::string(&c3[0], &c3[6])+std::string(&c4[0], &c4[6])+
     "e";
 
-  UTPexExtensionMessageHandle m = factory.createMessage(data.c_str(), data.size());
+  SharedHandle<UTPexExtensionMessage> m =
+    factory.createMessage(data.c_str(), data.size());
   CPPUNIT_ASSERT_EQUAL(factory.getExtensionMessageID("ut_pex"),
 		       m->getExtensionMessageID());
 }
+
+} // namespace aria2
diff --git a/test/DefaultPeerListProcessorTest.cc b/test/DefaultPeerListProcessorTest.cc
index 9942a19f..9a6e4638 100644
--- a/test/DefaultPeerListProcessorTest.cc
+++ b/test/DefaultPeerListProcessorTest.cc
@@ -1,9 +1,11 @@
 #include "DefaultPeerListProcessor.h"
 #include "MetaFileUtil.h"
 #include "Exception.h"
+#include "Dictionary.h"
+#include "Peer.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultPeerListProcessorTest:public CppUnit::TestFixture {
 
@@ -26,32 +28,34 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DefaultPeerListProcessorTest );
 
 void DefaultPeerListProcessorTest::testExtractPeer() {
   DefaultPeerListProcessor proc(1024*1024, 10*1024*1024);
-  string peersString = "d5:peersld2:ip11:192.168.0.17:peer id20:aria2-000000000000004:porti2006eeee";
+  std::string peersString = "d5:peersld2:ip11:192.168.0.17:peer id20:aria2-000000000000004:porti2006eeee";
 
   Dictionary* dic = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
   
   CPPUNIT_ASSERT(proc.canHandle(dic->get("peers")));
 
-  Peers peers = proc.extractPeer(dic->get("peers"));
+  std::deque<SharedHandle<Peer> > peers = proc.extractPeer(dic->get("peers"));
   CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
-  PeerHandle peer = *peers.begin();
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peer->ipaddr);
+  SharedHandle<Peer> peer = *peers.begin();
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)2006, peer->port);
 }
 
 void DefaultPeerListProcessorTest::testExtract2Peers() {
   DefaultPeerListProcessor proc(1024*1024, 10*1024*1024);
-  string peersString = "d5:peersld2:ip11:192.168.0.17:peer id20:aria2-000000000000004:porti2006eed2:ip11:192.168.0.27:peer id20:aria2-000000000000004:porti2007eeee";
+  std::string peersString = "d5:peersld2:ip11:192.168.0.17:peer id20:aria2-000000000000004:porti2006eed2:ip11:192.168.0.27:peer id20:aria2-000000000000004:porti2007eeee";
 
   Dictionary* dic = (Dictionary*)MetaFileUtil::bdecoding(peersString.c_str(), peersString.size());
 
-  Peers peers = proc.extractPeer(dic->get("peers"));
+  std::deque<SharedHandle<Peer> > peers = proc.extractPeer(dic->get("peers"));
   CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size());
-  PeerHandle peer = *peers.begin();
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peer->ipaddr);
+  SharedHandle<Peer> peer = *peers.begin();
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)2006, peer->port);
 
   peer = *(peers.begin()+1);
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), peer->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), peer->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)2007, peer->port);
 }
+
+} // namespace aria2
diff --git a/test/DefaultPeerStorageTest.cc b/test/DefaultPeerStorageTest.cc
index fe12d34a..b2874d8c 100644
--- a/test/DefaultPeerStorageTest.cc
+++ b/test/DefaultPeerStorageTest.cc
@@ -2,9 +2,13 @@
 #include "DefaultBtContext.h"
 #include "Util.h"
 #include "Exception.h"
+#include "Peer.h"
+#include "Option.h"
+#include "BtRuntime.h"
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultPeerStorageTest:public CppUnit::TestFixture {
 
@@ -20,17 +24,17 @@ class DefaultPeerStorageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testOnErasingPeer);
   CPPUNIT_TEST_SUITE_END();
 private:
-  BtContextHandle btContext;
-  BtRuntimeHandle btRuntime;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<BtRuntime> btRuntime;
   Option* option;
 public:
   DefaultPeerStorageTest():btContext(0) {}
 
   void setUp() {
-    btContext = BtContextHandle(new DefaultBtContext());
+    btContext = new DefaultBtContext();
     btContext->load("test.torrent");
     option = new Option();
-    btRuntime = BtRuntimeHandle(new BtRuntime());
+    btRuntime = SharedHandle<BtRuntime>(new BtRuntime());
   }
 
   void testCountPeer();
@@ -53,7 +57,7 @@ void DefaultPeerStorageTest::testCountPeer() {
   CPPUNIT_ASSERT_EQUAL((int32_t)0,
 		       ps.countPeer());
 
-  PeerHandle peer(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer(new Peer("192.168.0.1", 6889));
 
   ps.addPeer(peer);
   CPPUNIT_ASSERT_EQUAL((int32_t)1,
@@ -63,9 +67,9 @@ void DefaultPeerStorageTest::testCountPeer() {
 void DefaultPeerStorageTest::testDeleteUnusedPeer() {
   DefaultPeerStorage ps(btContext, option);
 
-  PeerHandle peer1(new Peer("192.168.0.1", 6889));
-  PeerHandle peer2(new Peer("192.168.0.2", 6889));
-  PeerHandle peer3(new Peer("192.168.0.3", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer2(new Peer("192.168.0.2", 6889));
+  SharedHandle<Peer> peer3(new Peer("192.168.0.3", 6889));
 
   ps.addPeer(peer1);
   ps.addPeer(peer2);
@@ -74,7 +78,7 @@ void DefaultPeerStorageTest::testDeleteUnusedPeer() {
   ps.deleteUnusedPeer(2);
 
   CPPUNIT_ASSERT_EQUAL((int32_t)1, ps.countPeer());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"),
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.3"),
 		       ps.getPeer("192.168.0.3", 6889)->ipaddr);
 
   ps.addPeer(peer1);
@@ -86,7 +90,7 @@ void DefaultPeerStorageTest::testDeleteUnusedPeer() {
 
   // peer2 has been in use, so it did't deleted.
   CPPUNIT_ASSERT_EQUAL((int32_t)1, ps.countPeer());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"),
 		       ps.getPeer("192.168.0.2", 6889)->ipaddr);
   
 }
@@ -94,9 +98,9 @@ void DefaultPeerStorageTest::testDeleteUnusedPeer() {
 void DefaultPeerStorageTest::testAddPeer() {
   DefaultPeerStorage ps(btContext, option);
 
-  PeerHandle peer1(new Peer("192.168.0.1", 6889));
-  PeerHandle peer2(new Peer("192.168.0.2", 6889));
-  PeerHandle peer3(new Peer("192.168.0.3", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer2(new Peer("192.168.0.2", 6889));
+  SharedHandle<Peer> peer3(new Peer("192.168.0.3", 6889));
 
   ps.addPeer(peer1);
   ps.addPeer(peer2);
@@ -111,15 +115,15 @@ void DefaultPeerStorageTest::testAddPeer() {
 
   ps.setMaxPeerListSize(3);
 
-  PeerHandle peer4(new Peer("192.168.0.4", 6889));
+  SharedHandle<Peer> peer4(new Peer("192.168.0.4", 6889));
 
   peer1->cuid = 1;
   CPPUNIT_ASSERT(ps.addPeer(peer4));
   // peer2 was deleted. While peer1 is oldest, its cuid is not 0.
   CPPUNIT_ASSERT_EQUAL((int32_t)3, ps.countPeer());
-  CPPUNIT_ASSERT(find(ps.getPeers().begin(), ps.getPeers().end(), peer2) == ps.getPeers().end());
+  CPPUNIT_ASSERT(std::find(ps.getPeers().begin(), ps.getPeers().end(), peer2) == ps.getPeers().end());
 
-  PeerHandle peer5(new Peer("192.168.0.4", 0));
+  SharedHandle<Peer> peer5(new Peer("192.168.0.4", 0));
 
   peer5->port = 6889;
 
@@ -131,11 +135,11 @@ void DefaultPeerStorageTest::testGetUnusedPeer() {
   DefaultPeerStorage ps(btContext, option);
   ps.setBtRuntime(btRuntime);
 
-  PeerHandle peer1(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
 
   ps.addPeer(peer1);
 
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"),
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"),
 		       ps.getUnusedPeer()->ipaddr);
 
   peer1->cuid = 1;
@@ -154,7 +158,7 @@ void DefaultPeerStorageTest::testIsPeerAvailable() {
 
   CPPUNIT_ASSERT_EQUAL(false, ps.isPeerAvailable());
 
-  PeerHandle peer1(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
 
   ps.addPeer(peer1);
 
@@ -176,11 +180,11 @@ void DefaultPeerStorageTest::testActivatePeer() {
 
   CPPUNIT_ASSERT_EQUAL((size_t)0, ps.getActivePeers().size());
 
-  PeerHandle peer1(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 6889));
 
   ps.addPeer(peer1);
 
-  Peers activePeer = ps.getActivePeers();
+  std::deque<SharedHandle<Peer> > activePeer = ps.getActivePeers();
 
   CPPUNIT_ASSERT_EQUAL((size_t)0, ps.getActivePeers().size());
 
@@ -196,24 +200,26 @@ void DefaultPeerStorageTest::testReturnPeer()
 {
   DefaultPeerStorage ps(btContext, option);
 
-  PeerHandle peer1(new Peer("192.168.0.1", 0));
-  PeerHandle peer2(new Peer("192.168.0.2", 6889));
-  PeerHandle peer3(new Peer("192.168.0.1", 6889));
+  SharedHandle<Peer> peer1(new Peer("192.168.0.1", 0));
+  SharedHandle<Peer> peer2(new Peer("192.168.0.2", 6889));
+  SharedHandle<Peer> peer3(new Peer("192.168.0.1", 6889));
   ps.addPeer(peer1);
   ps.addPeer(peer2);
   ps.addPeer(peer3);
 
   ps.returnPeer(peer2);
   // peer2 is moved to the end of container
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"),
 		       ps.getPeers().back()->ipaddr);
 
   ps.returnPeer(peer1); // peer1 is removed from the container
   CPPUNIT_ASSERT_EQUAL((size_t)2, ps.getPeers().size());
-  CPPUNIT_ASSERT(find(ps.getPeers().begin(), ps.getPeers().end(), peer1) == ps.getPeers().end());
+  CPPUNIT_ASSERT(std::find(ps.getPeers().begin(), ps.getPeers().end(), peer1) == ps.getPeers().end());
 }
 
 void DefaultPeerStorageTest::testOnErasingPeer()
 {
   // test this
 }
+
+} // namespace aria2
diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc
index a3ad533e..f953ea91 100644
--- a/test/DefaultPieceStorageTest.cc
+++ b/test/DefaultPieceStorageTest.cc
@@ -7,10 +7,11 @@
 #include "Piece.h"
 #include "Peer.h"
 #include "Option.h"
+#include "FileEntry.h"
 #include "MockBtContext.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DefaultPieceStorageTest:public CppUnit::TestFixture {
 
@@ -28,8 +29,8 @@ class DefaultPieceStorageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testMarkPiecesDone);
   CPPUNIT_TEST_SUITE_END();
 private:
-  BtContextHandle btContext;
-  PeerHandle peer;
+  SharedHandle<BtContext> btContext;
+  SharedHandle<Peer> peer;
   Option* option;
 public:
   DefaultPieceStorageTest():btContext(0), peer(0) {
@@ -81,14 +82,14 @@ void DefaultPieceStorageTest::testGetMissingPiece() {
   pss.setEndGamePieceNum(0);
 
   peer->setAllBitfield();
-  PieceHandle piece = pss.getMissingPiece(peer);
-  CPPUNIT_ASSERT_EQUAL(string("piece: index=0, length=128"),
+  SharedHandle<Piece> piece = pss.getMissingPiece(peer);
+  CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
 		       piece->toString());
   piece = pss.getMissingPiece(peer);
-  CPPUNIT_ASSERT_EQUAL(string("piece: index=1, length=128"),
+  CPPUNIT_ASSERT_EQUAL(std::string("piece: index=1, length=128"),
 		       piece->toString());
   piece = pss.getMissingPiece(peer);
-  CPPUNIT_ASSERT_EQUAL(string("piece: index=2, length=128"),
+  CPPUNIT_ASSERT_EQUAL(std::string("piece: index=2, length=128"),
 		       piece->toString());
   piece = pss.getMissingPiece(peer);
   CPPUNIT_ASSERT(piece.isNull());
@@ -102,8 +103,8 @@ void DefaultPieceStorageTest::testGetMissingFastPiece() {
   peer->setFastExtensionEnabled(true);
   peer->addPeerAllowedIndex(2);
 
-  PieceHandle piece = pss.getMissingFastPiece(peer);
-  CPPUNIT_ASSERT_EQUAL(string("piece: index=2, length=128"),
+  SharedHandle<Piece> piece = pss.getMissingFastPiece(peer);
+  CPPUNIT_ASSERT_EQUAL(std::string("piece: index=2, length=128"),
 		       piece->toString());
 }
 
@@ -123,8 +124,8 @@ void DefaultPieceStorageTest::testCompletePiece() {
 
   peer->setAllBitfield();
 
-  PieceHandle piece = pss.getMissingPiece(peer);
-  CPPUNIT_ASSERT_EQUAL(string("piece: index=0, length=128"),
+  SharedHandle<Piece> piece = pss.getMissingPiece(peer);
+  CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"),
 		       piece->toString());
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0,
@@ -135,7 +136,7 @@ void DefaultPieceStorageTest::testCompletePiece() {
   CPPUNIT_ASSERT_EQUAL((int64_t)128,
 		       pss.getCompletedLength());
 
-  PieceHandle incompletePiece = pss.getMissingPiece(peer);
+  SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer);
   incompletePiece->completeBlock(0);
   CPPUNIT_ASSERT_EQUAL((int64_t)256,
 		       pss.getCompletedLength());
@@ -144,7 +145,7 @@ void DefaultPieceStorageTest::testCompletePiece() {
 void DefaultPieceStorageTest::testGetPiece() {
   DefaultPieceStorage pss(btContext, option);
   
-  PieceHandle pieceGot = pss.getPiece(0);
+  SharedHandle<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(false, pieceGot->pieceComplete());
@@ -152,10 +153,10 @@ void DefaultPieceStorageTest::testGetPiece() {
 
 void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
   DefaultPieceStorage pss(btContext, option);
-  PieceHandle piece = PieceHandle(new Piece(0, 128));
+  SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
   piece->completeBlock(0);
   pss.addUsedPiece(piece);
-  PieceHandle pieceGot = pss.getPiece(0);
+  SharedHandle<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, pieceGot->countCompleteBlock());
@@ -163,9 +164,9 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() {
 
 void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
   DefaultPieceStorage pss(btContext, option);
-  PieceHandle piece = PieceHandle(new Piece(0, 128));
+  SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128));
   pss.completePiece(piece);
-  PieceHandle pieceGot = pss.getPiece(0);
+  SharedHandle<Piece> pieceGot = pss.getPiece(0);
   CPPUNIT_ASSERT_EQUAL((int32_t)0, pieceGot->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)128, pieceGot->getLength());
   CPPUNIT_ASSERT_EQUAL(true, pieceGot->pieceComplete());
@@ -179,36 +180,36 @@ void DefaultPieceStorageTest::testGetMissingPiece_fileEntry()
   int32_t pieceLength = 256*1024;
   int64_t totalLength = 1*pieceLength;
   int32_t blockLength = 16*1024;
-  Strings uris1;
+  std::deque<std::string> uris1;
   uris1.push_back("http://localhost/src/file1.txt");
-  Strings uris2;
+  std::deque<std::string> uris2;
   uris2.push_back("http://localhost/src/file2.txt");
-  FileEntryHandle file1 = new FileEntry("src/file1.txt", 150*1024, 0/*, uris1*/);
-  FileEntryHandle file2 = new FileEntry("src/file2.txt", 106*1024, file1->getLength() /*, uris2*/);
+  SharedHandle<FileEntry> file1 = new FileEntry("src/file1.txt", 150*1024, 0/*, uris1*/);
+  SharedHandle<FileEntry> file2 = new FileEntry("src/file2.txt", 106*1024, file1->getLength() /*, uris2*/);
 
-  MockBtContextHandle dctx = new MockBtContext();
+  SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
   dctx->addFileEntry(file1);
   dctx->addFileEntry(file2);
 
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, option);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, option);
 
-  PieceHandle p = ps->getMissingPiece(file1);
+  SharedHandle<Piece> p = ps->getMissingPiece(file1);
   CPPUNIT_ASSERT(!p.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, p->getIndex());
 
   for(int32_t i = 0; i < 9; ++i) {
     p->completeBlock(i);
   }
-  PieceHandle subPiece = new Piece(9, blockLength, 1);
+  SharedHandle<Piece> subPiece = new Piece(9, blockLength, 1);
   p->addSubPiece(subPiece);
 
   ps->cancelPiece(p);
 
   // Piece index = 0 should be retrieved again because the part of file1 is
   // not complete
-  PieceHandle p2 = ps->getMissingPiece(file1);
+  SharedHandle<Piece> p2 = ps->getMissingPiece(file1);
   CPPUNIT_ASSERT(!p2.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, p2->getIndex());
  
@@ -222,7 +223,7 @@ void DefaultPieceStorageTest::testGetMissingPiece_fileEntry()
   CPPUNIT_ASSERT(ps->getMissingPiece(file1).isNull());
 
   // Next, I retrive the piece giving file2
-  PieceHandle p3 = ps->getMissingPiece(file2);
+  SharedHandle<Piece> p3 = ps->getMissingPiece(file2);
   CPPUNIT_ASSERT(!p3.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, p3->getIndex());
 
@@ -244,27 +245,27 @@ void DefaultPieceStorageTest::testCancelPiece()
   int32_t pieceLength = 256*1024;
   int64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
   int32_t blockLength = 16*1024;
-  Strings uris1;
+  std::deque<std::string> uris1;
   uris1.push_back("http://localhost/src/file1.txt");
-  FileEntryHandle file1 = new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/);
+  SharedHandle<FileEntry> file1 = new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/);
 
-  MockBtContextHandle dctx = new MockBtContext();
+  SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
   dctx->addFileEntry(file1);
 
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, option);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, option);
 
-  PieceHandle p = ps->getMissingPiece(file1);
+  SharedHandle<Piece> p = ps->getMissingPiece(file1);
   
-  PieceHandle subPiece = new Piece(0, blockLength, 1);
+  SharedHandle<Piece> subPiece = new Piece(0, blockLength, 1);
   subPiece->completeBlock(0);
   p->addSubPiece(subPiece);
 
   ps->cancelPiece(p);
 
   // See the sub piece is also hibernated...
-  PieceHandle p2 = ps->getMissingPiece(file1);
+  SharedHandle<Piece> p2 = ps->getMissingPiece(file1);
 
   CPPUNIT_ASSERT(!p2->getSubPiece(0).isNull());  
 }
@@ -273,7 +274,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
 {
   int32_t pieceLength = 256*1024;
   int64_t totalLength = 4*1024*1024;
-  MockBtContextHandle dctx = new MockBtContext();
+  SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
 
@@ -295,3 +296,5 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
     CPPUNIT_ASSERT(ps.hasPiece(i));
   }
 }
+
+} // namespace aria2
diff --git a/test/DictionaryTest.cc b/test/DictionaryTest.cc
index 95c5b418..b1aa7987 100644
--- a/test/DictionaryTest.cc
+++ b/test/DictionaryTest.cc
@@ -3,7 +3,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class DictionaryTest:public CppUnit::TestFixture {
 
@@ -30,6 +30,7 @@ void DictionaryTest::testGet() {
   d.put("platform", data2);
   Data* dataGot = (Data*)d.get("app_name");
   CPPUNIT_ASSERT(dataGot != NULL);
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), dataGot->toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), dataGot->toString());
 }
 
+} // namespace aria2
diff --git a/test/DownloadHandlerFactoryTest.cc b/test/DownloadHandlerFactoryTest.cc
index 5039045c..6d5e2b48 100644
--- a/test/DownloadHandlerFactoryTest.cc
+++ b/test/DownloadHandlerFactoryTest.cc
@@ -3,8 +3,11 @@
 #include "Option.h"
 #include "SingleFileDownloadContext.h"
 #include "MemoryBufferPreDownloadHandler.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class DownloadHandlerFactoryTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DownloadHandlerFactoryTest);
@@ -30,11 +33,11 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DownloadHandlerFactoryTest );
 void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_extension()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.metalink");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.metalink");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
-  PreDownloadHandlerHandle handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
+  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -45,12 +48,12 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_extension()
 void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test");
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test");
   dctx->setContentType("application/metalink+xml");
-  RequestGroup rg(&op, Strings());
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
-  PreDownloadHandlerHandle handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
+  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -61,11 +64,11 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType()
 void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_extension()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.torrent");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
-  PreDownloadHandlerHandle handler = DownloadHandlerFactory::getBtPreDownloadHandler();
+  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
@@ -76,15 +79,17 @@ void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_extension()
 void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_contentType()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test");
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test");
   dctx->setContentType("application/x-bittorrent");
-  RequestGroup rg(&op, Strings());
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
-  PreDownloadHandlerHandle handler = DownloadHandlerFactory::getBtPreDownloadHandler();
+  SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler();
 
   CPPUNIT_ASSERT(handler->canHandle(&rg));
 
   dctx->setContentType("application/octet-stream");
   CPPUNIT_ASSERT(!handler->canHandle(&rg));
 }
+
+} // namespace aria2
diff --git a/test/FeatureConfigTest.cc b/test/FeatureConfigTest.cc
index 652fd679..80556862 100644
--- a/test/FeatureConfigTest.cc
+++ b/test/FeatureConfigTest.cc
@@ -1,7 +1,8 @@
 #include "FeatureConfig.h"
-
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class FeatureConfigTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(FeatureConfigTest);
@@ -45,7 +46,7 @@ void FeatureConfigTest::testIsSupported() {
 }
 
 void FeatureConfigTest::testGetConfigurationSummary() {
-  CPPUNIT_ASSERT_EQUAL(string("http: yes\n")
+  CPPUNIT_ASSERT_EQUAL(std::string("http: yes\n")
 #ifdef ENABLE_SSL
 		       +"https: yes\n"
 #else
@@ -75,3 +76,5 @@ void FeatureConfigTest::testGetConfigurationSummary() {
 		       ,
 		       FeatureConfig::getInstance()->getConfigurationSummary());
 }
+
+} // namespace aria2
diff --git a/test/FileEntryTest.cc b/test/FileEntryTest.cc
index af1c3fd7..5b6465bc 100644
--- a/test/FileEntryTest.cc
+++ b/test/FileEntryTest.cc
@@ -1,6 +1,8 @@
 #include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class FileEntryTest : public CppUnit::TestFixture {
   
   CPPUNIT_TEST_SUITE(FileEntryTest);
@@ -17,10 +19,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION( FileEntryTest );
 
 void FileEntryTest::testSetupDir()
 {
-  string topDir = "/tmp";
-  string dir = "aria2-FileEntryTest-testSetupDir";
-  string filename = "filename";
-  string path = topDir+"/"+dir+"/"+filename;
+  std::string topDir = "/tmp";
+  std::string dir = "aria2-FileEntryTest-testSetupDir";
+  std::string filename = "filename";
+  std::string path = topDir+"/"+dir+"/"+filename;
   File d(topDir+"/"+dir);
   if(d.exists()) {
     CPPUNIT_ASSERT(d.remove());
@@ -32,3 +34,5 @@ void FileEntryTest::testSetupDir()
   File f(path);
   CPPUNIT_ASSERT(!f.exists());
 }
+
+} // namespace aria2
diff --git a/test/FileTest.cc b/test/FileTest.cc
index 83acb95a..2bbd5177 100644
--- a/test/FileTest.cc
+++ b/test/FileTest.cc
@@ -6,7 +6,7 @@
 #include <fstream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class FileTest:public CppUnit::TestFixture {
 
@@ -76,7 +76,7 @@ void FileTest::testIsDir() {
 
 void FileTest::testRemove() {
   int fd;
-  string name = "/tmp/aria2test";
+  std::string name = "/tmp/aria2test";
   unlink(name.c_str());
   if((fd = creat(name.c_str(), S_IRUSR|S_IWUSR)) < 0) {
     CPPUNIT_FAIL("cannot create test file");
@@ -89,7 +89,7 @@ void FileTest::testRemove() {
   // delete the file again
   CPPUNIT_ASSERT(!f.remove());
 
-  string dir = "/tmp/aria2testdir";
+  std::string dir = "/tmp/aria2testdir";
 #ifdef __MINGW32__
   mkdir(dir.c_str());
 #else
@@ -109,7 +109,7 @@ void FileTest::testSize() {
 }
 
 void FileTest::testMkdir() {
-  string dir = "/tmp/aria2test2/test";
+  std::string dir = "/tmp/aria2test2/test";
   File d(dir);
   if(d.exists()) {
     CPPUNIT_ASSERT(d.remove());
@@ -127,23 +127,23 @@ void FileTest::testMkdir() {
 void FileTest::testGetDirname()
 {
   File f("/tmp/dist/aria2.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("/tmp/dist"), f.getDirname());
+  CPPUNIT_ASSERT_EQUAL(std::string("/tmp/dist"), f.getDirname());
 }
 
 void FileTest::testGetBasename()
 {
   File f("/tmp/dist/aria2.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), f.getBasename());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), f.getBasename());
 }
 
 void FileTest::testRenameTo()
 {
-  string fname = "FileTest_testRenameTo.txt";
-  ofstream of(fname.c_str());
+  std::string fname = "FileTest_testRenameTo.txt";
+  std::ofstream of(fname.c_str());
   of.close();
 
   File f(fname);
-  string fnameTo = "FileTest_testRenameTo_dest.txt";
+  std::string fnameTo = "FileTest_testRenameTo_dest.txt";
   CPPUNIT_ASSERT(f.renameTo(fnameTo));
   CPPUNIT_ASSERT(f.exists());
   CPPUNIT_ASSERT(!File(fname).exists());
@@ -155,3 +155,5 @@ void FileTest::testRenameTo()
   
   CPPUNIT_ASSERT(f.renameTo(fname));
 }
+
+} // namespace aria2
diff --git a/test/FileUriListParserTest.cc b/test/FileUriListParserTest.cc
deleted file mode 100644
index c0090145..00000000
--- a/test/FileUriListParserTest.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "FileUriListParser.h"
-#include "Exception.h"
-#include "Util.h"
-#include <sstream>
-#include <algorithm>
-#include <iostream>
-#include <iterator>
-#include <cppunit/extensions/HelperMacros.h>
-
-using namespace std;
-
-class FileUriListParserTest : public CppUnit::TestFixture {
-
-  CPPUNIT_TEST_SUITE(FileUriListParserTest);
-  CPPUNIT_TEST(testHasNext);
-  CPPUNIT_TEST_SUITE_END();
-private:
-  string list2String(const Strings& src);
-public:
-  void setUp() {
-  }
-
-  void testHasNext();
-};
-
-
-CPPUNIT_TEST_SUITE_REGISTRATION( FileUriListParserTest );
-
-string  FileUriListParserTest::list2String(const Strings& src)
-{
-  ostringstream strm;
-  copy(src.begin(), src.end(), ostream_iterator<string>(strm, " "));
-  return Util::trim(strm.str());
-}
-
-void FileUriListParserTest::testHasNext()
-{
-  FileUriListParser flp("filelist1.txt");
-
-  CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/index.html http://localhost2/index.html"), list2String(flp.next()));
-  CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string("ftp://localhost/aria2.tar.bz2"),
-		       list2String(flp.next()));
-  CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string(""),
-		       list2String(flp.next()));
-  CPPUNIT_ASSERT(!flp.hasNext());
-}
diff --git a/test/FixedNumberRandomizer.h b/test/FixedNumberRandomizer.h
index b03ee1a7..c53975c2 100644
--- a/test/FixedNumberRandomizer.h
+++ b/test/FixedNumberRandomizer.h
@@ -3,6 +3,8 @@
 
 #include "Randomizer.h"
 
+namespace aria2 {
+
 class FixedNumberRandomizer : public Randomizer {
 private:
   int32_t fixedNumber;
@@ -33,4 +35,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_FIXED_NUMBER_RANDOMIZER_H_
diff --git a/test/GlowFileAllocatorTest.cc b/test/GlowFileAllocatorTest.cc
index a02d2bdb..1e4e4cfa 100644
--- a/test/GlowFileAllocatorTest.cc
+++ b/test/GlowFileAllocatorTest.cc
@@ -25,7 +25,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( GlowFileAllocatorTest );
 
 void GlowFileAllocatorTest::testAllocate()
 {
-  string fn = "/tmp/aria2_GlowFileAllocatorTest_testAllocate";
+  std::stringfn = "/tmp/aria2_GlowFileAllocatorTest_testAllocate";
   ofstream of(fn.c_str());
 
   of << "0123456789";
diff --git a/test/GrowSegmentTest.cc b/test/GrowSegmentTest.cc
index 1c1235ae..6f8fdcb8 100644
--- a/test/GrowSegmentTest.cc
+++ b/test/GrowSegmentTest.cc
@@ -2,7 +2,7 @@
 #include "Piece.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class GrowSegmentTest : public CppUnit::TestFixture {
 
@@ -40,3 +40,5 @@ void GrowSegmentTest::testClear()
   segment.clear();
   CPPUNIT_ASSERT_EQUAL((int32_t)0, segment.getWrittenLength());  
 }
+
+} // namespace aria2
diff --git a/test/HandshakeExtensionMessageTest.cc b/test/HandshakeExtensionMessageTest.cc
index 62543c31..b68c4e5d 100644
--- a/test/HandshakeExtensionMessageTest.cc
+++ b/test/HandshakeExtensionMessageTest.cc
@@ -2,8 +2,11 @@
 #include "Peer.h"
 #include "MockBtContext.h"
 #include "Exception.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class HandshakeExtensionMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(HandshakeExtensionMessageTest);
@@ -16,7 +19,7 @@ class HandshakeExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreate_stringnum);
   CPPUNIT_TEST_SUITE_END();
 private:
-  BtContextHandle _btContext;
+  SharedHandle<BtContext> _btContext;
 public:
   HandshakeExtensionMessageTest():_btContext(0) {}
 
@@ -45,7 +48,7 @@ void HandshakeExtensionMessageTest::testGetExtensionMessageID()
 void HandshakeExtensionMessageTest::testGetExtensionName()
 {
   HandshakeExtensionMessage msg;
-  CPPUNIT_ASSERT_EQUAL(string("handshake"), msg.getExtensionName());
+  CPPUNIT_ASSERT_EQUAL(std::string("handshake"), msg.getExtensionName());
 }
 
 void HandshakeExtensionMessageTest::testGetBencodedData()
@@ -55,7 +58,7 @@ void HandshakeExtensionMessageTest::testGetBencodedData()
   msg.setTCPPort(6889);
   msg.setExtension("ut_pex", 1);
   msg.setExtension("a2_dht", 2);
-  CPPUNIT_ASSERT_EQUAL(string("d1:v5:aria21:pi6889e1:md6:a2_dhti2e6:ut_pexi1eee"), msg.getBencodedData());
+  CPPUNIT_ASSERT_EQUAL(std::string("d1:v5:aria21:pi6889e1:md6:a2_dhti2e6:ut_pexi1eee"), msg.getBencodedData());
 }
 
 void HandshakeExtensionMessageTest::testToString()
@@ -65,12 +68,12 @@ void HandshakeExtensionMessageTest::testToString()
   msg.setTCPPort(6889);
   msg.setExtension("ut_pex", 1);
   msg.setExtension("a2_dht", 2);
-  CPPUNIT_ASSERT_EQUAL(string("handshake client=aria2, tcpPort=6889, a2_dht=2, ut_pex=1"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("handshake client=aria2, tcpPort=6889, a2_dht=2, ut_pex=1"), msg.toString());
 }
 
 void HandshakeExtensionMessageTest::testDoReceivedAction()
 {
-  PeerHandle peer = new Peer("192.168.0.1", 0);
+  SharedHandle<Peer> peer = new Peer("192.168.0.1", 0);
   HandshakeExtensionMessage msg;
   msg.setClientVersion("aria2");
   msg.setTCPPort(6889);
@@ -88,48 +91,50 @@ void HandshakeExtensionMessageTest::testDoReceivedAction()
 
 void HandshakeExtensionMessageTest::testCreate()
 {
-  string in = "0d1:pi6881e1:v5:aria21:md6:ut_pexi1eee";
-  HandshakeExtensionMessageHandle m =
+  std::string in = "0d1:pi6881e1:v5:aria21:md6:ut_pexi1eee";
+  SharedHandle<HandshakeExtensionMessage> m =
     HandshakeExtensionMessage::create(in.c_str(), in.size());
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), m->getClientVersion());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), m->getClientVersion());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getTCPPort());
   CPPUNIT_ASSERT_EQUAL((uint8_t)1, m->getExtensionMessageID("ut_pex"));
 
   try {
     // bad payload format
-    string in = "011:hello world";
+    std::string in = "011:hello world";
     HandshakeExtensionMessage::create(in.c_str(), in.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
   try {
     // malformed dencoded message
-    string in = "011:hello";
+    std::string in = "011:hello";
     HandshakeExtensionMessage::create(in.c_str(), in.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
   try {
     // 0 length data
-    string in = "";
+    std::string in = "";
     HandshakeExtensionMessage::create(in.c_str(), in.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }    
 }
 
 void HandshakeExtensionMessageTest::testCreate_stringnum()
 {
-  string in = "0d1:p4:68811:v5:aria21:md6:ut_pex1:1ee";
-  HandshakeExtensionMessageHandle m =
+  std::string in = "0d1:p4:68811:v5:aria21:md6:ut_pex1:1ee";
+  SharedHandle<HandshakeExtensionMessage> m =
     HandshakeExtensionMessage::create(in.c_str(), in.size());
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), m->getClientVersion());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), m->getClientVersion());
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getTCPPort());
   CPPUNIT_ASSERT_EQUAL((uint8_t)1, m->getExtensionMessageID("ut_pex"));
 }
+
+} // namespace aria2
diff --git a/test/HelpItemTest.cc b/test/HelpItemTest.cc
index 7f7fefa9..b83cee75 100644
--- a/test/HelpItemTest.cc
+++ b/test/HelpItemTest.cc
@@ -2,6 +2,8 @@
 #include <sstream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class HelpItemTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(HelpItemTest);
@@ -20,7 +22,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(HelpItemTest);
 
 void HelpItemTest::testOperatorStreamOut()
 {
-  string usage =
+  std::string usage =
     " -m, --max-tries=N            Set number of tries. 0 means unlimited.";
   HelpItem item("max-tries", usage, "5");
   item.setAvailableValues("0,5,10");
@@ -28,7 +30,7 @@ void HelpItemTest::testOperatorStreamOut()
   item.addTag("http");
   item.addTag("ftp");
   
-  stringstream s;
+  std::stringstream s;
   s << item;
 
   CPPUNIT_ASSERT_EQUAL(usage+"\n"+
@@ -37,3 +39,5 @@ void HelpItemTest::testOperatorStreamOut()
 		       "                              Tags: basic,http,ftp",
 		       s.str());
 }
+
+} // namespace aria2
diff --git a/test/HttpHeaderProcessorTest.cc b/test/HttpHeaderProcessorTest.cc
index 16f7b4b0..dd1af1a2 100644
--- a/test/HttpHeaderProcessorTest.cc
+++ b/test/HttpHeaderProcessorTest.cc
@@ -1,8 +1,11 @@
 #include "HttpHeaderProcessor.h"
+#include "HttpHeader.h"
 #include "DlRetryEx.h"
 #include "DlAbortEx.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class HttpHeaderProcessorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(HttpHeaderProcessorTest);
@@ -37,7 +40,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( HttpHeaderProcessorTest );
 void HttpHeaderProcessorTest::testUpdate1()
 {
   HttpHeaderProcessor proc;
-  string hd1 = "HTTP/1.1 200 OK\r\n";
+  std::string hd1 = "HTTP/1.1 200 OK\r\n";
   proc.update(hd1);
   CPPUNIT_ASSERT(!proc.eoh());
   proc.update("\r\n");
@@ -47,7 +50,7 @@ void HttpHeaderProcessorTest::testUpdate1()
 void HttpHeaderProcessorTest::testUpdate2()
 {
   HttpHeaderProcessor proc;
-  string hd1 = "HTTP/1.1 200 OK\n";
+  std::string hd1 = "HTTP/1.1 200 OK\n";
   proc.update(hd1);
   CPPUNIT_ASSERT(!proc.eoh());
   proc.update("\n");
@@ -57,7 +60,7 @@ void HttpHeaderProcessorTest::testUpdate2()
 void HttpHeaderProcessorTest::testGetPutBackDataLength()
 {
   HttpHeaderProcessor proc;
-  string hd1 = "HTTP/1.1 200 OK\r\n"
+  std::string hd1 = "HTTP/1.1 200 OK\r\n"
     "\r\nputbackme";
   proc.update(hd1);
   CPPUNIT_ASSERT(proc.eoh());
@@ -65,7 +68,7 @@ void HttpHeaderProcessorTest::testGetPutBackDataLength()
 
   proc.clear();
 
-  string hd2 = "HTTP/1.1 200 OK\n"
+  std::string hd2 = "HTTP/1.1 200 OK\n"
     "\nputbackme";
   proc.update(hd2);
   CPPUNIT_ASSERT(proc.eoh());
@@ -86,7 +89,7 @@ void HttpHeaderProcessorTest::testGetPutBackDataLength_nullChar()
 void HttpHeaderProcessorTest::testGetHttpStatusHeader()
 {
   HttpHeaderProcessor proc;
-  string hd = "HTTP/1.1 200 OK\r\n"
+  std::string hd = "HTTP/1.1 200 OK\r\n"
     "Date: Mon, 25 Jun 2007 16:04:59 GMT\r\n"
     "Server: Apache/2.2.3 (Debian)\r\n"
     "Last-Modified: Tue, 12 Jun 2007 14:28:43 GMT\r\n"
@@ -99,14 +102,14 @@ void HttpHeaderProcessorTest::testGetHttpStatusHeader()
 
   proc.update(hd);
 
-  pair<string, HttpHeaderHandle> statusHeader = proc.getHttpStatusHeader();
-  string status = statusHeader.first;
-  HttpHeaderHandle header = statusHeader.second;
-  CPPUNIT_ASSERT_EQUAL(string("200"), status);
-  CPPUNIT_ASSERT_EQUAL(string("Mon, 25 Jun 2007 16:04:59 GMT"), header->getFirst("Date"));
-  CPPUNIT_ASSERT_EQUAL(string("Apache/2.2.3 (Debian)"), header->getFirst("Server"));
+  std::pair<std::string, SharedHandle<HttpHeader> > statusHeader = proc.getHttpStatusHeader();
+  std::string status = statusHeader.first;
+  SharedHandle<HttpHeader> header = statusHeader.second;
+  CPPUNIT_ASSERT_EQUAL(std::string("200"), status);
+  CPPUNIT_ASSERT_EQUAL(std::string("Mon, 25 Jun 2007 16:04:59 GMT"), header->getFirst("Date"));
+  CPPUNIT_ASSERT_EQUAL(std::string("Apache/2.2.3 (Debian)"), header->getFirst("Server"));
   CPPUNIT_ASSERT_EQUAL((int64_t)9187LL, header->getFirstAsLLInt("Content-Length"));
-  CPPUNIT_ASSERT_EQUAL(string("text/html; charset=UTF-8"), header->getFirst("Content-Type"));
+  CPPUNIT_ASSERT_EQUAL(std::string("text/html; charset=UTF-8"), header->getFirst("Content-Type"));
 }
 
 void HttpHeaderProcessorTest::testGetHttpStatusHeader_empty()
@@ -114,10 +117,10 @@ void HttpHeaderProcessorTest::testGetHttpStatusHeader_empty()
   HttpHeaderProcessor proc;
 
   try {
-    pair<string, HttpHeaderHandle> statusHeader = proc.getHttpStatusHeader();
+    std::pair<std::string, SharedHandle<HttpHeader> > statusHeader = proc.getHttpStatusHeader();
     CPPUNIT_FAIL("Exception must be thrown.");
   } catch(DlRetryEx* ex) {
-    cout << ex->getMsg() << endl;
+    std::cout << ex->getMsg() << std::endl;
     delete ex;
   }
   
@@ -127,10 +130,10 @@ void HttpHeaderProcessorTest::testGetHttpStatusHeader_statusOnly()
 {
   HttpHeaderProcessor proc;
 
-  string hd = "HTTP/1.1 200\r\n\r\n";
+  std::string hd = "HTTP/1.1 200\r\n\r\n";
   proc.update(hd);
-  pair<string, HttpHeaderHandle> statusHeader = proc.getHttpStatusHeader();
-  CPPUNIT_ASSERT_EQUAL(string("200"), statusHeader.first);
+  std::pair<std::string, SharedHandle<HttpHeader> > statusHeader = proc.getHttpStatusHeader();
+  CPPUNIT_ASSERT_EQUAL(std::string("200"), statusHeader.first);
   CPPUNIT_ASSERT(!statusHeader.second.isNull());
 }
 
@@ -138,13 +141,13 @@ void HttpHeaderProcessorTest::testGetHttpStatusHeader_insufficientStatusLength()
 {
   HttpHeaderProcessor proc;
 
-  string hd = "HTTP/1.1 20\r\n\r\n";
+  std::string hd = "HTTP/1.1 20\r\n\r\n";
   proc.update(hd);  
   try {
-    pair<string, HttpHeaderHandle> statusHeader = proc.getHttpStatusHeader();
+    std::pair<std::string, SharedHandle<HttpHeader> > statusHeader = proc.getHttpStatusHeader();
     CPPUNIT_FAIL("Exception must be thrown.");
   } catch(DlRetryEx* ex) {
-    cout << ex->getMsg() << endl;
+    std::cout << ex->getMsg() << std::endl;
     delete ex;
   }
   
@@ -155,8 +158,8 @@ void HttpHeaderProcessorTest::testBeyondLimit()
   HttpHeaderProcessor proc;
   proc.setHeaderLimit(20);
 
-  string hd1 = "HTTP/1.1 200 OK\r\n";
-  string hd2 = "Date: Mon, 25 Jun 2007 16:04:59 GMT\r\n";
+  std::string hd1 = "HTTP/1.1 200 OK\r\n";
+  std::string hd2 = "Date: Mon, 25 Jun 2007 16:04:59 GMT\r\n";
 
   proc.update(hd1);
   
@@ -164,7 +167,7 @@ void HttpHeaderProcessorTest::testBeyondLimit()
     proc.update(hd2);
     CPPUNIT_FAIL("Exception must be thrown.");
   } catch(DlAbortEx* ex) {
-    cout << ex->getMsg() << endl;
+    std::cout << ex->getMsg() << std::endl;
     delete ex;
   }
 }
@@ -172,7 +175,7 @@ void HttpHeaderProcessorTest::testBeyondLimit()
 void HttpHeaderProcessorTest::testGetHeaderString()
 {
   HttpHeaderProcessor proc;
-  string hd = "HTTP/1.1 200 OK\r\n"
+  std::string hd = "HTTP/1.1 200 OK\r\n"
     "Date: Mon, 25 Jun 2007 16:04:59 GMT\r\n"
     "Server: Apache/2.2.3 (Debian)\r\n"
     "Last-Modified: Tue, 12 Jun 2007 14:28:43 GMT\r\n"
@@ -185,7 +188,7 @@ void HttpHeaderProcessorTest::testGetHeaderString()
 
   proc.update(hd);
 
-  CPPUNIT_ASSERT_EQUAL(string("HTTP/1.1 200 OK\r\n"
+  CPPUNIT_ASSERT_EQUAL(std::string("HTTP/1.1 200 OK\r\n"
 			      "Date: Mon, 25 Jun 2007 16:04:59 GMT\r\n"
 			      "Server: Apache/2.2.3 (Debian)\r\n"
 			      "Last-Modified: Tue, 12 Jun 2007 14:28:43 GMT\r\n"
@@ -196,3 +199,5 @@ void HttpHeaderProcessorTest::testGetHeaderString()
 			      "Content-Type: text/html; charset=UTF-8"),
 		       proc.getHeaderString());
 }
+
+} // namespace aria2
diff --git a/test/HttpHeaderTest.cc b/test/HttpHeaderTest.cc
index 88646439..8e6ab945 100644
--- a/test/HttpHeaderTest.cc
+++ b/test/HttpHeaderTest.cc
@@ -1,6 +1,9 @@
 #include "HttpHeader.h"
+#include "Range.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class HttpHeaderTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(HttpHeaderTest);
@@ -20,9 +23,11 @@ void HttpHeaderTest::testGetRange()
   HttpHeader httpHeader;
   httpHeader.put("Content-Range", "bytes 1-499/1234");
 
-  RangeHandle range = httpHeader.getRange();
+  SharedHandle<Range> range = httpHeader.getRange();
 
   CPPUNIT_ASSERT_EQUAL((int64_t)1, range->getStartByte());
   CPPUNIT_ASSERT_EQUAL((int64_t)499, range->getEndByte());
   CPPUNIT_ASSERT_EQUAL((int64_t)1234, range->getEntityLength());
 }
+
+} // namespace aria2
diff --git a/test/HttpRequestTest.cc b/test/HttpRequestTest.cc
index 514b2c55..eefd1103 100644
--- a/test/HttpRequestTest.cc
+++ b/test/HttpRequestTest.cc
@@ -3,9 +3,13 @@
 #include "AuthConfigFactory.h"
 #include "PiecedSegment.h"
 #include "Piece.h"
+#include "Range.h"
+#include "Request.h"
+#include "CookieBox.h"
+#include "Option.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class HttpRequestTest : public CppUnit::TestFixture {
 
@@ -40,7 +44,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( HttpRequestTest );
 void HttpRequestTest::testGetStartByte()
 {
   HttpRequest httpRequest;
-  SegmentHandle segment = new PiecedSegment(1024, new Piece(1, 1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024, new Piece(1, 1024));
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0, httpRequest.getStartByte());
 
@@ -57,7 +61,7 @@ void HttpRequestTest::testGetEndByte()
   int32_t segmentLength = 1024*1024;
 
   HttpRequest httpRequest;
-  SegmentHandle segment = new PiecedSegment(segmentLength,
+  SharedHandle<Segment> segment = new PiecedSegment(segmentLength,
 					    new Piece(index, length));
   
 
@@ -67,7 +71,7 @@ void HttpRequestTest::testGetEndByte()
 
   CPPUNIT_ASSERT_EQUAL((int64_t)0, httpRequest.getEndByte());
 
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setKeepAlive(true);
 
   httpRequest.setRequest(request);
@@ -93,13 +97,13 @@ void HttpRequestTest::testCreateRequest()
   option.put(PREF_HTTP_PROXY_USER, "aria2proxyuser");
   option.put(PREF_HTTP_PROXY_PASSWD, "aria2proxypasswd");
 
-  AuthConfigFactoryHandle authConfigFactory = new AuthConfigFactory(&option);
-  AuthConfigFactorySingleton::instance(authConfigFactory);
+  SharedHandle<AuthConfigFactory> authConfigFactory = new AuthConfigFactory(&option);
+  SingletonHolder<SharedHandle<AuthConfigFactory> >::instance(authConfigFactory);
 
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
-  SegmentHandle segment = new PiecedSegment(1024, new Piece(0, 1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024, new Piece(0, 1024));
 
   HttpRequest httpRequest;
   httpRequest.setRequest(request);
@@ -107,7 +111,7 @@ void HttpRequestTest::testCreateRequest()
 
   request->setKeepAlive(true);
   
-  string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
+  std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
     "User-Agent: aria2\r\n"
     "Accept: */*\r\n"
     "Host: localhost:8080\r\n"
@@ -296,20 +300,20 @@ void HttpRequestTest::testCreateRequest_ftp()
   option.put(PREF_HTTP_PROXY_USER, "aria2proxyuser");
   option.put(PREF_HTTP_PROXY_PASSWD, "aria2proxypasswd");
 
-  AuthConfigFactoryHandle authConfigFactory = new AuthConfigFactory(&option);
-  AuthConfigFactorySingleton::instance(authConfigFactory);
+  SharedHandle<AuthConfigFactory> authConfigFactory = new AuthConfigFactory(&option);
+  SingletonHolder<SharedHandle<AuthConfigFactory> >::instance(authConfigFactory);
 
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("ftp://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
   HttpRequest httpRequest;
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
   httpRequest.setRequest(request);
   httpRequest.setSegment(segment);
 
   httpRequest.configure(&option);
 
-  string expectedText = "GET ftp://localhost:8080/archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
+  std::string expectedText = "GET ftp://localhost:8080/archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
     "User-Agent: aria2\r\n"
     "Accept: */*\r\n"
     "Host: localhost:8080\r\n"
@@ -344,9 +348,9 @@ void HttpRequestTest::testCreateRequest_ftp()
 
 void HttpRequestTest::testCreateRequest_with_cookie()
 {
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
 
   Cookie cookie1("name1", "value1", "/archives", "localhost", false);
   Cookie cookie2("name2", "value2", "/archives/download", "localhost", false);
@@ -363,7 +367,7 @@ void HttpRequestTest::testCreateRequest_with_cookie()
   httpRequest.setRequest(request);
   httpRequest.setSegment(segment);
 
-  string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
+  std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
     "User-Agent: aria2\r\n"
     "Accept: */*\r\n"
     "Host: localhost\r\n"
@@ -421,16 +425,16 @@ void HttpRequestTest::testCreateRequest_with_cookie()
 
 void HttpRequestTest::testCreateProxyRequest()
 {
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
 
   HttpRequest httpRequest;
 
   httpRequest.setRequest(request);
   httpRequest.setSegment(segment);
 
-  string expectedText = "CONNECT localhost:80 HTTP/1.1\r\n"
+  std::string expectedText = "CONNECT localhost:80 HTTP/1.1\r\n"
     "User-Agent: aria2\r\n"
     "Host: localhost:80\r\n"
     "Proxy-Connection: close\r\n"
@@ -452,17 +456,17 @@ void HttpRequestTest::testCreateProxyRequest()
 
 void HttpRequestTest::testIsRangeSatisfied()
 {
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
   request->setKeepAlive(false);
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(0, 1024*1024));
 
   HttpRequest httpRequest;
 
   httpRequest.setRequest(request);
   httpRequest.setSegment(segment);
 
-  RangeHandle range = new Range(0, 0, 0);
+  SharedHandle<Range> range = new Range(0, 0, 0);
 
   CPPUNIT_ASSERT(httpRequest.isRangeSatisfied(range));
 
@@ -505,20 +509,20 @@ void HttpRequestTest::testUserAgent()
 {
   Option option;
 
-  AuthConfigFactoryHandle authConfigFactory = new AuthConfigFactory(&option);
-  AuthConfigFactorySingleton::instance(authConfigFactory);
+  SharedHandle<AuthConfigFactory> authConfigFactory = new AuthConfigFactory(&option);
+  SingletonHolder<SharedHandle<AuthConfigFactory> >::instance(authConfigFactory);
 
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost:8080/archives/aria2-1.0.0.tar.bz2");
 
-  SegmentHandle segment = new PiecedSegment(1024, new Piece(0, 1024));
+  SharedHandle<Segment> segment = new PiecedSegment(1024, new Piece(0, 1024));
 
   HttpRequest httpRequest;
   httpRequest.setRequest(request);
   httpRequest.setSegment(segment);
   httpRequest.setUserAgent("aria2 (Linux)");
 
-  string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
+  std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n"
     "User-Agent: aria2 (Linux)\r\n"
     "Accept: */*\r\n"
     "Host: localhost:8080\r\n"
@@ -529,7 +533,7 @@ void HttpRequestTest::testUserAgent()
 
   CPPUNIT_ASSERT_EQUAL(expectedText, httpRequest.createRequest());
 
-  string expectedTextForProxy = "CONNECT localhost:8080 HTTP/1.1\r\n"
+  std::string expectedTextForProxy = "CONNECT localhost:8080 HTTP/1.1\r\n"
     "User-Agent: aria2 (Linux)\r\n"
     "Host: localhost:8080\r\n"
     "Proxy-Connection: close\r\n"
@@ -537,3 +541,5 @@ void HttpRequestTest::testUserAgent()
 
   CPPUNIT_ASSERT_EQUAL(expectedTextForProxy, httpRequest.createProxyRequest());
 }
+
+} // namespace aria2
diff --git a/test/HttpResponseTest.cc b/test/HttpResponseTest.cc
index c71ca830..a46d6239 100644
--- a/test/HttpResponseTest.cc
+++ b/test/HttpResponseTest.cc
@@ -2,9 +2,14 @@
 #include "prefs.h"
 #include "PiecedSegment.h"
 #include "Piece.h"
+#include "TransferEncoding.h"
+#include "Request.h"
+#include "HttpHeader.h"
+#include "HttpRequest.h"
+#include "Exception.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class HttpResponseTest : public CppUnit::TestFixture {
 
@@ -67,7 +72,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
 {
   HttpResponse httpResponse;
 
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Content-Length", "4294967296");
 
   httpResponse.setHttpHeader(httpHeader);
@@ -79,7 +84,7 @@ void HttpResponseTest::testGetEntityLength()
 {
   HttpResponse httpResponse;
 
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Content-Length", "4294967296");
 
   httpResponse.setHttpHeader(httpHeader);
@@ -95,89 +100,89 @@ void HttpResponseTest::testGetEntityLength()
 void HttpResponseTest::testGetContentType()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("content-type", "application/octet-stream");
   httpResponse.setHttpHeader(httpHeader);
-  CPPUNIT_ASSERT_EQUAL(string("application/octet-stream"),
+  CPPUNIT_ASSERT_EQUAL(std::string("application/octet-stream"),
 		       httpResponse.getContentType());
 }
 
 void HttpResponseTest::testDeterminFilename_without_ContentDisposition()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
-  HttpRequestHandle httpRequest = new HttpRequest();
-  RequestHandle request = new Request();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
   httpResponse.setHttpHeader(httpHeader);
   httpResponse.setHttpRequest(httpRequest);
 
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"),
 		       httpResponse.determinFilename());
 }
 
 void HttpResponseTest::testDeterminFilename_with_ContentDisposition_zero_length()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Content-Disposition", "attachment; filename=\"\"");
-  HttpRequestHandle httpRequest = new HttpRequest();
-  RequestHandle request = new Request();
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
   httpResponse.setHttpHeader(httpHeader);
   httpResponse.setHttpRequest(httpRequest);
 
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"),
 		       httpResponse.determinFilename());
 }
 
 void HttpResponseTest::testDeterminFilename_with_ContentDisposition()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Content-Disposition", "attachment; filename=\"aria2-current.tar.bz2\"");
-  HttpRequestHandle httpRequest = new HttpRequest();
-  RequestHandle request = new Request();
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   httpRequest->setRequest(request);
 
   httpResponse.setHttpHeader(httpHeader);
   httpResponse.setHttpRequest(httpRequest);
 
-  CPPUNIT_ASSERT_EQUAL(string("aria2-current.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-current.tar.bz2"),
 		       httpResponse.determinFilename());
 }
 
 void HttpResponseTest::testGetRedirectURI_without_Location()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL(string(""),
+  CPPUNIT_ASSERT_EQUAL(std::string(""),
 		       httpResponse.getRedirectURI());  
 }
 
 void HttpResponseTest::testGetRedirectURI_with_Location()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Location", "http://localhost/download/aria2-1.0.0.tar.bz2");
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/download/aria2-1.0.0.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/download/aria2-1.0.0.tar.bz2"),
 		       httpResponse.getRedirectURI());
 }
 
 void HttpResponseTest::testIsRedirect()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpHeader->put("Location", "http://localhost/download/aria2-1.0.0.tar.bz2");
 
   httpResponse.setHttpHeader(httpHeader);
@@ -193,7 +198,7 @@ void HttpResponseTest::testIsRedirect()
 void HttpResponseTest::testIsTransferEncodingSpecified()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -207,21 +212,21 @@ void HttpResponseTest::testIsTransferEncodingSpecified()
 void HttpResponseTest::testGetTransferEncoding()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL(string(""), httpResponse.getTransferEncoding());  
+  CPPUNIT_ASSERT_EQUAL(std::string(""), httpResponse.getTransferEncoding());  
 
   httpHeader->put("Transfer-Encoding", "chunked");
 
-  CPPUNIT_ASSERT_EQUAL(string("chunked"), httpResponse.getTransferEncoding());
+  CPPUNIT_ASSERT_EQUAL(std::string("chunked"), httpResponse.getTransferEncoding());
 }
 
 void HttpResponseTest::testGetTransferDecoder()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
 
   httpResponse.setHttpHeader(httpHeader);
 
@@ -255,7 +260,7 @@ void HttpResponseTest::testValidateResponse()
   }
 
   httpResponse.setStatus(304);
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpResponse.setHttpHeader(httpHeader);
   try {
     httpResponse.validateResponse();
@@ -277,13 +282,13 @@ void HttpResponseTest::testValidateResponse()
 void HttpResponseTest::testValidateResponse_good_range()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpResponse.setHttpHeader(httpHeader);
 
-  HttpRequestHandle httpRequest = new HttpRequest();
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
   httpRequest->setSegment(segment);
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   request->setKeepAlive(false);
   httpRequest->setRequest(request);
@@ -294,7 +299,7 @@ void HttpResponseTest::testValidateResponse_good_range()
   try {
     httpResponse.validateResponse();
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
     CPPUNIT_FAIL("exception must not be thrown.");
   }
@@ -303,13 +308,13 @@ void HttpResponseTest::testValidateResponse_good_range()
 void HttpResponseTest::testValidateResponse_bad_range()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpResponse.setHttpHeader(httpHeader);
 
-  HttpRequestHandle httpRequest = new HttpRequest();
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
   httpRequest->setSegment(segment);
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   request->setKeepAlive(false);
   httpRequest->setRequest(request);
@@ -328,13 +333,13 @@ void HttpResponseTest::testValidateResponse_bad_range()
 void HttpResponseTest::testValidateResponse_chunked()
 {
   HttpResponse httpResponse;
-  HttpHeaderHandle httpHeader = new HttpHeader();
+  SharedHandle<HttpHeader> httpHeader = new HttpHeader();
   httpResponse.setHttpHeader(httpHeader);
 
-  HttpRequestHandle httpRequest = new HttpRequest();
-  SegmentHandle segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
+  SharedHandle<HttpRequest> httpRequest = new HttpRequest();
+  SharedHandle<Segment> segment = new PiecedSegment(1024*1024, new Piece(1, 1024*1024));
   httpRequest->setSegment(segment);
-  RequestHandle request = new Request();
+  SharedHandle<Request> request = new Request();
   request->setUrl("http://localhost/archives/aria2-1.0.0.tar.bz2");
   request->setKeepAlive(false);
   httpRequest->setRequest(request);
@@ -351,3 +356,5 @@ void HttpResponseTest::testValidateResponse_chunked()
     CPPUNIT_FAIL("exception must not be thrown.");
   }
 }
+
+} // namespace aria2
diff --git a/test/IteratableChecksumValidatorTest.cc b/test/IteratableChecksumValidatorTest.cc
index 312e2d6c..4ce9f58b 100644
--- a/test/IteratableChecksumValidatorTest.cc
+++ b/test/IteratableChecksumValidatorTest.cc
@@ -3,9 +3,10 @@
 #include "DefaultPieceStorage.h"
 #include "Option.h"
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class IteratableChecksumValidatorTest:public CppUnit::TestFixture {
 
@@ -28,11 +29,11 @@ CPPUNIT_TEST_SUITE_REGISTRATION( IteratableChecksumValidatorTest );
 
 void IteratableChecksumValidatorTest::testValidate() {
   Option option;
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(100, 250, "chunkChecksumTestFile250.txt");
   dctx->setChecksum("898a81b8e0181280ae2ee1b81e269196d91e869a");
   dctx->setChecksumHashAlgo("sha1");
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, &option);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, &option);
   ps->initStorage();
   ps->getDiskAdaptor()->openFile();
 
@@ -47,11 +48,11 @@ void IteratableChecksumValidatorTest::testValidate() {
 
 void IteratableChecksumValidatorTest::testValidate_fail() {
   Option option;
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(100, 250, "chunkChecksumTestFile250.txt");
-  dctx->setChecksum(string(40, '0')); // set wrong checksum
+  dctx->setChecksum(std::string(40, '0')); // set wrong checksum
   dctx->setChecksumHashAlgo("sha1");
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, &option);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, &option);
   ps->initStorage();
   ps->getDiskAdaptor()->openFile();
 
@@ -64,3 +65,5 @@ void IteratableChecksumValidatorTest::testValidate_fail() {
 
   CPPUNIT_ASSERT(!ps->downloadFinished());
 }
+
+} // namespace aria2
diff --git a/test/IteratableChunkChecksumValidatorTest.cc b/test/IteratableChunkChecksumValidatorTest.cc
index c410c665..52e0cc0a 100644
--- a/test/IteratableChunkChecksumValidatorTest.cc
+++ b/test/IteratableChunkChecksumValidatorTest.cc
@@ -3,9 +3,10 @@
 #include "DefaultPieceStorage.h"
 #include "Option.h"
 #include "DiskAdaptor.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class IteratableChunkChecksumValidatorTest:public CppUnit::TestFixture {
 
@@ -31,11 +32,11 @@ const char* IteratableChunkChecksumValidatorTest::csArray[] = { "29b0e7878271645
 
 void IteratableChunkChecksumValidatorTest::testValidate() {
   Option option;
-  SingleFileDownloadContextHandle dctx =
+  SharedHandle<SingleFileDownloadContext> dctx =
     new SingleFileDownloadContext(100, 250, "chunkChecksumTestFile250.txt");
-  dctx->setPieceHashes(Strings(&csArray[0], &csArray[3]));
+  dctx->setPieceHashes(std::deque<std::string>(&csArray[0], &csArray[3]));
   dctx->setPieceHashAlgo("sha1");
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, &option);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, &option);
   ps->initStorage();
   ps->getDiskAdaptor()->openFile();
 
@@ -51,7 +52,7 @@ void IteratableChunkChecksumValidatorTest::testValidate() {
   CPPUNIT_ASSERT(ps->downloadFinished());
 
   // make the test fail
-  Strings badHashes(&csArray[0], &csArray[3]);
+  std::deque<std::string> badHashes(&csArray[0], &csArray[3]);
   badHashes[1] = "ffffffffffffffffffffffffffffffffffffffff";
   dctx->setPieceHashes(badHashes);
 
@@ -64,3 +65,5 @@ void IteratableChunkChecksumValidatorTest::testValidate() {
   CPPUNIT_ASSERT(!ps->hasPiece(1));
   CPPUNIT_ASSERT(ps->hasPiece(2));
 }
+
+} // namespace aria2
diff --git a/test/ListTest.cc b/test/ListTest.cc
index 8652c383..c36b2515 100644
--- a/test/ListTest.cc
+++ b/test/ListTest.cc
@@ -3,7 +3,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class ListTest:public CppUnit::TestFixture {
 
@@ -31,3 +31,4 @@ void ListTest::testAdd() {
   CPPUNIT_ASSERT_EQUAL(2, (int)l.getList().size());
 }
 
+} // namespace aria2
diff --git a/test/Makefile.am b/test/Makefile.am
index e8506096..afab249f 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -21,8 +21,7 @@ aria2c_SOURCES = AllTest.cc\
 	ParameterizedStringParserTest.cc\
 	UtilTest.cc\
 	AlphaNumberDecoratorTest.cc\
-	FileUriListParserTest.cc\
-	StreamUriListParserTest.cc\
+	UriListParserTest.cc\
 	HttpHeaderProcessorTest.cc\
 	CookieBoxTest.cc\
 	RequestTest.cc\
@@ -47,7 +46,6 @@ aria2c_SOURCES = AllTest.cc\
 	DefaultDiskWriterTest.cc\
 	FeatureConfigTest.cc\
 	SpeedCalcTest.cc\
-	FixedNumberRandomizer.h\
 	MultiDiskAdaptorTest.cc\
 	MultiFileAllocationIteratorTest.cc
 
@@ -83,7 +81,6 @@ aria2c_SOURCES += BtAllowedFastMessageTest.cc\
 	MockBtMessage.h\
 	MockBtMessageDispatcher.h\
 	MockBtMessageFactory.h\
-	ShaVisitorTest.cc\
 	DefaultPeerListProcessorTest.cc\
 	AnnounceListTest.cc\
 	DefaultPeerStorageTest.cc\
@@ -106,7 +103,7 @@ aria2c_SOURCES += BtAllowedFastMessageTest.cc\
 	HandshakeExtensionMessageTest.cc\
 	UTPexExtensionMessageTest.cc\
 	DefaultBtMessageFactoryTest.cc\
-	DefaultExtensionMessageFactoryTest.cc
+	DefaultExtensionMessageFactoryTest.cc\
 	DHTNodeTest.cc\
 	DHTBucketTest.cc\
 	DHTRoutingTableTest.cc\
diff --git a/test/Makefile.in b/test/Makefile.in
index f0b7d25f..192c346e 100644
--- a/test/Makefile.in
+++ b/test/Makefile.in
@@ -66,7 +66,6 @@ check_PROGRAMS = $(am__EXEEXT_1)
 @ENABLE_BITTORRENT_TRUE@	MockBtMessage.h\
 @ENABLE_BITTORRENT_TRUE@	MockBtMessageDispatcher.h\
 @ENABLE_BITTORRENT_TRUE@	MockBtMessageFactory.h\
-@ENABLE_BITTORRENT_TRUE@	ShaVisitorTest.cc\
 @ENABLE_BITTORRENT_TRUE@	DefaultPeerListProcessorTest.cc\
 @ENABLE_BITTORRENT_TRUE@	AnnounceListTest.cc\
 @ENABLE_BITTORRENT_TRUE@	DefaultPeerStorageTest.cc\
@@ -89,7 +88,31 @@ check_PROGRAMS = $(am__EXEEXT_1)
 @ENABLE_BITTORRENT_TRUE@	HandshakeExtensionMessageTest.cc\
 @ENABLE_BITTORRENT_TRUE@	UTPexExtensionMessageTest.cc\
 @ENABLE_BITTORRENT_TRUE@	DefaultBtMessageFactoryTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DefaultExtensionMessageFactoryTest.cc
+@ENABLE_BITTORRENT_TRUE@	DefaultExtensionMessageFactoryTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTNodeTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTBucketTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerEntryTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTConnectionImplTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTPingMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTPingReplyMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTFindNodeMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTFindNodeReplyMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTGetPeersMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTGetPeersReplyMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerReplyMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTUnknownMessageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTMessageFactoryImplTest.cc\
+@ENABLE_BITTORRENT_TRUE@	BNodeTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceEntryTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceStorageTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTTokenTrackerTest.cc\
+@ENABLE_BITTORRENT_TRUE@	XORCloserTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTIDCloserTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableSerializerTest.cc\
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableDeserializerTest.cc
 
 @ENABLE_METALINK_TRUE@am__append_3 = MetalinkerTest.cc\
 @ENABLE_METALINK_TRUE@	MetalinkEntryTest.cc\
@@ -135,8 +158,7 @@ am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \
 	DefaultBtProgressInfoFileTest.cc \
 	SingleFileDownloadContextTest.cc RequestGroupTest.cc \
 	PStringBuildVisitorTest.cc ParameterizedStringParserTest.cc \
-	UtilTest.cc AlphaNumberDecoratorTest.cc \
-	FileUriListParserTest.cc StreamUriListParserTest.cc \
+	UtilTest.cc AlphaNumberDecoratorTest.cc UriListParserTest.cc \
 	HttpHeaderProcessorTest.cc CookieBoxTest.cc RequestTest.cc \
 	CookieParserTest.cc HttpRequestTest.cc CookieBoxFactoryTest.cc \
 	RequestGroupManTest.cc AuthConfigFactoryTest.cc \
@@ -145,9 +167,8 @@ am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \
 	NetrcTest.cc SingletonHolderTest.cc HttpHeaderTest.cc \
 	HttpResponseTest.cc SharedHandleTest.cc ChunkedEncodingTest.cc \
 	FileTest.cc OptionTest.cc DefaultDiskWriterTest.cc \
-	FeatureConfigTest.cc SpeedCalcTest.cc FixedNumberRandomizer.h \
-	MultiDiskAdaptorTest.cc MultiFileAllocationIteratorTest.cc \
-	MessageDigestHelperTest.cc \
+	FeatureConfigTest.cc SpeedCalcTest.cc MultiDiskAdaptorTest.cc \
+	MultiFileAllocationIteratorTest.cc MessageDigestHelperTest.cc \
 	IteratableChunkChecksumValidatorTest.cc \
 	IteratableChecksumValidatorTest.cc BtAllowedFastMessageTest.cc \
 	BtBitfieldMessageTest.cc BtCancelMessageTest.cc \
@@ -162,17 +183,29 @@ am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \
 	DefaultBtContextTest.cc DefaultBtMessageDispatcherTest.cc \
 	DefaultBtRequestFactoryTest.cc MockBtMessage.h \
 	MockBtMessageDispatcher.h MockBtMessageFactory.h \
-	ShaVisitorTest.cc DefaultPeerListProcessorTest.cc \
-	AnnounceListTest.cc DefaultPeerStorageTest.cc \
-	MockPeerStorage.h DataTest.cc DictionaryTest.cc ListTest.cc \
-	MetaFileUtilTest.cc ByteArrayDiskWriterTest.cc PeerTest.cc \
-	PeerMessageUtilTest.cc ShareRatioSeedCriteriaTest.cc \
-	BtRegistryTest.cc BtDependencyTest.cc \
-	BtPostDownloadHandlerTest.cc DownloadHandlerFactoryTest.cc \
-	TimeSeedCriteriaTest.cc BencodeVisitorTest.cc \
-	BtExtendedMessageTest.cc HandshakeExtensionMessageTest.cc \
-	UTPexExtensionMessageTest.cc DefaultBtMessageFactoryTest.cc \
-	DefaultExtensionMessageFactoryTest.cc MetalinkerTest.cc \
+	DefaultPeerListProcessorTest.cc AnnounceListTest.cc \
+	DefaultPeerStorageTest.cc MockPeerStorage.h DataTest.cc \
+	DictionaryTest.cc ListTest.cc MetaFileUtilTest.cc \
+	ByteArrayDiskWriterTest.cc PeerTest.cc PeerMessageUtilTest.cc \
+	ShareRatioSeedCriteriaTest.cc BtRegistryTest.cc \
+	BtDependencyTest.cc BtPostDownloadHandlerTest.cc \
+	DownloadHandlerFactoryTest.cc TimeSeedCriteriaTest.cc \
+	BencodeVisitorTest.cc BtExtendedMessageTest.cc \
+	HandshakeExtensionMessageTest.cc UTPexExtensionMessageTest.cc \
+	DefaultBtMessageFactoryTest.cc \
+	DefaultExtensionMessageFactoryTest.cc DHTNodeTest.cc \
+	DHTBucketTest.cc DHTRoutingTableTest.cc \
+	DHTMessageTrackerEntryTest.cc DHTMessageTrackerTest.cc \
+	DHTConnectionImplTest.cc DHTPingMessageTest.cc \
+	DHTPingReplyMessageTest.cc DHTFindNodeMessageTest.cc \
+	DHTFindNodeReplyMessageTest.cc DHTGetPeersMessageTest.cc \
+	DHTGetPeersReplyMessageTest.cc DHTAnnouncePeerMessageTest.cc \
+	DHTAnnouncePeerReplyMessageTest.cc DHTUnknownMessageTest.cc \
+	DHTMessageFactoryImplTest.cc BNodeTest.cc \
+	DHTPeerAnnounceEntryTest.cc DHTPeerAnnounceStorageTest.cc \
+	DHTTokenTrackerTest.cc XORCloserTest.cc DHTIDCloserTest.cc \
+	DHTRoutingTableSerializerTest.cc \
+	DHTRoutingTableDeserializerTest.cc MetalinkerTest.cc \
 	MetalinkEntryTest.cc Metalink2RequestGroupTest.cc \
 	MetalinkPostDownloadHandlerTest.cc MetalinkHelperTest.cc \
 	MetalinkParserControllerTest.cc MetalinkProcessorTest.cc
@@ -203,7 +236,6 @@ am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \
 @ENABLE_BITTORRENT_TRUE@	DefaultBtContextTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultBtMessageDispatcherTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultBtRequestFactoryTest.$(OBJEXT) \
-@ENABLE_BITTORRENT_TRUE@	ShaVisitorTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultPeerListProcessorTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	AnnounceListTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultPeerStorageTest.$(OBJEXT) \
@@ -225,7 +257,31 @@ am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \
 @ENABLE_BITTORRENT_TRUE@	HandshakeExtensionMessageTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	UTPexExtensionMessageTest.$(OBJEXT) \
 @ENABLE_BITTORRENT_TRUE@	DefaultBtMessageFactoryTest.$(OBJEXT) \
-@ENABLE_BITTORRENT_TRUE@	DefaultExtensionMessageFactoryTest.$(OBJEXT)
+@ENABLE_BITTORRENT_TRUE@	DefaultExtensionMessageFactoryTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTNodeTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTBucketTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerEntryTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTConnectionImplTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTPingMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTPingReplyMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTFindNodeMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTFindNodeReplyMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTGetPeersMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTGetPeersReplyMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerReplyMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTUnknownMessageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTMessageFactoryImplTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	BNodeTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceEntryTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceStorageTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTTokenTrackerTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	XORCloserTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTIDCloserTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableSerializerTest.$(OBJEXT) \
+@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableDeserializerTest.$(OBJEXT)
 @ENABLE_METALINK_TRUE@am__objects_3 = MetalinkerTest.$(OBJEXT) \
 @ENABLE_METALINK_TRUE@	MetalinkEntryTest.$(OBJEXT) \
 @ENABLE_METALINK_TRUE@	Metalink2RequestGroupTest.$(OBJEXT) \
@@ -245,9 +301,7 @@ am_aria2c_OBJECTS = AllTest.$(OBJEXT) SocketCoreTest.$(OBJEXT) \
 	SingleFileDownloadContextTest.$(OBJEXT) \
 	RequestGroupTest.$(OBJEXT) PStringBuildVisitorTest.$(OBJEXT) \
 	ParameterizedStringParserTest.$(OBJEXT) UtilTest.$(OBJEXT) \
-	AlphaNumberDecoratorTest.$(OBJEXT) \
-	FileUriListParserTest.$(OBJEXT) \
-	StreamUriListParserTest.$(OBJEXT) \
+	AlphaNumberDecoratorTest.$(OBJEXT) UriListParserTest.$(OBJEXT) \
 	HttpHeaderProcessorTest.$(OBJEXT) CookieBoxTest.$(OBJEXT) \
 	RequestTest.$(OBJEXT) CookieParserTest.$(OBJEXT) \
 	HttpRequestTest.$(OBJEXT) CookieBoxFactoryTest.$(OBJEXT) \
@@ -487,8 +541,7 @@ aria2c_SOURCES = AllTest.cc SocketCoreTest.cc array_funTest.cc \
 	DefaultBtProgressInfoFileTest.cc \
 	SingleFileDownloadContextTest.cc RequestGroupTest.cc \
 	PStringBuildVisitorTest.cc ParameterizedStringParserTest.cc \
-	UtilTest.cc AlphaNumberDecoratorTest.cc \
-	FileUriListParserTest.cc StreamUriListParserTest.cc \
+	UtilTest.cc AlphaNumberDecoratorTest.cc UriListParserTest.cc \
 	HttpHeaderProcessorTest.cc CookieBoxTest.cc RequestTest.cc \
 	CookieParserTest.cc HttpRequestTest.cc CookieBoxFactoryTest.cc \
 	RequestGroupManTest.cc AuthConfigFactoryTest.cc \
@@ -497,9 +550,9 @@ aria2c_SOURCES = AllTest.cc SocketCoreTest.cc array_funTest.cc \
 	NetrcTest.cc SingletonHolderTest.cc HttpHeaderTest.cc \
 	HttpResponseTest.cc SharedHandleTest.cc ChunkedEncodingTest.cc \
 	FileTest.cc OptionTest.cc DefaultDiskWriterTest.cc \
-	FeatureConfigTest.cc SpeedCalcTest.cc FixedNumberRandomizer.h \
-	MultiDiskAdaptorTest.cc MultiFileAllocationIteratorTest.cc \
-	$(am__append_1) $(am__append_2) $(am__append_3)
+	FeatureConfigTest.cc SpeedCalcTest.cc MultiDiskAdaptorTest.cc \
+	MultiFileAllocationIteratorTest.cc $(am__append_1) \
+	$(am__append_2) $(am__append_3)
 
 #aria2c_CXXFLAGS = ${CPPUNIT_CFLAGS} -I../src -I../lib -Wall -D_FILE_OFFSET_BITS=64
 #aria2c_LDFLAGS = ${CPPUNIT_LIBS}
@@ -567,6 +620,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AlphaNumberDecoratorTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AnnounceListTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AuthConfigFactoryTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BNodeTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Base64Test.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BencodeVisitorTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BitfieldManTest.Po@am__quote@
@@ -596,6 +650,28 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CookieBoxFactoryTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CookieBoxTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CookieParserTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAnnouncePeerMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAnnouncePeerReplyMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTBucketTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTConnectionImplTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTFindNodeMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTFindNodeReplyMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTGetPeersMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTGetPeersReplyMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTIDCloserTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageFactoryImplTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageTrackerEntryTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageTrackerTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTNodeTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerAnnounceEntryTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerAnnounceStorageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPingMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPingReplyMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTableDeserializerTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTableSerializerTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTableTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTTokenTrackerTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTUnknownMessageTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DataTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultAuthResolverTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultBtAnnounceTest.Po@am__quote@
@@ -614,7 +690,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/FeatureConfigTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/FileEntryTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/FileTest.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/FileUriListParserTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/GrowSegmentTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HandshakeExtensionMessageTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HelpItemTest.Po@am__quote@
@@ -651,7 +726,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SegmentManTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SegmentTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SequenceTest.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ShaVisitorTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ShareRatioSeedCriteriaTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SharedHandleTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingleFileAllocationIteratorTest.Po@am__quote@
@@ -659,12 +733,13 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingletonHolderTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SocketCoreTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SpeedCalcTest.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StreamUriListParserTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TagContainerTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TaggedItemTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TimeSeedCriteriaTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/UTPexExtensionMessageTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/UriListParserTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/UtilTest.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/XORCloserTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/a2functionalTest.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/array_funTest.Po@am__quote@
 
@@ -921,30 +996,6 @@ uninstall-am: uninstall-info-am
 	mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
 	uninstall-am uninstall-info-am
 
-@ENABLE_BITTORRENT_TRUE@	DHTNodeTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTBucketTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerEntryTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTMessageTrackerTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTConnectionImplTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTPingMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTPingReplyMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTFindNodeMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTFindNodeReplyMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTGetPeersMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTGetPeersReplyMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTAnnouncePeerReplyMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTUnknownMessageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTMessageFactoryImplTest.cc\
-@ENABLE_BITTORRENT_TRUE@	BNodeTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceEntryTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTPeerAnnounceStorageTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTTokenTrackerTest.cc\
-@ENABLE_BITTORRENT_TRUE@	XORCloserTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTIDCloserTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableSerializerTest.cc\
-@ENABLE_BITTORRENT_TRUE@	DHTRoutingTableDeserializerTest.cc
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
 .NOEXPORT:
diff --git a/test/MessageDigestHelperTest.cc b/test/MessageDigestHelperTest.cc
index cc9cbcf0..3656518e 100644
--- a/test/MessageDigestHelperTest.cc
+++ b/test/MessageDigestHelperTest.cc
@@ -3,7 +3,7 @@
 #include "DefaultDiskWriter.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MessageDigestHelperTest:public CppUnit::TestFixture {
 
@@ -27,24 +27,26 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestHelperTest );
 
 void MessageDigestHelperTest::testDigestDiskWriter() {
-  DiskWriterHandle diskio = new DefaultDiskWriter();
+  SharedHandle<DefaultDiskWriter> diskio = new DefaultDiskWriter();
   diskio->openExistingFile("4096chunk.txt");
-  CPPUNIT_ASSERT_EQUAL(string("608cabc0f2fa18c260cafd974516865c772363d5"),
+  CPPUNIT_ASSERT_EQUAL(std::string("608cabc0f2fa18c260cafd974516865c772363d5"),
 		       MessageDigestHelper::digest("sha1", diskio, 0, 4096));
 
-  CPPUNIT_ASSERT_EQUAL(string("7a4a9ae537ebbbb826b1060e704490ad0f365ead"),
+  CPPUNIT_ASSERT_EQUAL(std::string("7a4a9ae537ebbbb826b1060e704490ad0f365ead"),
 		       MessageDigestHelper::digest("sha1", diskio, 5, 100));
 }
 
 void MessageDigestHelperTest::testDigestFilename()
 {
-  CPPUNIT_ASSERT_EQUAL(string("608cabc0f2fa18c260cafd974516865c772363d5"),
+  CPPUNIT_ASSERT_EQUAL(std::string("608cabc0f2fa18c260cafd974516865c772363d5"),
 		       MessageDigestHelper::digest("sha1", "4096chunk.txt"));
 }
 
 void MessageDigestHelperTest::testDigestData()
 {
-  string data = "aria2";
-  CPPUNIT_ASSERT_EQUAL(string("f36003f22b462ffa184390533c500d8989e9f681"),
+  std::string data = "aria2";
+  CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
 		       MessageDigestHelper::digest("sha1", data.c_str(), data.size()));
 }
+
+} // namespace aria2
diff --git a/test/MetaFileUtilTest.cc b/test/MetaFileUtilTest.cc
index cec564e4..f300fab4 100644
--- a/test/MetaFileUtilTest.cc
+++ b/test/MetaFileUtilTest.cc
@@ -6,7 +6,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MetaFileUtilTest:public CppUnit::TestFixture {
 
@@ -75,3 +75,4 @@ void MetaFileUtilTest::testBdecoding() {
   }
 }
     
+} // namespace aria2
diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc
index dbebf0af..d4bb9327 100644
--- a/test/Metalink2RequestGroupTest.cc
+++ b/test/Metalink2RequestGroupTest.cc
@@ -3,8 +3,12 @@
 #include "prefs.h"
 #include "Option.h"
 #include "RequestGroup.h"
+#include "FileEntry.h"
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class Metalink2RequestGroupTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(Metalink2RequestGroupTest);
@@ -28,49 +32,50 @@ CPPUNIT_TEST_SUITE_REGISTRATION( Metalink2RequestGroupTest );
 
 void Metalink2RequestGroupTest::testGenerate()
 {
-  RequestGroups groups = Metalink2RequestGroup(_option.get()).generate("test.xml");
+  std::deque<SharedHandle<RequestGroup> > groups =
+    Metalink2RequestGroup(_option.get()).generate("test.xml");
   // first file
   {
-    RequestGroupHandle rg = groups[0];
-    Strings uris = rg->getUris();
-    sort(uris.begin(), uris.end());
+    SharedHandle<RequestGroup> rg = groups[0];
+    std::deque<std::string> uris = rg->getUris();
+    std::sort(uris.begin(), uris.end());
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
-    CPPUNIT_ASSERT_EQUAL(string("ftp://ftphost/aria2-0.5.2.tar.bz2"), uris[0]);
-    CPPUNIT_ASSERT_EQUAL(string("http://httphost/aria2-0.5.2.tar.bz2"), uris[1]);
-    SingleFileDownloadContextHandle dctx = rg->getDownloadContext();
+    CPPUNIT_ASSERT_EQUAL(std::string("ftp://ftphost/aria2-0.5.2.tar.bz2"), uris[0]);
+    CPPUNIT_ASSERT_EQUAL(std::string("http://httphost/aria2-0.5.2.tar.bz2"), uris[1]);
+    SharedHandle<SingleFileDownloadContext> dctx = rg->getDownloadContext();
     CPPUNIT_ASSERT(!dctx.isNull());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, dctx->getTotalLength());
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), dctx->getChecksumHashAlgo());
-    CPPUNIT_ASSERT_EQUAL(string("a96cf3f0266b91d87d5124cf94326422800b627d"),
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), dctx->getChecksumHashAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
 			 dctx->getChecksum());
 #endif // ENABLE_MESSAGE_DIGEST
   }
   // second file
   {
-    RequestGroupHandle rg = groups[1];
-    Strings uris = rg->getUris();
+    SharedHandle<RequestGroup> rg = groups[1];
+    std::deque<std::string> uris = rg->getUris();
     CPPUNIT_ASSERT_EQUAL((size_t)2, uris.size());
-    SingleFileDownloadContextHandle dctx = rg->getDownloadContext();
+    SharedHandle<SingleFileDownloadContext> dctx = rg->getDownloadContext();
     CPPUNIT_ASSERT(!dctx.isNull());
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), dctx->getPieceHashAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), dctx->getPieceHashAlgo());
     CPPUNIT_ASSERT_EQUAL((size_t)2, dctx->getPieceHashes().size());
     CPPUNIT_ASSERT_EQUAL((int32_t)262144, dctx->getPieceLength());
-    CPPUNIT_ASSERT_EQUAL(string(""), dctx->getChecksumHashAlgo());
-    CPPUNIT_ASSERT_EQUAL(string(""), dctx->getChecksum());
+    CPPUNIT_ASSERT_EQUAL(std::string(""), dctx->getChecksumHashAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string(""), dctx->getChecksum());
 #endif // ENABLE_MESSAGE_DIGEST
   }
 
 #ifdef ENABLE_BITTORRENT
   // fifth file <- downloading .torrent file
   {
-    RequestGroupHandle rg = groups[4];
-    Strings uris = rg->getUris();
+    SharedHandle<RequestGroup> rg = groups[4];
+    std::deque<std::string> uris = rg->getUris();
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
-    CPPUNIT_ASSERT_EQUAL(string("http://host/torrent-http.integrated.torrent"),
+    CPPUNIT_ASSERT_EQUAL(std::string("http://host/torrent-http.integrated.torrent"),
 			 uris[0]);
-    SingleFileDownloadContextHandle dctx = rg->getDownloadContext();
+    SharedHandle<SingleFileDownloadContext> dctx = rg->getDownloadContext();
     CPPUNIT_ASSERT(!dctx.isNull());
   }
 #endif // ENABLE_BITTORRENT
@@ -78,14 +83,16 @@ void Metalink2RequestGroupTest::testGenerate()
   // sixth file <- depends on thrid file
   {
 #ifdef ENABLE_BITTORRENT
-    RequestGroupHandle rg = groups[5];
+    SharedHandle<RequestGroup> rg = groups[5];
 #else
-    RequestGroupHandle rg = groups[4];
+    SharedHandle<RequestGroup> rg = groups[4];
 #endif // ENABLE_BITTORRENT
-    Strings uris = rg->getUris();
+    std::deque<std::string> uris = rg->getUris();
     CPPUNIT_ASSERT_EQUAL((size_t)1, uris.size());
-    CPPUNIT_ASSERT_EQUAL(string("http://host/torrent-http.integrated"), uris[0]);
-    SingleFileDownloadContextHandle dctx = rg->getDownloadContext();
+    CPPUNIT_ASSERT_EQUAL(std::string("http://host/torrent-http.integrated"), uris[0]);
+    SharedHandle<SingleFileDownloadContext> dctx = rg->getDownloadContext();
     CPPUNIT_ASSERT(!dctx.isNull());
   }
 }
+
+} // namespace aria2
diff --git a/test/MetalinkEntryTest.cc b/test/MetalinkEntryTest.cc
index 5b27f442..14447894 100644
--- a/test/MetalinkEntryTest.cc
+++ b/test/MetalinkEntryTest.cc
@@ -1,7 +1,8 @@
 #include "MetalinkEntry.h"
+#include "MetalinkResource.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MetalinkEntryTest:public CppUnit::TestFixture {
 
@@ -28,8 +29,8 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkEntryTest );
 
-MetalinkEntryHandle createTestEntry() {
-  MetalinkEntryHandle entry = new MetalinkEntry();
+MetalinkEntry* createTestEntry() {
+  MetalinkEntry* entry = new MetalinkEntry();
   MetalinkResource* res1 = new MetalinkResource();
   res1->url = "ftp://myhost/aria2.tar.bz2";
   res1->type = MetalinkResource::TYPE_FTP;
@@ -65,7 +66,7 @@ MetalinkEntryHandle createTestEntry() {
 }
 
 void MetalinkEntryTest::testDropUnsupportedResource() {
-  MetalinkEntryHandle entry = createTestEntry();
+  MetalinkEntry* entry = createTestEntry();
 
   entry->dropUnsupportedResource();
 #if defined ENABLE_SSL && ENABLE_BITTORRENT
@@ -76,7 +77,8 @@ void MetalinkEntryTest::testDropUnsupportedResource() {
   CPPUNIT_ASSERT_EQUAL(2, (int)entry->resources.size());
 #endif // ENABLE_MESSAGE_DIGEST
   
-  MetalinkResources::const_iterator itr = entry->resources.begin();
+  std::deque<SharedHandle<MetalinkResource> >::const_iterator itr =
+    entry->resources.begin();
   CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP,
 		       (*itr++)->type);
   CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP,
@@ -89,10 +91,11 @@ void MetalinkEntryTest::testDropUnsupportedResource() {
   CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTPS,
 		       (*itr++)->type);
 #endif // ENABLE_SSL
+  delete entry;
 }
 
 void MetalinkEntryTest::testReorderResourcesByPreference() {
-  MetalinkEntryHandle entry = createTestEntry();
+  MetalinkEntry* entry = createTestEntry();
   
   entry->reorderResourcesByPreference();
 
@@ -101,37 +104,45 @@ void MetalinkEntryTest::testReorderResourcesByPreference() {
   CPPUNIT_ASSERT_EQUAL((int32_t)60, entry->resources.at(2)->preference);
   CPPUNIT_ASSERT_EQUAL((int32_t)50, entry->resources.at(3)->preference);
   CPPUNIT_ASSERT_EQUAL((int32_t)10, entry->resources.at(4)->preference);
+
+  delete entry;
 }
 
 void MetalinkEntryTest::testSetLocationPreference()
 {
-  MetalinkEntryHandle entry = createTestEntry();
+  MetalinkEntry* entry = createTestEntry();
 
   const char* locationsSrc[] = { "jp", "al", "RO" };
 
-  Strings locations(&locationsSrc[0], &locationsSrc[3]);
+  std::deque<std::string> locations(&locationsSrc[0], &locationsSrc[3]);
 
   entry->setLocationPreference(locations, 100);
 
-  CPPUNIT_ASSERT_EQUAL(string("RO"), entry->resources[0]->location);
+  CPPUNIT_ASSERT_EQUAL(std::string("RO"), entry->resources[0]->location);
   CPPUNIT_ASSERT_EQUAL((int32_t)150, entry->resources[0]->preference);
-  CPPUNIT_ASSERT_EQUAL(string("AT"), entry->resources[1]->location);
+  CPPUNIT_ASSERT_EQUAL(std::string("AT"), entry->resources[1]->location);
   CPPUNIT_ASSERT_EQUAL((int32_t)100, entry->resources[1]->preference);
-  CPPUNIT_ASSERT_EQUAL(string("AL"), entry->resources[2]->location);
+  CPPUNIT_ASSERT_EQUAL(std::string("AL"), entry->resources[2]->location);
   CPPUNIT_ASSERT_EQUAL((int32_t)160, entry->resources[2]->preference);
-  CPPUNIT_ASSERT_EQUAL(string("AD"), entry->resources[3]->location);
+  CPPUNIT_ASSERT_EQUAL(std::string("AD"), entry->resources[3]->location);
   CPPUNIT_ASSERT_EQUAL((int32_t)10, entry->resources[3]->preference);
-  CPPUNIT_ASSERT_EQUAL(string("JP"), entry->resources[4]->location);
+  CPPUNIT_ASSERT_EQUAL(std::string("JP"), entry->resources[4]->location);
   CPPUNIT_ASSERT_EQUAL((int32_t)190, entry->resources[4]->preference);
+
+  delete entry;
 }
 
 void MetalinkEntryTest::testSetProtocolPreference()
 {
-  MetalinkEntryHandle entry = createTestEntry();
+  MetalinkEntry* entry = createTestEntry();
   entry->setProtocolPreference("http", 1);
   CPPUNIT_ASSERT_EQUAL(50, entry->resources[0]->preference); // ftp
   CPPUNIT_ASSERT_EQUAL(101, entry->resources[1]->preference); // http, +1
   CPPUNIT_ASSERT_EQUAL(60, entry->resources[2]->preference); // bittorrent
   CPPUNIT_ASSERT_EQUAL(10, entry->resources[3]->preference); // not supported
   CPPUNIT_ASSERT_EQUAL(90, entry->resources[4]->preference); // https
+
+  delete entry;
 }
+
+} // namespace aria2
diff --git a/test/MetalinkHelperTest.cc b/test/MetalinkHelperTest.cc
index 2a50d801..4e732d64 100644
--- a/test/MetalinkHelperTest.cc
+++ b/test/MetalinkHelperTest.cc
@@ -4,7 +4,7 @@
 #include "prefs.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MetalinkHelperTest:public CppUnit::TestFixture {
 
@@ -29,7 +29,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkHelperTest );
 void MetalinkHelperTest::testParseAndQuery()
 {
   Option option;
-  MetalinkEntries entries = MetalinkHelper::parseAndQuery("test.xml", &option);
+  std::deque<SharedHandle<MetalinkEntry> > entries =
+    MetalinkHelper::parseAndQuery("test.xml", &option);
   CPPUNIT_ASSERT_EQUAL((size_t)5, entries.size());
 }
 
@@ -37,8 +38,11 @@ void MetalinkHelperTest::testParseAndQuery_version()
 {
   Option option;
   option.put(PREF_METALINK_VERSION, "0.5.1");
-  MetalinkEntries entries = MetalinkHelper::parseAndQuery("test.xml", &option);
+  std::deque<SharedHandle<MetalinkEntry> > entries =
+    MetalinkHelper::parseAndQuery("test.xml", &option);
   CPPUNIT_ASSERT_EQUAL((size_t)1, entries.size());
-  MetalinkEntryHandle entry = entries.front();
-  CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.1.tar.bz2"), entry->getPath());
+  SharedHandle<MetalinkEntry> entry = entries.front();
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry->getPath());
 }
+
+} // namespace aria2
diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc
index 9fca46dc..64b04038 100644
--- a/test/MetalinkParserControllerTest.cc
+++ b/test/MetalinkParserControllerTest.cc
@@ -2,12 +2,15 @@
 #include "Metalinker.h"
 #include "MetalinkEntry.h"
 #include "MetalinkResource.h"
+#include "FileEntry.h"
 #ifdef ENABLE_MESSAGE_DIGEST
-#include "Checksum.h"
-#include "ChunkChecksum.h"
+# include "Checksum.h"
+# include "ChunkChecksum.h"
 #endif // ENABLE_MESSAGE_DIGEST
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class MetalinkParserControllerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MetalinkParserControllerTest);
@@ -49,15 +52,15 @@ void MetalinkParserControllerTest::testEntryTransaction()
   ctrl.setOSOfEntry("Linux");
   ctrl.commitEntryTransaction();
   {
-    MetalinkerHandle m = ctrl.getResult();
+    SharedHandle<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->entries.size());
-    MetalinkEntryHandle e = m->entries.front();
-    CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), e->file->getPath());
+    SharedHandle<MetalinkEntry> e = m->entries.front();
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)1024*1024, e->file->getLength());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, e->file->getOffset());
-    CPPUNIT_ASSERT_EQUAL(string("1.0"), e->version);
-    CPPUNIT_ASSERT_EQUAL(string("ja_JP"), e->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux"), e->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("1.0"), e->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux"), e->os);
   }
   ctrl.newEntryTransaction();
   ctrl.cancelEntryTransaction();
@@ -76,12 +79,12 @@ void MetalinkParserControllerTest::testResourceTransaction()
   ctrl.setMaxConnectionsOfResource(1);
   ctrl.commitEntryTransaction();
   {
-    MetalinkerHandle m = ctrl.getResult();
+    SharedHandle<Metalinker> m = ctrl.getResult();
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->entries.front()->resources.size());
-    MetalinkResourceHandle res = m->entries.front()->resources[0];
-    CPPUNIT_ASSERT_EQUAL(string("http://mirror/aria2.tar.bz2"), res->url);
+    SharedHandle<MetalinkResource> res = m->entries.front()->resources[0];
+    CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/aria2.tar.bz2"), res->url);
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, res->type);
-    CPPUNIT_ASSERT_EQUAL(string("US"), res->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("US"), res->location);
     CPPUNIT_ASSERT_EQUAL(100, res->preference);
     CPPUNIT_ASSERT_EQUAL(1, res->maxConnections);
   }
@@ -102,10 +105,10 @@ void MetalinkParserControllerTest::testChecksumTransaction()
   ctrl.setHashOfChecksum("hash");
   ctrl.commitEntryTransaction();
   {
-    MetalinkerHandle m = ctrl.getResult();
-    ChecksumHandle md = m->entries.front()->checksum;
-    CPPUNIT_ASSERT_EQUAL(string("md5"), md->getAlgo());
-    CPPUNIT_ASSERT_EQUAL(string("hash"), md->getMessageDigest());
+    SharedHandle<Metalinker> m = ctrl.getResult();
+    SharedHandle<Checksum> md = m->entries.front()->checksum;
+    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("hash"), md->getMessageDigest());
   }
   ctrl.newEntryTransaction();
   ctrl.newChecksumTransaction();
@@ -128,16 +131,16 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
   ctrl.addHashOfChunkChecksum(5, "hash5");
   ctrl.commitEntryTransaction();
   {
-    MetalinkerHandle m = ctrl.getResult();
-    ChunkChecksumHandle md = m->entries.front()->chunkChecksum;
-    CPPUNIT_ASSERT_EQUAL(string("md5"), md->getAlgo());
+    SharedHandle<Metalinker> m = ctrl.getResult();
+    SharedHandle<ChunkChecksum> md = m->entries.front()->chunkChecksum;
+    CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo());
     CPPUNIT_ASSERT_EQUAL(256*1024, md->getChecksumLength());
     CPPUNIT_ASSERT_EQUAL(5, md->countChecksum());
-    CPPUNIT_ASSERT_EQUAL(string("hash1"), md->getChecksums()[0]);
-    CPPUNIT_ASSERT_EQUAL(string("hash2"), md->getChecksums()[1]);
-    CPPUNIT_ASSERT_EQUAL(string("hash3"), md->getChecksums()[2]);
-    CPPUNIT_ASSERT_EQUAL(string("hash4"), md->getChecksums()[3]);
-    CPPUNIT_ASSERT_EQUAL(string("hash5"), md->getChecksums()[4]);
+    CPPUNIT_ASSERT_EQUAL(std::string("hash1"), md->getChecksums()[0]);
+    CPPUNIT_ASSERT_EQUAL(std::string("hash2"), md->getChecksums()[1]);
+    CPPUNIT_ASSERT_EQUAL(std::string("hash3"), md->getChecksums()[2]);
+    CPPUNIT_ASSERT_EQUAL(std::string("hash4"), md->getChecksums()[3]);
+    CPPUNIT_ASSERT_EQUAL(std::string("hash5"), md->getChecksums()[4]);
   }
   ctrl.newEntryTransaction();
   ctrl.newChunkChecksumTransaction();
@@ -146,3 +149,5 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
   CPPUNIT_ASSERT(ctrl.getResult()->entries[1]->chunkChecksum.isNull());
 }
 #endif // ENABLE_MESSAGE_DIGEST
+
+} // namespace aria2
diff --git a/test/MetalinkPostDownloadHandlerTest.cc b/test/MetalinkPostDownloadHandlerTest.cc
index 69caf68b..37cc8738 100644
--- a/test/MetalinkPostDownloadHandlerTest.cc
+++ b/test/MetalinkPostDownloadHandlerTest.cc
@@ -2,8 +2,11 @@
 #include "RequestGroup.h"
 #include "Option.h"
 #include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class MetalinkPostDownloadHandlerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MetalinkPostDownloadHandlerTest);
@@ -27,8 +30,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkPostDownloadHandlerTest );
 void MetalinkPostDownloadHandlerTest::testCanHandle_extension()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.metalink");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.metalink");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
   MetalinkPostDownloadHandler handler;
@@ -42,9 +45,9 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_extension()
 void MetalinkPostDownloadHandlerTest::testCanHandle_contentType()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test");
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test");
   dctx->setContentType("application/metalink+xml");
-  RequestGroup rg(&op, Strings());
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
 
   MetalinkPostDownloadHandler handler;
@@ -58,8 +61,8 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_contentType()
 void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "test.xml");
-  RequestGroup rg(&op, Strings());
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "test.xml");
+  RequestGroup rg(&op, std::deque<std::string>());
   rg.setDownloadContext(dctx);
   rg.initPieceStorage();
 
@@ -71,3 +74,5 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups()
   CPPUNIT_ASSERT_EQUAL((size_t)5, groups.size());
 #endif // ENABLE_BITTORRENT
 }
+
+} // namespace aria2
diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc
index 3151f98a..86650cb3 100644
--- a/test/MetalinkProcessorTest.cc
+++ b/test/MetalinkProcessorTest.cc
@@ -3,8 +3,18 @@
 #include "Exception.h"
 #include "DefaultDiskWriter.h"
 #include "ByteArrayDiskWriter.h"
+#include "MetalinkProcessor.h"
+#include "Metalinker.h"
+#include "MetalinkEntry.h"
+#include "MetalinkResource.h"
+#ifdef ENABLE_MESSAGE_DIGEST
+# include "ChunkChecksum.h"
+# include "Checksum.h"
+#endif // ENABLE_MESSAGE_DIGEST
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class MetalinkProcessorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MetalinkProcessorTest);
@@ -51,68 +61,68 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkProcessorTest );
 
 void MetalinkProcessorTest::testParseFile()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
   try {
-    MetalinkerHandle metalinker = proc->parseFile("test.xml");
+    SharedHandle<Metalinker> metalinker = proc->parseFile("test.xml");
 
-    MetalinkEntries::iterator entryItr = metalinker->entries.begin();
+    std::deque<SharedHandle<MetalinkEntry> >::iterator entryItr = metalinker->entries.begin();
 
-    MetalinkEntryHandle entry1 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), entry1->getPath());
+    SharedHandle<MetalinkEntry> entry1 = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, entry1->getLength());
-    CPPUNIT_ASSERT_EQUAL(string("0.5.2"), entry1->version);
-    CPPUNIT_ASSERT_EQUAL(string("en-US"), entry1->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux-x86"), entry1->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entry1->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entry1->os);
     CPPUNIT_ASSERT_EQUAL((int32_t)1, entry1->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("a96cf3f0266b91d87d5124cf94326422800b627d"),
+    CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
 			 entry1->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), entry1->checksum->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), entry1->checksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
-    MetalinkResources::iterator resourceItr1 = entry1->resources.begin();
-    MetalinkResourceHandle resource1 = *resourceItr1;
+    std::deque<SharedHandle<MetalinkResource> >::iterator resourceItr1 = entry1->resources.begin();
+    SharedHandle<MetalinkResource> resource1 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, resource1->type);
-    CPPUNIT_ASSERT_EQUAL(string("JP"), resource1->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("JP"), resource1->location);
     CPPUNIT_ASSERT_EQUAL((int32_t)100, resource1->preference);
-    CPPUNIT_ASSERT_EQUAL(string("ftp://ftphost/aria2-0.5.2.tar.bz2"),
+    CPPUNIT_ASSERT_EQUAL(std::string("ftp://ftphost/aria2-0.5.2.tar.bz2"),
 			 resource1->url);
     CPPUNIT_ASSERT_EQUAL((int32_t)1, resource1->maxConnections);
 
     resourceItr1++;
-    MetalinkResourceHandle resource2 = *resourceItr1;
+    SharedHandle<MetalinkResource> resource2 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, resource2->type);
-    CPPUNIT_ASSERT_EQUAL(string("US"), resource2->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("US"), resource2->location);
     CPPUNIT_ASSERT_EQUAL((int32_t)100, resource2->preference);
-    CPPUNIT_ASSERT_EQUAL(string("http://httphost/aria2-0.5.2.tar.bz2"),
+    CPPUNIT_ASSERT_EQUAL(std::string("http://httphost/aria2-0.5.2.tar.bz2"),
 			 resource2->url);
     CPPUNIT_ASSERT_EQUAL((int32_t)-1, resource2->maxConnections);
 
     entryItr++;
 
-    MetalinkEntryHandle entry2 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.1.tar.bz2"), entry2->getPath());
+    SharedHandle<MetalinkEntry> entry2 = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)345689, entry2->getLength());
-    CPPUNIT_ASSERT_EQUAL(string("0.5.1"), entry2->version);
-    CPPUNIT_ASSERT_EQUAL(string("ja-JP"), entry2->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux-m68k"), entry2->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entry2->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entry2->os);
     CPPUNIT_ASSERT_EQUAL((int32_t)-1, entry2->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
+    CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
 			 entry2->checksum->getMessageDigest());
     CPPUNIT_ASSERT_EQUAL((int32_t)2, entry2->chunkChecksum->countChecksum());
     CPPUNIT_ASSERT_EQUAL((int32_t)262144, entry2->chunkChecksum->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL(string("179463a88d79cbf0b1923991708aead914f26142"),
+    CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
 			 entry2->chunkChecksum->getChecksum(0));
-    CPPUNIT_ASSERT_EQUAL(string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
+    CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
 			 entry2->chunkChecksum->getChecksum(1));
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), entry2->checksum->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), entry2->checksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
 
     entryItr++;
 
     // test case: verification hash is not provided
-    MetalinkEntryHandle entry3 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("NoVerificationHash"), entry3->getPath());
+    SharedHandle<MetalinkEntry> entry3 = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("NoVerificationHash"), entry3->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(entry3->checksum.isNull());
     CPPUNIT_ASSERT(entry3->chunkChecksum.isNull());
@@ -121,14 +131,14 @@ void MetalinkProcessorTest::testParseFile()
     entryItr++;
 
     // test case: unsupported verification hash is included
-    MetalinkEntryHandle entry4 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
+    SharedHandle<MetalinkEntry> entry4 = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("sha1"),
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"),
 			 entry4->checksum->getAlgo());
-    CPPUNIT_ASSERT_EQUAL(string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
+    CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
 			 entry4->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(string("sha1"),
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"),
 			 entry4->chunkChecksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
 
@@ -141,16 +151,16 @@ void MetalinkProcessorTest::testParseFile()
 
 void MetalinkProcessorTest::testParseFromBinaryStream()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
   DefaultDiskWriterHandle dw = new DefaultDiskWriter();
   dw->openExistingFile("test.xml");
   
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
 
-    MetalinkEntries::iterator entryItr = m->entries.begin();
-    MetalinkEntryHandle entry1 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), entry1->getPath());
+    std::deque<SharedHandle<MetalinkEntry> >::iterator entryItr = m->entries.begin();
+    SharedHandle<MetalinkEntry> entry1 = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -159,38 +169,38 @@ void MetalinkProcessorTest::testParseFromBinaryStream()
 
 void MetalinkProcessorTest::testMalformedXML()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink><files></file></metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
 
 void MetalinkProcessorTest::testMalformedXML2()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink><files></files>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }
 }
 
 void MetalinkProcessorTest::testBadSize()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2-0.5.2.tar.bz2\">"
@@ -203,15 +213,15 @@ void MetalinkProcessorTest::testBadSize()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
 
-    MetalinkEntries::iterator entryItr = m->entries.begin();
-    MetalinkEntryHandle e = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), e->getPath());
+    std::deque<SharedHandle<MetalinkEntry> >::iterator entryItr = m->entries.begin();
+    SharedHandle<MetalinkEntry> e = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, e->getLength());
-    CPPUNIT_ASSERT_EQUAL(string("0.5.2"), e->version);
-    CPPUNIT_ASSERT_EQUAL(string("en-US"), e->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux-x86"), e->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), e->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("en-US"), e->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), e->os);
 
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
@@ -221,8 +231,8 @@ void MetalinkProcessorTest::testBadSize()
 
 void MetalinkProcessorTest::testBadMaxConn()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2-0.5.2.tar.bz2\">"
@@ -236,10 +246,10 @@ void MetalinkProcessorTest::testBadMaxConn()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
 
-    MetalinkEntries::iterator entryItr = m->entries.begin();
-    MetalinkEntryHandle e = *entryItr;
+    std::deque<SharedHandle<MetalinkEntry> >::iterator entryItr = m->entries.begin();
+    SharedHandle<MetalinkEntry> e = *entryItr;
     CPPUNIT_ASSERT_EQUAL((int64_t)43743838, e->getLength());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
@@ -249,8 +259,8 @@ void MetalinkProcessorTest::testBadMaxConn()
 
 void MetalinkProcessorTest::testNoName()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file>"
@@ -269,11 +279,11 @@ void MetalinkProcessorTest::testNoName()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
     CPPUNIT_ASSERT_EQUAL((size_t)1, m->entries.size());
-    MetalinkEntries::iterator entryItr = m->entries.begin();
-    MetalinkEntryHandle e = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), e->getPath());
+    std::deque<SharedHandle<MetalinkEntry> >::iterator entryItr = m->entries.begin();
+    SharedHandle<MetalinkEntry> e = *entryItr;
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -282,8 +292,8 @@ void MetalinkProcessorTest::testNoName()
 
 void MetalinkProcessorTest::testBadURLPrefs()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2-0.5.2.tar.bz2\">"
@@ -299,13 +309,13 @@ void MetalinkProcessorTest::testBadURLPrefs()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    MetalinkResourceHandle r = e->resources[0];
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<MetalinkResource> r = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type);
     CPPUNIT_ASSERT_EQUAL(0, r->preference);
     CPPUNIT_ASSERT_EQUAL(1, r->maxConnections);
-    CPPUNIT_ASSERT_EQUAL(string("JP"), r->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("JP"), r->location);
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -314,8 +324,8 @@ void MetalinkProcessorTest::testBadURLPrefs()
 
 void MetalinkProcessorTest::testBadURLMaxConn()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2-0.5.2.tar.bz2\">"
@@ -331,13 +341,13 @@ void MetalinkProcessorTest::testBadURLMaxConn()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    MetalinkResourceHandle r = e->resources[0];
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<MetalinkResource> r = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r->type);
     CPPUNIT_ASSERT_EQUAL(100, r->preference);
     CPPUNIT_ASSERT_EQUAL(-1, r->maxConnections);
-    CPPUNIT_ASSERT_EQUAL(string("JP"), r->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("JP"), r->location);
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -347,8 +357,8 @@ void MetalinkProcessorTest::testBadURLMaxConn()
 #ifdef ENABLE_MESSAGE_DIGEST
 void MetalinkProcessorTest::testUnsupportedType()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2-0.5.2.tar.bz2\">"
@@ -366,14 +376,14 @@ void MetalinkProcessorTest::testUnsupportedType()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
     CPPUNIT_ASSERT_EQUAL((size_t)3, e->resources.size());
-    MetalinkResourceHandle r1 = e->resources[0];
+    SharedHandle<MetalinkResource> r1 = e->resources[0];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, r1->type);
-    MetalinkResourceHandle r2 = e->resources[1];
+    SharedHandle<MetalinkResource> r2 = e->resources[1];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_NOT_SUPPORTED, r2->type);
-    MetalinkResourceHandle r3 = e->resources[2];
+    SharedHandle<MetalinkResource> r3 = e->resources[2];
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, r3->type);
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
@@ -383,8 +393,8 @@ void MetalinkProcessorTest::testUnsupportedType()
 
 void MetalinkProcessorTest::testMultiplePieces()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2.tar.bz2\">"
@@ -402,11 +412,11 @@ void MetalinkProcessorTest::testMultiplePieces()
 
   try {
     // aria2 prefers sha1
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    ChunkChecksumHandle c = e->chunkChecksum;
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), c->getAlgo());
     CPPUNIT_ASSERT_EQUAL(1024, c->getChecksumLength());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
@@ -416,8 +426,8 @@ void MetalinkProcessorTest::testMultiplePieces()
 
 void MetalinkProcessorTest::testBadPieceNo()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2.tar.bz2\">"
@@ -435,11 +445,11 @@ void MetalinkProcessorTest::testBadPieceNo()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    ChunkChecksumHandle c = e->chunkChecksum;
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
-    CPPUNIT_ASSERT_EQUAL(string("sha256"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha256"), c->getAlgo());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -448,8 +458,8 @@ void MetalinkProcessorTest::testBadPieceNo()
 
 void MetalinkProcessorTest::testBadPieceLength()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2.tar.bz2\">"
@@ -466,11 +476,11 @@ void MetalinkProcessorTest::testBadPieceLength()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    ChunkChecksumHandle c = e->chunkChecksum;
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
-    CPPUNIT_ASSERT_EQUAL(string("sha256"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha256"), c->getAlgo());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
@@ -479,8 +489,8 @@ void MetalinkProcessorTest::testBadPieceLength()
 
 void MetalinkProcessorTest::testUnsupportedType_piece()
 {
-  MetalinkProcessorHandle proc = MetalinkProcessorFactory::newInstance();
-  ByteArrayDiskWriterHandle dw = new ByteArrayDiskWriter();
+  SharedHandle<MetalinkProcessor> proc = MetalinkProcessorFactory::newInstance();
+  SharedHandle<ByteArrayDiskWriter> dw = new ByteArrayDiskWriter();
   dw->setString("<metalink>"
 		"<files>"
 		"<file name=\"aria2.tar.bz2\">"
@@ -497,14 +507,16 @@ void MetalinkProcessorTest::testUnsupportedType_piece()
 		"</metalink>");
 
   try {
-    MetalinkerHandle m = proc->parseFromBinaryStream(dw);
-    MetalinkEntryHandle e = m->entries[0];
-    ChunkChecksumHandle c = e->chunkChecksum;
+    SharedHandle<Metalinker> m = proc->parseFromBinaryStream(dw);
+    SharedHandle<MetalinkEntry> e = m->entries[0];
+    SharedHandle<ChunkChecksum> c = e->chunkChecksum;
  
-    CPPUNIT_ASSERT_EQUAL(string("sha256"), c->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha256"), c->getAlgo());
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
     delete e;
   }
 }
 #endif // ENABLE_MESSAGE_DIGEST
+
+} // namespace aria2
diff --git a/test/MetalinkerTest.cc b/test/MetalinkerTest.cc
index 282d5847..49e39d63 100644
--- a/test/MetalinkerTest.cc
+++ b/test/MetalinkerTest.cc
@@ -1,7 +1,8 @@
 #include "Metalinker.h"
+#include "MetalinkEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MetalinkerTest:public CppUnit::TestFixture {
 
@@ -23,32 +24,31 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( MetalinkerTest );
 
 void MetalinkerTest::testQueryEntry() {
-  MetalinkerHandle metalinker(new Metalinker());
-  MetalinkEntryHandle entry1(new MetalinkEntry());
+  SharedHandle<Metalinker> metalinker(new Metalinker());
+  SharedHandle<MetalinkEntry> entry1(new MetalinkEntry());
   entry1->version = "0.5.2";
   entry1->language = "en-US";
   entry1->os = "Linux-x86";
-  MetalinkEntryHandle entry2(new MetalinkEntry());
+  SharedHandle<MetalinkEntry> entry2(new MetalinkEntry());
   entry2->version = "0.5.1";
   entry2->language = "ja-JP";
   entry2->os = "Linux-m68k";
   metalinker->entries.push_back(entry1);
   metalinker->entries.push_back(entry2);
 
-  string version;
-  string language;
-  string os;
+  std::string version;
+  std::string language;
+  std::string os;
 
   version = "0.5.1";
   language = "ja-JP";
   os = "Linux-m68k";
-  MetalinkEntries entries = metalinker->queryEntry(version,
-						 language,
-						 os);
+  std::deque<SharedHandle<MetalinkEntry> > entries =
+    metalinker->queryEntry(version, language, os);
   CPPUNIT_ASSERT_EQUAL((size_t)1, entries.size());
-  CPPUNIT_ASSERT_EQUAL(string("0.5.1"), entries.at(0)->version);
-  CPPUNIT_ASSERT_EQUAL(string("ja-JP"), entries.at(0)->language);
-  CPPUNIT_ASSERT_EQUAL(string("Linux-m68k"), entries.at(0)->os);
+  CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entries.at(0)->version);
+  CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entries.at(0)->language);
+  CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entries.at(0)->os);
 
   version = "0.6.0";
   language = "";
@@ -61,7 +61,9 @@ void MetalinkerTest::testQueryEntry() {
   os = "";
   entries = metalinker->queryEntry(version, language, os);
   CPPUNIT_ASSERT_EQUAL((size_t)1, entries.size());
-  CPPUNIT_ASSERT_EQUAL(string("0.5.2"), entries.at(0)->version);
-  CPPUNIT_ASSERT_EQUAL(string("en-US"), entries.at(0)->language);
-  CPPUNIT_ASSERT_EQUAL(string("Linux-x86"), entries.at(0)->os);
+  CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entries.at(0)->version);
+  CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entries.at(0)->language);
+  CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entries.at(0)->os);
 }
+
+} // namespace aria2
diff --git a/test/MockBtAnnounce.h b/test/MockBtAnnounce.h
index a34e0cd2..d70f0d49 100644
--- a/test/MockBtAnnounce.h
+++ b/test/MockBtAnnounce.h
@@ -3,11 +3,13 @@
 
 #include "BtAnnounce.h"
 
+namespace aria2 {
+
 class MockBtAnnounce : public BtAnnounce {
 private:
   bool announceReady;
-  string announceUrl;
-  string peerId;
+  std::string announceUrl;
+  std::string peerId;
 public:
   MockBtAnnounce() {}
   virtual ~MockBtAnnounce() {}
@@ -20,11 +22,11 @@ public:
     this->announceReady = flag;
   }
 
-  virtual string getAnnounceUrl() {
+  virtual std::string getAnnounceUrl() {
     return announceUrl;
   }
 
-  void setAnnounceUrl(const string& url) {
+  void setAnnounceUrl(const std::string& url) {
     this->announceUrl = url;
   }
 
@@ -50,13 +52,15 @@ public:
   virtual void shuffleAnnounce() {
   }
 
-  virtual string getPeerId() {
+  virtual std::string getPeerId() {
     return peerId;
   }
 
-  void setPeerId(const string& peerId) {
+  void setPeerId(const std::string& peerId) {
     this->peerId = peerId;
   }
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_BT_ANNOUNCE_H_
diff --git a/test/MockBtContext.h b/test/MockBtContext.h
index d8f41f45..1eade544 100644
--- a/test/MockBtContext.h
+++ b/test/MockBtContext.h
@@ -5,19 +5,21 @@
 #include "Util.h"
 #include "AnnounceTier.h"
 
+namespace aria2 {
+
 class MockBtContext : public BtContext  {
 private:
   unsigned char infoHash[20];
-  Strings pieceHashes;
+  std::deque<std::string> pieceHashes;
   int64_t totalLength;
   FILE_MODE fileMode;
-  string name;
+  std::string name;
   int32_t pieceLength;
   int32_t numPieces;
   unsigned char peerId[20];
-  FileEntries fileEntries;
-  AnnounceTiers announceTiers;
-  Integers fastSet;
+  std::deque<SharedHandle<FileEntry> > fileEntries;
+  std::deque<SharedHandle<AnnounceTier> > announceTiers;
+  std::deque<int32_t> fastSet;
 public:
   MockBtContext():totalLength(0),
 		  pieceLength(0),
@@ -37,19 +39,19 @@ public:
     return sizeof(infoHash);
   }
 
-  virtual string getInfoHashAsString() const {
+  virtual std::string getInfoHashAsString() const {
     return Util::toHex(infoHash, sizeof(infoHash));
   }
 
-  virtual string getPieceHash(int32_t index) const {
+  virtual std::string getPieceHash(int32_t index) const {
     return pieceHashes.at(index);
   }
   
-  virtual const Strings& getPieceHashes() const {
+  virtual const std::deque<std::string>& getPieceHashes() const {
     return pieceHashes;
   }
 
-  void addPieceHash(const string pieceHash) {
+  void addPieceHash(const std::string& pieceHash) {
     pieceHashes.push_back(pieceHash);
   }
 
@@ -69,29 +71,29 @@ public:
     this->fileMode = fileMode;
   }
 
-  virtual FileEntries getFileEntries() const {
+  virtual std::deque<SharedHandle<FileEntry> > getFileEntries() const {
     return fileEntries;
   }
 
-  void addFileEntry(const FileEntryHandle& fileEntry) {
+  void addFileEntry(const SharedHandle<FileEntry>& fileEntry) {
     fileEntries.push_back(fileEntry);
   }
 
-  virtual AnnounceTiers getAnnounceTiers() const {
+  virtual std::deque<SharedHandle<AnnounceTier> > getAnnounceTiers() const {
     return announceTiers;
   }
 
-  void addAnnounceTier(const AnnounceTierHandle& announceTier) {
+  void addAnnounceTier(const SharedHandle<AnnounceTier>& announceTier) {
     announceTiers.push_back(announceTier);
   }
 
-  virtual void load(const string& torrentFile) {}
+  virtual void load(const std::string& torrentFile) {}
 
-  virtual string getName() const {
+  virtual std::string getName() const {
     return name;
   }
 
-  void setName(const string& name) {
+  void setName(const std::string& name) {
     this->name = name;
   }
   
@@ -119,22 +121,22 @@ public:
     memcpy(this->peerId, peerId, sizeof(this->peerId));
   }
 
-  virtual Integers computeFastSet(const string& ipaddr, int32_t fastSetSize)
+  virtual std::deque<int32_t> computeFastSet(const std::string& ipaddr, int32_t fastSetSize)
   {
     return fastSet;
   }
 
-  void setFastSet(const Integers& fastSet)
+  void setFastSet(const std::deque<int32_t>& fastSet)
   {
     this->fastSet = fastSet;
   }
 
-  virtual string getPieceHashAlgo() const
+  virtual std::string getPieceHashAlgo() const
   {
     return "sha1";
   }
 
-  virtual string getActualBasePath() const
+  virtual std::string getActualBasePath() const
   {
     return _dir+"/"+name;
   }
@@ -145,6 +147,6 @@ public:
   }
 };
 
-typedef SharedHandle<MockBtContext> MockBtContextHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_BT_CONTEXT_H_
diff --git a/test/MockBtMessage.h b/test/MockBtMessage.h
index c33e0824..18277733 100644
--- a/test/MockBtMessage.h
+++ b/test/MockBtMessage.h
@@ -37,6 +37,8 @@
 
 #include "BtMessage.h"
 
+namespace aria2 {
+
 class MockBtMessage : public BtMessage {
 private:
   bool sendingInProgress;
@@ -85,18 +87,18 @@ public:
 
   virtual void send() {}
 
-  virtual bool validate(Errors& errors) {
+  virtual bool validate(std::deque<std::string>& errors) {
     return false;
   }
 
-  virtual void handleEvent(const BtEventHandle& event) {}
+  virtual void handleEvent(const SharedHandle<BtEvent>& event) {}
 
   virtual void onQueued() {}
 
-  virtual string toString() const { return "MockBtMessage"; }
+  virtual std::string toString() const { return "MockBtMessage"; }
 
 };
 
-typedef SharedHandle<MockBtMessage> MockBtMessageHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_BT_MESSAGE_H_
diff --git a/test/MockBtMessageDispatcher.h b/test/MockBtMessageDispatcher.h
index 291bd84e..4b88e48b 100644
--- a/test/MockBtMessageDispatcher.h
+++ b/test/MockBtMessageDispatcher.h
@@ -2,6 +2,9 @@
 #define _D_MOCK_BT_MESSAGE_DISPATCHER_H_
 
 #include "BtMessageDispatcher.h"
+#include <algorithm>
+
+namespace aria2 {
 
 class MockBtMessageDispatcher : public BtMessageDispatcher {
 public:
@@ -9,21 +12,21 @@ public:
 
   virtual ~MockBtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const BtMessageHandle& btMessage) {
+  virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) {
     messageQueue.push_back(btMessage);
   }
 
-  virtual void addMessageToQueue(const BtMessages& btMessages) {
-    copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
+  virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) {
+    std::copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
   }
 
   virtual void sendMessages() {}
 
   virtual void doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length) {}
 
-  virtual void doCancelSendingPieceAction(const PieceHandle& piece) {}
+  virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) {}
 
-  virtual void doAbortOutstandingRequestAction(const PieceHandle& piece) {}
+  virtual void doAbortOutstandingRequestAction(const SharedHandle<Piece>& piece) {}
 
   virtual void doChokedAction() {}
 
@@ -56,6 +59,6 @@ public:
   virtual void addOutstandingRequest(const RequestSlot& slot) {}
 };
 
-typedef SharedHandle<MockBtMessageDispatcher> MockBtMessageDispatcherHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_BT_MESSAGE_DISPATCHER_H_
diff --git a/test/MockBtMessageFactory.h b/test/MockBtMessageFactory.h
index 196c578f..8141fb6f 100644
--- a/test/MockBtMessageFactory.h
+++ b/test/MockBtMessageFactory.h
@@ -3,8 +3,9 @@
 
 #include "BtMessageFactory.h"
 
+namespace aria2 {
+
 class ExtensionMessage;
-typedef SharedHandle<ExtensionMessage> ExensionMessageHandle;
 
 class MockBtMessageFactory : public BtMessageFactory {
 public:
@@ -12,93 +13,94 @@ public:
 
   virtual ~MockBtMessageFactory() {}
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createBtMessage(const unsigned char* msg, int32_t msgLength) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   };
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* msg, int32_t msgLength) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createHandshakeMessage(const unsigned char* infoHash,
 			 const unsigned char* peerId) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle
-  createRequestMessage(const PieceHandle& piece, int32_t blockIndex) {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage>
+  createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex) {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createCancelMessage(int32_t index, int32_t begin, int32_t length) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createPieceMessage(int32_t index, int32_t begin, int32_t length) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createHaveMessage(int32_t index) {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createHaveMessage(int32_t index) {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createChokeMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createChokeMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createUnchokeMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createUnchokeMessage() {
+    return SharedHandle<BtMessage>(0);
   }
   
-  virtual BtMessageHandle createInterestedMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createInterestedMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createNotInterestedMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createNotInterestedMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createBitfieldMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createBitfieldMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createKeepAliveMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createKeepAliveMessage() {
+    return SharedHandle<BtMessage>(0);
   }
   
-  virtual BtMessageHandle createHaveAllMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createHaveAllMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createHaveNoneMessage() {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createHaveNoneMessage() {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle
+  virtual SharedHandle<BtMessage>
   createRejectMessage(int32_t index, int32_t begin, int32_t length) {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createAllowedFastMessage(int32_t index) {
-    return BtMessageHandle(0);
+  virtual SharedHandle<BtMessage> createAllowedFastMessage(int32_t index) {
+    return SharedHandle<BtMessage>(0);
   }
 
-  virtual BtMessageHandle createPortMessage(uint16_t port)
+  virtual SharedHandle<BtMessage> createPortMessage(uint16_t port)
   {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
   
-  virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle&)
+  virtual SharedHandle<BtMessage>
+  createBtExtendedMessage(const SharedHandle<ExtensionMessage>& extmsg)
   {
-    return BtMessageHandle(0);
+    return SharedHandle<BtMessage>(0);
   }
 };
 
-typedef SharedHandle<MockBtMessageFactory> MockBtMessageFactoryHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_BT_MESSAGE_FACTORY_H_
diff --git a/test/MockBtProgressInfoFile.h b/test/MockBtProgressInfoFile.h
index 7a651d0f..8676d749 100644
--- a/test/MockBtProgressInfoFile.h
+++ b/test/MockBtProgressInfoFile.h
@@ -3,18 +3,20 @@
 
 #include "BtProgressInfoFile.h"
 
+namespace aria2 {
+
 class MockBtProgressInfoFile : public BtProgressInfoFile {
 private:
-  string filename;
+  std::string filename;
 public:
   MockBtProgressInfoFile() {}
   virtual ~MockBtProgressInfoFile() {}
 
-  virtual string getFilename() {
+  virtual std::string getFilename() {
     return filename;
   }
 
-  virtual void setFilename(const string& filename) {
+  virtual void setFilename(const std::string& filename) {
     this->filename = filename;
   }
 
@@ -29,4 +31,6 @@ public:
   virtual void removeFile() {}
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_BT_PROGRESS_INFO_FILE_H_
diff --git a/test/MockBtRequestFactory.h b/test/MockBtRequestFactory.h
index 0e38e07c..8987a0a9 100644
--- a/test/MockBtRequestFactory.h
+++ b/test/MockBtRequestFactory.h
@@ -3,13 +3,15 @@
 
 #include "BtRequestFactory.h"
 
+namespace aria2 {
+
 class MockBtRequestFactory : public BtRequestFactory {
 public:
   virtual ~MockBtRequestFactory() {}
 
-  virtual void addTargetPiece(const PieceHandle& piece) {}
+  virtual void addTargetPiece(const SharedHandle<Piece>& piece) {}
 
-  virtual void removeTargetPiece(const PieceHandle& piece) {}
+  virtual void removeTargetPiece(const SharedHandle<Piece>& piece) {}
 
   virtual void removeAllTargetPiece() {}
 
@@ -19,12 +21,13 @@ public:
 
   virtual void doChokedAction() {}
 
-  virtual BtMessages createRequestMessages(int32_t max) { return BtMessages(); }
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessages(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 
-  virtual BtMessages createRequestMessagesOnEndGame(int32_t max) { return BtMessages(); }
+  virtual std::deque<SharedHandle<BtMessage> >
+  createRequestMessagesOnEndGame(int32_t max) { return std::deque<SharedHandle<BtMessage> >(); }
 };
 
-typedef SharedHandle<MockBtRequestFactory> MockBtRequestFactoryHandle;
-typedef WeakHandle<MockBtRequestFactory> MockBtRequestFactoryWeakHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_BT_REQUEST_FACTORY_H_
diff --git a/test/MockDHTMessage.h b/test/MockDHTMessage.h
index bac33e92..f45d552c 100644
--- a/test/MockDHTMessage.h
+++ b/test/MockDHTMessage.h
@@ -3,15 +3,17 @@
 
 #include "DHTMessage.h"
 
+namespace aria2 {
+
 class MockDHTMessage:public DHTMessage {
 private:
   bool _isReply;
 
-  string _messageType;
+  std::string _messageType;
 public:
-  MockDHTMessage(const DHTNodeHandle& localNode,
-		 const DHTNodeHandle& remoteNode,
-		 const string& transactionID = ""):
+  MockDHTMessage(const SharedHandle<DHTNode>& localNode,
+		 const SharedHandle<DHTNode>& remoteNode,
+		 const std::string& transactionID = ""):
     DHTMessage(localNode, remoteNode, transactionID), _isReply(false), _messageType("mock") {}
   
   virtual ~MockDHTMessage() {}
@@ -24,12 +26,13 @@ public:
 
   void setReply(bool f) { _isReply = f; }
 
-  virtual string getMessageType() const { return _messageType; }
+  virtual std::string getMessageType() const { return _messageType; }
 
-  virtual string toString() const { return "MockDHTMessage"; }
+  virtual std::string toString() const { return "MockDHTMessage"; }
 
   virtual void validate() const {}
 };
 
-typedef SharedHandle<MockDHTMessage> MockDHTMessageHandle;
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_MESSAGE_H_
diff --git a/test/MockDHTMessageCallback.h b/test/MockDHTMessageCallback.h
index 09f0ff48..52bade88 100644
--- a/test/MockDHTMessageCallback.h
+++ b/test/MockDHTMessageCallback.h
@@ -3,15 +3,19 @@
 
 #include "DHTMessageCallback.h"
 
+namespace aria2 {
+
 class MockDHTMessageCallback:public DHTMessageCallback {
 public:
   MockDHTMessageCallback() {}
 
   virtual ~MockDHTMessageCallback() {}
 
-  virtual void onReceived(const DHTMessageHandle& message) {}
+  virtual void onReceived(const SharedHandle<DHTMessage>& message) {}
 
-  virtual void onTimeout(const DHTNodeHandle& remoteNode) {}
+  virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) {}
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_MESSAGE_CALLBACK_H_
diff --git a/test/MockDHTMessageFactory.h b/test/MockDHTMessageFactory.h
index bbf83964..5441e5d5 100644
--- a/test/MockDHTMessageFactory.h
+++ b/test/MockDHTMessageFactory.h
@@ -7,118 +7,122 @@
 #include "Dictionary.h"
 #include "Data.h"
 
+namespace aria2 {
+
 class MockDHTMessageFactory:public DHTMessageFactory {
 private:
-  DHTNodeHandle _localNode;
+  SharedHandle<DHTNode> _localNode;
 public:
   MockDHTMessageFactory() {}
 
   virtual ~MockDHTMessageFactory() {}
 
-  virtual DHTMessageHandle
+  virtual SharedHandle<DHTMessage>
   createQueryMessage(const Dictionary* d,
-		     const string& ipaddr, uint16_t port)
+		     const std::string& ipaddr, uint16_t port)
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createResponseMessage(const string& messageType,
+  virtual SharedHandle<DHTMessage>
+  createResponseMessage(const std::string& messageType,
 			const Dictionary* d,
-			const DHTNodeHandle& remoteNode)
+			const SharedHandle<DHTNode>& remoteNode)
   {
-    MockDHTMessageHandle m = new MockDHTMessage(_localNode, remoteNode,
-						reinterpret_cast<const Data*>(d->get("t"))->toString());
+    SharedHandle<MockDHTMessage> m =
+      new MockDHTMessage(_localNode, remoteNode,
+			 reinterpret_cast<const Data*>(d->get("t"))->toString());
     m->setReply(true);
     return m;
   }
 
-  virtual DHTMessageHandle
-  createPingMessage(const DHTNodeHandle& remoteNode,
-		    const string& transactionID = "")
+  virtual SharedHandle<DHTMessage>
+  createPingMessage(const SharedHandle<DHTNode>& remoteNode,
+		    const std::string& transactionID = "")
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createPingReplyMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			 const unsigned char* remoteNodeID,
-			 const string& transactionID)
+			 const std::string& transactionID)
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createFindNodeMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createFindNodeMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* targetNodeID,
-			const string& transactionID = "")
+			const std::string& transactionID = "")
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createFindNodeReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& transactionID)
+  virtual SharedHandle<DHTMessage>
+  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& transactionID)
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createGetPeersMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
 			const unsigned char* infoHash,
-			const string& transactionID)
+			const std::string& transactionID)
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const DHTNodes& closestKNodes,
-			     const string& transactionID,
-			     const string& token = "")
+  virtual SharedHandle<DHTMessage>
+  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			     const std::string& transactionID,
+			     const std::string& token = "")
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createGetPeersReplyMessage(const DHTNodeHandle& remoteNode,
-			     const Peers& peers,
-			     const string& transactionID,
-			     const string& token = "")
+  virtual SharedHandle<DHTMessage>
+  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			     const std::deque<SharedHandle<Peer> >& peers,
+			     const std::string& transactionID,
+			     const std::string& token = "")
   {
     return 0;
   }
   
-  virtual DHTMessageHandle
-  createAnnouncePeerMessage(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,
 			    const unsigned char* infoHash,
 			    uint16_t tcpPort,
-			    const string& token,
-			    const string& transactionID = "")
+			    const std::string& token,
+			    const std::string& transactionID = "")
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode,
-				 const string& transactionID)
+  virtual SharedHandle<DHTMessage>
+  createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+				 const std::string& transactionID)
   {
     return 0;
   }
 
-  virtual DHTMessageHandle
-  createUnknownMessage(const char* data, size_t length, const string& ipaddr,
+  virtual SharedHandle<DHTMessage>
+  createUnknownMessage(const char* data, size_t length, const std::string& ipaddr,
 		       uint16_t port)
   {
     return 0;
   }
 
-  void setLocalNode(const DHTNodeHandle& node)
+  void setLocalNode(const SharedHandle<DHTNode>& node)
   {
     _localNode = node;
   }
 };
 
-typedef SharedHandle<MockDHTMessageFactory> MockDHTMessageFactoryHandle;
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_MESSAGE_FACTORY_H_
diff --git a/test/MockDHTTask.h b/test/MockDHTTask.h
index e12954b0..dceac86a 100644
--- a/test/MockDHTTask.h
+++ b/test/MockDHTTask.h
@@ -4,11 +4,13 @@
 #include "DHTTask.h"
 #include "DHTNode.h"
 
+namespace aria2 {
+
 class MockDHTTask:public DHTTask {
 public:
-  DHTNodeHandle _remoteNode;
+  SharedHandle<DHTNode> _remoteNode;
 
-  MockDHTTask(const DHTNodeHandle& remoteNode):_remoteNode(remoteNode) {}
+  MockDHTTask(const SharedHandle<DHTNode>& remoteNode):_remoteNode(remoteNode) {}
 
   virtual ~MockDHTTask() {}
 
@@ -20,4 +22,6 @@ public:
   }
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_TASK_H_
diff --git a/test/MockDHTTaskFactory.h b/test/MockDHTTaskFactory.h
index 355ce45a..4e7c1234 100644
--- a/test/MockDHTTaskFactory.h
+++ b/test/MockDHTTaskFactory.h
@@ -3,47 +3,51 @@
 
 #include "DHTTaskFactory.h"
 
+namespace aria2 {
+
 class MockDHTTaskFactory:public DHTTaskFactory {
 public:
   virtual ~MockDHTTaskFactory() {}
 
-  virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTTask> createPingTask(const SharedHandle<DHTNode>& remoteNode,
 				       size_t numRetry = 0)
   {
     return 0;
   }
 
-  virtual DHTTaskHandle createGetIDTask(const DHTNodeHandle& remoteNode,
+  virtual SharedHandle<DHTTask> createGetIDTask(const SharedHandle<DHTNode>& remoteNode,
 					size_t numRetry = 0)
   {
     return 0;
   }
 
-  virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID)
+  virtual SharedHandle<DHTTask> createNodeLookupTask(const unsigned char* targetID)
   {
     return 0;
   }
 
-  virtual DHTTaskHandle createBucketRefreshTask()
+  virtual SharedHandle<DHTTask> createBucketRefreshTask()
   {
     return 0;
   }
 
-  virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx)
+  virtual SharedHandle<DHTTask> createPeerLookupTask(const SharedHandle<BtContext>& ctx)
   {
     return 0;
   }
   
-  virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash)
+  virtual SharedHandle<DHTTask> createPeerAnnounceTask(const unsigned char* infoHash)
   {
     return 0;
   }
 
-  virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket,
-					      const DHTNodeHandle& newNode)
+  virtual SharedHandle<DHTTask> createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket,
+						      const SharedHandle<DHTNode>& newNode)
   {
     return 0;
   }
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_TASK_FACTORY_H_
diff --git a/test/MockDHTTaskQueue.h b/test/MockDHTTaskQueue.h
index 0c6680ba..2a785afb 100644
--- a/test/MockDHTTaskQueue.h
+++ b/test/MockDHTTaskQueue.h
@@ -3,13 +3,15 @@
 
 #include "DHTTaskQueue.h"
 
+namespace aria2 {
+
 class MockDHTTaskQueue:public DHTTaskQueue {
 public:
-  DHTTasks _periodicTaskQueue1;
+  std::deque<SharedHandle<DHTTask> > _periodicTaskQueue1;
 
-  DHTTasks _periodicTaskQueue2;
+  std::deque<SharedHandle<DHTTask> > _periodicTaskQueue2;
 
-  DHTTasks _immediateTaskQueue;
+  std::deque<SharedHandle<DHTTask> > _immediateTaskQueue;
 
   MockDHTTaskQueue() {}
 
@@ -17,20 +19,22 @@ public:
 
   virtual void executeTask() {}
 
-  virtual void addPeriodicTask1(const DHTTaskHandle& task)
+  virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task)
   {
     _periodicTaskQueue1.push_back(task);
   }
 
-  virtual void addPeriodicTask2(const DHTTaskHandle& task)
+  virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task)
   {
     _periodicTaskQueue2.push_back(task);
   }
 
-  virtual void addImmediateTask(const DHTTaskHandle& task)
+  virtual void addImmediateTask(const SharedHandle<DHTTask>& task)
   {
     _immediateTaskQueue.push_back(task);
   }
 };
 
+} // namespace aria2
+
 #endif // _D_MOCK_DHT_TASK_QUEUE_H_
diff --git a/test/MockExtensionMessage.h b/test/MockExtensionMessage.h
index 0fdd9a67..5a0e1b21 100644
--- a/test/MockExtensionMessage.h
+++ b/test/MockExtensionMessage.h
@@ -3,14 +3,16 @@
 
 #include "ExtensionMessage.h"
 
+namespace aria2 {
+
 class MockExtensionMessage:public ExtensionMessage {
 public:
-  string _extensionName;
+  std::string _extensionName;
   uint8_t _extensionMessageID;
-  string _data;
+  std::string _data;
   bool _doReceivedActionCalled;
 public:
-  MockExtensionMessage(const string& extensionName,
+  MockExtensionMessage(const std::string& extensionName,
 		       uint8_t extensionMessageID,
 		       const char* data,
 		       size_t length):_extensionName(extensionName),
@@ -20,7 +22,7 @@ public:
 
   virtual ~MockExtensionMessage() {}
 
-  virtual string getBencodedData()
+  virtual std::string getBencodedData()
   {
     return _data;
   }
@@ -30,12 +32,12 @@ public:
     return _extensionMessageID;
   }
   
-  virtual const string& getExtensionName() const
+  virtual const std::string& getExtensionName() const
   {
     return _extensionName;
   }
 
-  virtual string toString() const
+  virtual std::string toString() const
   {
     return _extensionName;
   }
@@ -46,6 +48,6 @@ public:
   }
 };
 
-typedef SharedHandle<MockExtensionMessage> MockExtensionMessageHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_EXTENSION_MESSAGE_H_
diff --git a/test/MockExtensionMessageFactory.h b/test/MockExtensionMessageFactory.h
index f9789be1..3107f349 100644
--- a/test/MockExtensionMessageFactory.h
+++ b/test/MockExtensionMessageFactory.h
@@ -4,17 +4,20 @@
 #include "ExtensionMessageFactory.h"
 #include "MockExtensionMessage.h"
 
+namespace aria2 {
+
 class MockExtensionMessageFactory:public ExtensionMessageFactory {
 public:
   virtual ~MockExtensionMessageFactory() {}
 
-  virtual ExtensionMessageHandle createMessage(const char* data,
-					       size_t length)
+  virtual SharedHandle<ExtensionMessage> createMessage(const char* data,
+						       size_t length)
   {
     return new MockExtensionMessage("a2_mock", *data, data+1, length-1);
 				    
   }
 };
 
-typedef SharedHandle<MockExtensionMessageFactory> MockExtensionMessageFactoryHandle;
+} // namespace aria2
+
 #endif // _D_MOCK_EXTENSION_MESSAGE_FACTORY_H_
diff --git a/test/MockPeerStorage.h b/test/MockPeerStorage.h
index a7572807..7bffbacd 100644
--- a/test/MockPeerStorage.h
+++ b/test/MockPeerStorage.h
@@ -2,30 +2,33 @@
 #define _D_MOCK_PEER_STORAGE_H_
 
 #include "PeerStorage.h"
+#include "Peer.h"
+
+namespace aria2 {
 
 class MockPeerStorage : public PeerStorage {
 private:
   TransferStat stat;
-  Peers peers;
-  Peers activePeers;
+  std::deque<SharedHandle<Peer> > peers;
+  std::deque<SharedHandle<Peer> > activePeers;
 public:
   MockPeerStorage() {}
   virtual ~MockPeerStorage() {}
 
-  virtual bool addPeer(const PeerHandle& peer) {
+  virtual bool addPeer(const SharedHandle<Peer>& peer) {
     peers.push_back(peer);
     return true;
   }
 
-  virtual void addPeer(const Peers& peers) {
+  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers) {
     copy(peers.begin(), peers.end(), back_inserter(this->peers));
   }
 
-  virtual const Peers& getPeers() {
+  virtual const std::deque<SharedHandle<Peer> >& getPeers() {
     return peers;
   }
 
-  virtual PeerHandle getUnusedPeer() {
+  virtual SharedHandle<Peer> getUnusedPeer() {
     return 0;
   }
 
@@ -33,12 +36,12 @@ public:
     return false;
   }
   
-  void setActivePeers(const Peers& activePeers)
+  void setActivePeers(const std::deque<SharedHandle<Peer> >& activePeers)
   {
     this->activePeers = activePeers;
   }
 
-  virtual Peers getActivePeers() {
+  virtual std::deque<SharedHandle<Peer> > getActivePeers() {
     return activePeers;
   }
 
@@ -50,11 +53,11 @@ public:
     this->stat = stat;
   }
 
-  virtual void returnPeer(const PeerHandle& peer)
+  virtual void returnPeer(const SharedHandle<Peer>& peer)
   {
   }
 };
 
-typedef SharedHandle<MockPeerStorage> MockPeerStorageHandle;
-
 #endif // _D_MOCK_PEER_STORAGE_H_
+
+} // namespace aria2
diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h
index 6d5edfea..be3c43f1 100644
--- a/test/MockPieceStorage.h
+++ b/test/MockPieceStorage.h
@@ -5,6 +5,9 @@
 #include "BitfieldMan.h"
 #include "Piece.h"
 #include "DiskAdaptor.h"
+#include <algorithm>
+
+namespace aria2 {
 
 class MockPieceStorage : public PieceStorage {
 private:
@@ -15,9 +18,9 @@ private:
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
-  DiskAdaptorHandle diskAdaptor;
-  Integers pieceLengthList;
-  Pieces inFlightPieces;
+  SharedHandle<DiskAdaptor> diskAdaptor;
+  std::deque<int32_t> pieceLengthList;
+  std::deque<SharedHandle<Piece> > inFlightPieces;
   bool _allDownloadFinished;
 public:
   MockPieceStorage():totalLength(0),
@@ -32,24 +35,24 @@ public:
 
   virtual ~MockPieceStorage() {}
 
-  virtual bool hasMissingPiece(const PeerHandle& peer) {
+  virtual bool hasMissingPiece(const SharedHandle<Peer>& peer) {
     return false;
   }
 
-  virtual PieceHandle getMissingPiece(const PeerHandle& peer) {
+  virtual SharedHandle<Piece> getMissingPiece(const SharedHandle<Peer>& peer) {
     return new Piece();
   }
 
-  virtual PieceHandle getMissingFastPiece(const PeerHandle& peer) {
+  virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer) {
     return new Piece();
   }
 
-  virtual PieceHandle getMissingPiece()
+  virtual SharedHandle<Piece> getMissingPiece()
   {
     return new Piece();
   }
 
-  virtual PieceHandle getMissingPiece(int32_t index)
+  virtual SharedHandle<Piece> getMissingPiece(int32_t index)
   {
     return new Piece();
   }
@@ -63,13 +66,13 @@ public:
 
   virtual void markPiecesDone(int64_t) {}
 
-  virtual PieceHandle getPiece(int32_t index) {
+  virtual SharedHandle<Piece> getPiece(int32_t index) {
     return new Piece();
   }
 
-  virtual void completePiece(const PieceHandle& piece) {}
+  virtual void completePiece(const SharedHandle<Piece>& piece) {}
 
-  virtual void cancelPiece(const PieceHandle& piece) {}
+  virtual void cancelPiece(const SharedHandle<Piece>& piece) {}
 
   virtual bool hasPiece(int32_t index) {
     return false;
@@ -107,7 +110,7 @@ public:
     this->filteredCompletedLength = completedLength;
   }
   
-  virtual void setFileFilter(const Strings& filePaths) {}
+  virtual void setFileFilter(const std::deque<std::string>& filePaths) {}
 
   virtual void setFileFilter(IntSequence seq) {}
 
@@ -163,11 +166,11 @@ public:
     this->endGame = flag;
   }
 
-  virtual DiskAdaptorHandle getDiskAdaptor() {
+  virtual SharedHandle<DiskAdaptor> getDiskAdaptor() {
     return diskAdaptor;
   }
 
-  void setDiskAdaptor(const DiskAdaptorHandle adaptor) {
+  void setDiskAdaptor(const SharedHandle<DiskAdaptor> adaptor) {
     this->diskAdaptor = adaptor;
   }
   
@@ -181,18 +184,18 @@ public:
 
   virtual void advertisePiece(int32_t cuid, int32_t index) {}
 
-  virtual Integers getAdvertisedPieceIndexes(int32_t myCuid,
-					     const Time& lastCheckTime) {
-    return Integers();
+  virtual std::deque<int32_t> getAdvertisedPieceIndexes(int32_t myCuid,
+							const Time& lastCheckTime) {
+    return std::deque<int32_t>();
   }
 
   virtual void removeAdvertisedPiece(int32_t elapsed) {}
 
   virtual void markAllPiecesDone() {}
 
-  virtual void addInFlightPiece(const Pieces& pieces)
+  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces)
   {
-    copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
+    std::copy(pieces.begin(), pieces.end(), back_inserter(inFlightPieces));
   }
 
   virtual int32_t countInFlightPiece()
@@ -200,13 +203,13 @@ public:
     return inFlightPieces.size();
   }
 
-  virtual Pieces getInFlightPieces()
+  virtual std::deque<SharedHandle<Piece> > getInFlightPieces()
   {
     return inFlightPieces;
   }
 
 };
 
-typedef SharedHandle<MockPieceStorage> MockPieceStorageHandle;
+} // namespace aria2
 
 #endif // _D_MOCK_PIECE_STORAGE_H_
diff --git a/test/MultiDiskAdaptorTest.cc b/test/MultiDiskAdaptorTest.cc
index 9983e1a4..fd1d9ed8 100644
--- a/test/MultiDiskAdaptorTest.cc
+++ b/test/MultiDiskAdaptorTest.cc
@@ -1,8 +1,10 @@
 #include "MultiDiskAdaptor.h"
+#include "FileEntry.h"
+#include "Exception.h"
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class MultiDiskAdaptorTest:public CppUnit::TestFixture {
 
@@ -11,7 +13,7 @@ class MultiDiskAdaptorTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testReadData);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MultiDiskAdaptorHandle adaptor;
+  SharedHandle<MultiDiskAdaptor> adaptor;
 public:
   MultiDiskAdaptorTest():adaptor(0) {}
 
@@ -29,21 +31,21 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( MultiDiskAdaptorTest );
 
-FileEntries createEntries() {
-  FileEntryHandle entry1(new FileEntry("file1.txt", 15, 0));
-  FileEntryHandle entry2(new FileEntry("file2.txt", 7, 15));
-  FileEntryHandle entry3(new FileEntry("file3.txt", 3, 22));
+std::deque<SharedHandle<FileEntry> > createEntries() {
+  SharedHandle<FileEntry> entry1(new FileEntry("file1.txt", 15, 0));
+  SharedHandle<FileEntry> entry2(new FileEntry("file2.txt", 7, 15));
+  SharedHandle<FileEntry> entry3(new FileEntry("file3.txt", 3, 22));
   unlink("file1.txt");
   unlink("file2.txt");
   unlink("file3.txt");
-  FileEntries entries;
+  std::deque<SharedHandle<FileEntry> > entries;
   entries.push_back(entry1);
   entries.push_back(entry2);
   entries.push_back(entry3);
   return entries;
 }
 
-void readFile(const string& filename, char* buf, int bufLength) {
+void readFile(const std::string& filename, char* buf, int bufLength) {
   FILE* f = fopen(filename.c_str(), "r");
   if(f == NULL) {
     abort();
@@ -60,51 +62,51 @@ void MultiDiskAdaptorTest::testWriteData() {
   adaptor->setFileEntries(createEntries());
 
   adaptor->openFile();
-  string msg = "12345";
+  std::string msg = "12345";
   adaptor->writeData((const unsigned char*)msg.c_str(), msg.size(), 0);
   adaptor->closeFile();
 
   char buf[128];
   readFile("file1.txt", buf, 5);
   buf[5] = '\0';
-  CPPUNIT_ASSERT_EQUAL(msg, string(buf));
+  CPPUNIT_ASSERT_EQUAL(msg, std::string(buf));
 
   adaptor->openFile();
-  string msg2 = "67890ABCDEF";
+  std::string msg2 = "67890ABCDEF";
   adaptor->writeData((const unsigned char*)msg2.c_str(), msg2.size(), 5);
   adaptor->closeFile();
 
   readFile("file1.txt", buf, 15);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDE"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDE"), std::string(buf));
   readFile("file2.txt", buf, 1);
   buf[1] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("F"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("F"), std::string(buf));
 
   adaptor->openFile();
-  string msg3 = "12345123456712";
+  std::string msg3 = "12345123456712";
   adaptor->writeData((const unsigned char*)msg3.c_str(), msg3.size(), 10);
   adaptor->closeFile();
 
   readFile("file1.txt", buf, 15);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("123456789012345"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789012345"), std::string(buf));
   readFile("file2.txt", buf, 7);
   buf[7] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567"), std::string(buf));
   readFile("file3.txt", buf, 2);
   buf[2] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("12"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("12"), std::string(buf));
   } catch(Exception* e) {
     CPPUNIT_FAIL(e->getMsg());
   }
 }
 
 void MultiDiskAdaptorTest::testReadData() {
-  FileEntryHandle entry1(new FileEntry("file1r.txt", 15, 0));
-  FileEntryHandle entry2(new FileEntry("file2r.txt", 7, 15));
-  FileEntryHandle entry3(new FileEntry("file3r.txt", 3, 22));
-  FileEntries entries;
+  SharedHandle<FileEntry> entry1(new FileEntry("file1r.txt", 15, 0));
+  SharedHandle<FileEntry> entry2(new FileEntry("file2r.txt", 7, 15));
+  SharedHandle<FileEntry> entry3(new FileEntry("file3r.txt", 3, 22));
+  std::deque<SharedHandle<FileEntry> > entries;
   entries.push_back(entry1);
   entries.push_back(entry2);
   entries.push_back(entry3);
@@ -115,14 +117,16 @@ void MultiDiskAdaptorTest::testReadData() {
   unsigned char buf[128];
   adaptor->readData(buf, 15, 0);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDE"), string((char*)buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDE"), std::string((char*)buf));
   adaptor->readData(buf, 10, 6);
   buf[10] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("7890ABCDEF"), string((char*)buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("7890ABCDEF"), std::string((char*)buf));
   adaptor->readData(buf, 4, 20);
   buf[4] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("KLMN"), string((char*)buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("KLMN"), std::string((char*)buf));
   adaptor->readData(buf, 25, 0);
   buf[25] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDEFGHIJKLMNO"), string((char*)buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDEFGHIJKLMNO"), std::string((char*)buf));
 }
+
+} // namespace aria2
diff --git a/test/MultiDiskWriterTest.cc b/test/MultiDiskWriterTest.cc
index 265b3f81..95de9fac 100644
--- a/test/MultiDiskWriterTest.cc
+++ b/test/MultiDiskWriterTest.cc
@@ -58,7 +58,7 @@ void MultiDiskWriterTest::testWriteData() {
   dw.setFileEntries(createEntries());
 
   dw.openFile(".");
-  string msg = "12345";
+  std::string msg = "12345";
   dw.writeData(msg.c_str(), msg.size(), 0);
   dw.closeFile();
 
@@ -68,31 +68,31 @@ void MultiDiskWriterTest::testWriteData() {
   CPPUNIT_ASSERT_EQUAL(msg, string(buf));
 
   dw.openFile(".");
-  string msg2 = "67890ABCDEF";
+  std::string msg2 = "67890ABCDEF";
   dw.writeData(msg2.c_str(), msg2.size(), 5);
   dw.closeFile();
 
   readFile("file1.txt", buf, 15);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDE"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDE"), string(buf));
   readFile("file2.txt", buf, 1);
   buf[1] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("F"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("F"), string(buf));
 
   dw.openFile(".");
-  string msg3 = "12345123456712";
+  std::string msg3 = "12345123456712";
   dw.writeData(msg3.c_str(), msg3.size(), 10);
   dw.closeFile();
 
   readFile("file1.txt", buf, 15);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("123456789012345"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("123456789012345"), string(buf));
   readFile("file2.txt", buf, 7);
   buf[7] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567"), string(buf));
   readFile("file3.txt", buf, 2);
   buf[2] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("12"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("12"), string(buf));
 }
 
 void MultiDiskWriterTest::testReadData() {
@@ -110,16 +110,16 @@ void MultiDiskWriterTest::testReadData() {
   char buf[128];
   dw.readData(buf, 15, 0);
   buf[15] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDE"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDE"), string(buf));
   dw.readData(buf, 10, 6);
   buf[10] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("7890ABCDEF"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("7890ABCDEF"), string(buf));
   dw.readData(buf, 4, 20);
   buf[4] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("KLMN"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("KLMN"), string(buf));
   dw.readData(buf, 25, 0);
   buf[25] = '\0';
-  CPPUNIT_ASSERT_EQUAL(string("1234567890ABCDEFGHIJKLMNO"), string(buf));
+  CPPUNIT_ASSERT_EQUAL(std::string("1234567890ABCDEFGHIJKLMNO"), string(buf));
 }
 
 void MultiDiskWriterTest::testMessageDigest() {
@@ -134,11 +134,11 @@ void MultiDiskWriterTest::testMessageDigest() {
   dw.setFileEntries(entries);
 
   dw.openFile(".");
-  string sha1sum = dw.messageDigest(0, 25, DIGEST_ALGO_SHA1);
-  CPPUNIT_ASSERT_EQUAL(string("76495faf71ca63df66dce99547d2c58da7266d9e"), sha1sum);
+  std::string sha1sum = dw.messageDigest(0, 25, DIGEST_ALGO_SHA1);
+  CPPUNIT_ASSERT_EQUAL(std::string("76495faf71ca63df66dce99547d2c58da7266d9e"), sha1sum);
   sha1sum = dw.messageDigest(15, 7, DIGEST_ALGO_SHA1);
-  CPPUNIT_ASSERT_EQUAL(string("737660d816fb23c2d5bc74f62d9b01b852b2aaca"), sha1sum);
+  CPPUNIT_ASSERT_EQUAL(std::string("737660d816fb23c2d5bc74f62d9b01b852b2aaca"), sha1sum);
   sha1sum = dw.messageDigest(10, 14, DIGEST_ALGO_SHA1);
-  CPPUNIT_ASSERT_EQUAL(string("6238bf61dd8df8f77156b2378e9e39cd3939680c"), sha1sum);
+  CPPUNIT_ASSERT_EQUAL(std::string("6238bf61dd8df8f77156b2378e9e39cd3939680c"), sha1sum);
   dw.closeFile();
 }
diff --git a/test/MultiFileAllocationIteratorTest.cc b/test/MultiFileAllocationIteratorTest.cc
index 9428d84f..cc7fcd0a 100644
--- a/test/MultiFileAllocationIteratorTest.cc
+++ b/test/MultiFileAllocationIteratorTest.cc
@@ -1,8 +1,13 @@
 #include "MultiFileAllocationIterator.h"
 #include "File.h"
 #include "MultiDiskAdaptor.h"
+#include "FileEntry.h"
+#include "Exception.h"
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class MultiFileAllocationIteratorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(MultiFileAllocationIteratorTest);
@@ -23,7 +28,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MultiFileAllocationIteratorTest );
 
 void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
 {
-  FileEntryHandle fs[] = {
+  SharedHandle<FileEntry> fs[] = {
     new FileEntry("file1", 1536, 0),
     new FileEntry("file2", 2048, 1536),
     new FileEntry("file3", 1024, 3584),
@@ -43,39 +48,39 @@ void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
   fs[8]->setRequested(false);
   fs[9]->setRequested(false);
   
-  string storeDir = "/tmp/aria2_MultiFileAllocationIteratorTest_testMakeDiskWriterEntries";
-  MultiDiskAdaptorHandle diskAdaptor = new MultiDiskAdaptor();
-  diskAdaptor->setFileEntries(FileEntries(&fs[0], &fs[10]));
+  std::string storeDir = "/tmp/aria2_MultiFileAllocationIteratorTest_testMakeDiskWriterEntries";
+  SharedHandle<MultiDiskAdaptor> diskAdaptor = new MultiDiskAdaptor();
+  diskAdaptor->setFileEntries(std::deque<SharedHandle<FileEntry> >(&fs[0], &fs[10]));
   diskAdaptor->setPieceLength(1024);
   diskAdaptor->setStoreDir(storeDir);
   diskAdaptor->openFile();
 
-  MultiFileAllocationIteratorHandle itr = diskAdaptor->fileAllocationIterator();
+  SharedHandle<MultiFileAllocationIterator> itr = diskAdaptor->fileAllocationIterator();
 
   DiskWriterEntries entries = itr->getDiskWriterEntries();
 
-  sort(entries.begin(), entries.end());
+  std::sort(entries.begin(), entries.end());
 
   CPPUNIT_ASSERT_EQUAL((size_t)6, entries.size());
 
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file1"), entries[0]->getFilePath(storeDir));
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file2"), entries[1]->getFilePath(storeDir));
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file3"), entries[2]->getFilePath(storeDir));
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file6"), entries[3]->getFilePath(storeDir));
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file7"), entries[4]->getFilePath(storeDir));
-  CPPUNIT_ASSERT_EQUAL(storeDir+string("/file8"), entries[5]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file1"), entries[0]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file2"), entries[1]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file3"), entries[2]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file6"), entries[3]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file7"), entries[4]->getFilePath(storeDir));
+  CPPUNIT_ASSERT_EQUAL(storeDir+std::string("/file8"), entries[5]->getFilePath(storeDir));
 }
 
 void MultiFileAllocationIteratorTest::testAllocate()
 {
-  string dir = "/tmp";
-  string topDir = "aria2_MultiFileAllocationIteratorTest_testAllocate";
-  string fname1 = "file1";
-  string fname2 = "file2";
-  string fname3 = "file3";
-  string fname4 = "file4";
-  string fname5 = "file5";
-  string fname6 = "file6";
+  std::string dir = "/tmp";
+  std::string topDir = "aria2_MultiFileAllocationIteratorTest_testAllocate";
+  std::string fname1 = "file1";
+  std::string fname2 = "file2";
+  std::string fname3 = "file3";
+  std::string fname4 = "file4";
+  std::string fname5 = "file5";
+  std::string fname6 = "file6";
   int64_t length1 = 32769;
   int64_t length2 = 0;
   int64_t length3 = 8;
@@ -84,66 +89,69 @@ void MultiFileAllocationIteratorTest::testAllocate()
   int64_t length6 = 30;
 
   try {
-  MultiDiskAdaptorHandle diskAdaptor = new MultiDiskAdaptor();
-  diskAdaptor->setStoreDir(dir);
-  diskAdaptor->setTopDir(topDir);
+    SharedHandle<MultiDiskAdaptor> diskAdaptor = new MultiDiskAdaptor();
+    diskAdaptor->setStoreDir(dir);
+    diskAdaptor->setTopDir(topDir);
 
-  int64_t offset = 0;
-  FileEntryHandle fileEntry1 = new FileEntry(fname1,
-					     length1,
-					     offset);
-  offset += length1;
-  FileEntryHandle fileEntry2 = new FileEntry(fname2,
-					     length2,
-					     offset);
+    int64_t offset = 0;
+    SharedHandle<FileEntry> fileEntry1 = new FileEntry(fname1,
+						       length1,
+						       offset);
+    offset += length1;
+    SharedHandle<FileEntry> fileEntry2 = new FileEntry(fname2,
+						       length2,
+						       offset);
 
-  offset += length2;
-  FileEntryHandle fileEntry3 = new FileEntry(fname3,
-					     length3,
-					     offset);
+    offset += length2;
+    SharedHandle<FileEntry> fileEntry3 = new FileEntry(fname3,
+						       length3,
+						       offset);
 
-  offset += length3;
-  FileEntryHandle fileEntry4 = new FileEntry(fname4,
-					     length4,
-					     offset);
-  fileEntry4->setRequested(false);
+    offset += length3;
+    SharedHandle<FileEntry> fileEntry4 = new FileEntry(fname4,
+						       length4,
+						       offset);
+    fileEntry4->setRequested(false);
 
-  offset += length4;
-  FileEntryHandle fileEntry5 = new FileEntry(fname5,
-					     length5,
-					     offset);
+    offset += length4;
+    SharedHandle<FileEntry> fileEntry5 = new FileEntry(fname5,
+						       length5,
+						       offset);
 
-  offset += length5;
-  FileEntryHandle fileEntry6 = new FileEntry(fname6,
-					     length6,
-					     offset);
-  fileEntry6->setRequested(false);
+    offset += length5;
+    SharedHandle<FileEntry> fileEntry6 = new FileEntry(fname6,
+						       length6,
+						       offset);
+    fileEntry6->setRequested(false);
 
-  FileEntries fs;
-  fs.push_back(fileEntry1);
-  fs.push_back(fileEntry2);
-  fs.push_back(fileEntry3);
-  fs.push_back(fileEntry4);
-  fs.push_back(fileEntry5);
-  fs.push_back(fileEntry6);
-  diskAdaptor->setFileEntries(fs);
+    std::deque<SharedHandle<FileEntry> > fs;
+    fs.push_back(fileEntry1);
+    fs.push_back(fileEntry2);
+    fs.push_back(fileEntry3);
+    fs.push_back(fileEntry4);
+    fs.push_back(fileEntry5);
+    fs.push_back(fileEntry6);
+    diskAdaptor->setFileEntries(fs);
 
-  // we have to open file first.
-  diskAdaptor->initAndOpenFile();
-  MultiFileAllocationIteratorHandle itr = diskAdaptor->fileAllocationIterator();
-  while(!itr->finished()) {
-    itr->allocateChunk();
-  }
-  CPPUNIT_ASSERT_EQUAL((int64_t)length1, File(dir+"/"+topDir+"/"+fname1).size());
-  CPPUNIT_ASSERT_EQUAL((int64_t)length2, File(dir+"/"+topDir+"/"+fname2).size());
-  CPPUNIT_ASSERT_EQUAL((int64_t)length3, File(dir+"/"+topDir+"/"+fname3).size());
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, File(dir+"/"+topDir+"/"+fname4).size());
-  CPPUNIT_ASSERT_EQUAL((int64_t)length5, File(dir+"/"+topDir+"/"+fname5).size());
-  CPPUNIT_ASSERT_EQUAL((int64_t)0, File(dir+"/"+topDir+"/"+fname6).size());
+    // we have to open file first.
+    diskAdaptor->initAndOpenFile();
+    SharedHandle<MultiFileAllocationIterator> itr = diskAdaptor->fileAllocationIterator();
+    while(!itr->finished()) {
+      itr->allocateChunk();
+    }
+    CPPUNIT_ASSERT_EQUAL((int64_t)length1, File(dir+"/"+topDir+"/"+fname1).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length2, File(dir+"/"+topDir+"/"+fname2).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length3, File(dir+"/"+topDir+"/"+fname3).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, File(dir+"/"+topDir+"/"+fname4).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length5, File(dir+"/"+topDir+"/"+fname5).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, File(dir+"/"+topDir+"/"+fname6).size());
 
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << *e << std::endl;
+    std::string m = e->getMsg();
     delete e;
-    CPPUNIT_FAIL("exception was thrown");
+    CPPUNIT_FAIL(m);
   }
 }
+
+} // namespace aria2
diff --git a/test/NetrcAuthResolverTest.cc b/test/NetrcAuthResolverTest.cc
index 3b1ae28d..694871da 100644
--- a/test/NetrcAuthResolverTest.cc
+++ b/test/NetrcAuthResolverTest.cc
@@ -1,8 +1,10 @@
 #include "NetrcAuthResolver.h"
 #include "prefs.h"
+#include "Netrc.h"
+#include "AuthConfig.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class NetrcAuthResolverTest : public CppUnit::TestFixture {
 
@@ -11,9 +13,9 @@ class NetrcAuthResolverTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testResolveAuthConfig_with_userDefined);
   CPPUNIT_TEST_SUITE_END();
 private:
-  NetrcHandle _netrc;
+  SharedHandle<Netrc> _netrc;
   //SharedHandle<Option> _option;
-  NetrcAuthResolverHandle _resolver;
+  SharedHandle<NetrcAuthResolver> _resolver;
 public:
   void setUp()
   {
@@ -36,28 +38,30 @@ CPPUNIT_TEST_SUITE_REGISTRATION( NetrcAuthResolverTest );
 
 void NetrcAuthResolverTest::testResolveAuthConfig_without_userDefined()
 {
-  AuthConfigHandle authConfig = _resolver->resolveAuthConfig("localhost");
-  CPPUNIT_ASSERT_EQUAL(string("name:passwd"), authConfig->getAuthText());
+  SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost");
+  CPPUNIT_ASSERT_EQUAL(std::string("name:passwd"), authConfig->getAuthText());
 
   authConfig = _resolver->resolveAuthConfig("mymachine");
-  CPPUNIT_ASSERT_EQUAL(string("default:defaultpasswd"), authConfig->getAuthText());
+  CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpasswd"), authConfig->getAuthText());
 
   _resolver->setNetrc(0);
   authConfig = _resolver->resolveAuthConfig("localhost");
-  CPPUNIT_ASSERT_EQUAL(string("foo:bar"), authConfig->getAuthText());
+  CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText());
 
 }
 
 void NetrcAuthResolverTest::testResolveAuthConfig_with_userDefined()
 {
   _resolver->setUserDefinedAuthConfig(new AuthConfig("myname", "mypasswd"));
-  AuthConfigHandle authConfig = _resolver->resolveAuthConfig("localhost");
-  CPPUNIT_ASSERT_EQUAL(string("myname:mypasswd"), authConfig->getAuthText());
+  SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost");
+  CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 
   authConfig = _resolver->resolveAuthConfig("mymachine");
-  CPPUNIT_ASSERT_EQUAL(string("myname:mypasswd"), authConfig->getAuthText());
+  CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 
   _resolver->setNetrc(0);
   authConfig = _resolver->resolveAuthConfig("mymachine");
-  CPPUNIT_ASSERT_EQUAL(string("myname:mypasswd"), authConfig->getAuthText());
+  CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText());
 }
+
+} // namespace aria2
diff --git a/test/NetrcTest.cc b/test/NetrcTest.cc
index 145720fb..1bfd8233 100644
--- a/test/NetrcTest.cc
+++ b/test/NetrcTest.cc
@@ -1,8 +1,9 @@
 #include "Netrc.h"
 #include "Exception.h"
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class NetrcTest : public CppUnit::TestFixture {
 
@@ -36,44 +37,44 @@ void NetrcTest::testFindAuthenticator()
   netrc.addAuthenticator(new Authenticator("host2", "aria2", "aria2password", "aria2account"));
   netrc.addAuthenticator(new DefaultAuthenticator("default", "defaultpassword", "defaultaccount"));
 
-  AuthenticatorHandle aria2auth = netrc.findAuthenticator("host2");
+  SharedHandle<Authenticator> aria2auth = netrc.findAuthenticator("host2");
   CPPUNIT_ASSERT(!aria2auth.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), aria2auth->getLogin());
-  CPPUNIT_ASSERT_EQUAL(string("aria2password"), aria2auth->getPassword());
-  CPPUNIT_ASSERT_EQUAL(string("aria2account"), aria2auth->getAccount());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), aria2auth->getLogin());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2password"), aria2auth->getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2account"), aria2auth->getAccount());
 
-  AuthenticatorHandle defaultauth = netrc.findAuthenticator("host3");
+  SharedHandle<Authenticator> defaultauth = netrc.findAuthenticator("host3");
   CPPUNIT_ASSERT(!defaultauth.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("default"), defaultauth->getLogin());
-  CPPUNIT_ASSERT_EQUAL(string("defaultpassword"), defaultauth->getPassword());
-  CPPUNIT_ASSERT_EQUAL(string("defaultaccount"), defaultauth->getAccount());
+  CPPUNIT_ASSERT_EQUAL(std::string("default"), defaultauth->getLogin());
+  CPPUNIT_ASSERT_EQUAL(std::string("defaultpassword"), defaultauth->getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("defaultaccount"), defaultauth->getAccount());
 }
 
 void NetrcTest::testParse()
 {
   Netrc netrc;
   netrc.parse("sample.netrc");
-  Authenticators::const_iterator itr = netrc.getAuthenticators().begin();
+  std::deque<SharedHandle<Authenticator> >::const_iterator itr = netrc.getAuthenticators().begin();
 
-  AuthenticatorHandle tujikawaauth = *itr;
+  SharedHandle<Authenticator> tujikawaauth = *itr;
   CPPUNIT_ASSERT(!tujikawaauth.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("host1"), tujikawaauth->getMachine());
-  CPPUNIT_ASSERT_EQUAL(string("tujikawa"), tujikawaauth->getLogin());
-  CPPUNIT_ASSERT_EQUAL(string("tujikawapassword"), tujikawaauth->getPassword());
-  CPPUNIT_ASSERT_EQUAL(string("tujikawaaccount"), tujikawaauth->getAccount());
+  CPPUNIT_ASSERT_EQUAL(std::string("host1"), tujikawaauth->getMachine());
+  CPPUNIT_ASSERT_EQUAL(std::string("tujikawa"), tujikawaauth->getLogin());
+  CPPUNIT_ASSERT_EQUAL(std::string("tujikawapassword"), tujikawaauth->getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("tujikawaaccount"), tujikawaauth->getAccount());
   ++itr;
-  AuthenticatorHandle aria2auth = *itr;
+  SharedHandle<Authenticator> aria2auth = *itr;
   CPPUNIT_ASSERT(!aria2auth.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("host2"), aria2auth->getMachine());
-  CPPUNIT_ASSERT_EQUAL(string("aria2"), aria2auth->getLogin());
-  CPPUNIT_ASSERT_EQUAL(string("aria2password"), aria2auth->getPassword());
-  CPPUNIT_ASSERT_EQUAL(string("aria2account"), aria2auth->getAccount());
+  CPPUNIT_ASSERT_EQUAL(std::string("host2"), aria2auth->getMachine());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2"), aria2auth->getLogin());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2password"), aria2auth->getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2account"), aria2auth->getAccount());
   ++itr;
-  DefaultAuthenticatorHandle defaultauth = *itr;
+  SharedHandle<Authenticator> defaultauth = *itr;
   CPPUNIT_ASSERT(!defaultauth.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("anonymous"), defaultauth->getLogin());
-  CPPUNIT_ASSERT_EQUAL(string("ARIA2@USER"), defaultauth->getPassword());
-  CPPUNIT_ASSERT_EQUAL(string("ARIA2@ACCT"), defaultauth->getAccount());
+  CPPUNIT_ASSERT_EQUAL(std::string("anonymous"), defaultauth->getLogin());
+  CPPUNIT_ASSERT_EQUAL(std::string("ARIA2@USER"), defaultauth->getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("ARIA2@ACCT"), defaultauth->getAccount());
 }
 
 void NetrcTest::testParse_fileNotFound()
@@ -83,7 +84,7 @@ void NetrcTest::testParse_fileNotFound()
     netrc.parse("");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -103,7 +104,9 @@ void NetrcTest::testParse_malformedNetrc()
     netrc.parse("malformed.netrc");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
+
+} // namespace aria2
diff --git a/test/OptionHandlerTest.cc b/test/OptionHandlerTest.cc
index 95555bf1..c33c7fe3 100644
--- a/test/OptionHandlerTest.cc
+++ b/test/OptionHandlerTest.cc
@@ -1,8 +1,11 @@
 #include "OptionHandlerImpl.h"
 #include "prefs.h"
 #include "Exception.h"
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class OptionHandlerTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(OptionHandlerTest);
@@ -62,14 +65,14 @@ void OptionHandlerTest::testBooleanOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, V_TRUE);
-  CPPUNIT_ASSERT_EQUAL(string(V_TRUE), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string(V_TRUE), option.get("foo"));
   handler.parse(&option, V_FALSE);
-  CPPUNIT_ASSERT_EQUAL(string(V_FALSE), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string(V_FALSE), option.get("foo"));
   try {
     handler.parse(&option, "hello");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -81,7 +84,7 @@ void OptionHandlerTest::testNumberOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "0");
-  CPPUNIT_ASSERT_EQUAL(string("0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("0"), option.get("foo"));
 }
 
 void OptionHandlerTest::testNumberOptionHandler_min()
@@ -89,12 +92,12 @@ void OptionHandlerTest::testNumberOptionHandler_min()
   NumberOptionHandler handler("foo", 1);
   Option option;
   handler.parse(&option, "1");
-  CPPUNIT_ASSERT_EQUAL(string("1"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("1"), option.get("foo"));
   try {
     handler.parse(&option, "0");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 
@@ -105,12 +108,12 @@ void OptionHandlerTest::testNumberOptionHandler_max()
   NumberOptionHandler handler("foo", -1, 100);
   Option option;
   handler.parse(&option, "100");
-  CPPUNIT_ASSERT_EQUAL(string("100"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("100"), option.get("foo"));
   try {
     handler.parse(&option, "101");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -120,21 +123,21 @@ void OptionHandlerTest::testNumberOptionHandler_min_max()
   NumberOptionHandler handler("foo", 1, 100);
   Option option;
   handler.parse(&option, "1");
-  CPPUNIT_ASSERT_EQUAL(string("1"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("1"), option.get("foo"));
   handler.parse(&option, "100");
-  CPPUNIT_ASSERT_EQUAL(string("100"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("100"), option.get("foo"));
   try {
     handler.parse(&option, "0");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, "101");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -146,29 +149,29 @@ void OptionHandlerTest::testUnitNumberOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "4294967296");
-  CPPUNIT_ASSERT_EQUAL(string("4294967296"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("4294967296"), option.get("foo"));
   handler.parse(&option, "4096M");
-  CPPUNIT_ASSERT_EQUAL(string("4294967296"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("4294967296"), option.get("foo"));
   handler.parse(&option, "4096K");
-  CPPUNIT_ASSERT_EQUAL(string("4194304"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("4194304"), option.get("foo"));
   try {
     handler.parse(&option, "K");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     handler.parse(&option, "M");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     handler.parse(&option, "");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
 }
@@ -180,12 +183,12 @@ void OptionHandlerTest::testParameterOptionHandler_1argInit()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "value1");
-  CPPUNIT_ASSERT_EQUAL(string("value1"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value1"), option.get("foo"));
   try {
     handler.parse(&option, "value3");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -197,21 +200,21 @@ void OptionHandlerTest::testParameterOptionHandler_2argsInit()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "value1");
-  CPPUNIT_ASSERT_EQUAL(string("value1"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value1"), option.get("foo"));
   handler.parse(&option, "value2");
-  CPPUNIT_ASSERT_EQUAL(string("value2"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value2"), option.get("foo"));
   try {
     handler.parse(&option, "value3");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
 
 void OptionHandlerTest::testParameterOptionHandler_listInit()
 {
-  Strings validValues;
+  std::deque<std::string> validValues;
   validValues.push_back("value1");
   validValues.push_back("value2");
 
@@ -220,14 +223,14 @@ void OptionHandlerTest::testParameterOptionHandler_listInit()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "value1");
-  CPPUNIT_ASSERT_EQUAL(string("value1"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value1"), option.get("foo"));
   handler.parse(&option, "value2");
-  CPPUNIT_ASSERT_EQUAL(string("value2"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value2"), option.get("foo"));
   try {
     handler.parse(&option, "value3");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -239,9 +242,9 @@ void OptionHandlerTest::testDefaultOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "bar");
-  CPPUNIT_ASSERT_EQUAL(string("bar"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("bar"), option.get("foo"));
   handler.parse(&option, "");
-  CPPUNIT_ASSERT_EQUAL(string(""), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), option.get("foo"));
 }
 
 void OptionHandlerTest::testFloatNumberOptionHandler()
@@ -251,7 +254,7 @@ void OptionHandlerTest::testFloatNumberOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "1.0");
-  CPPUNIT_ASSERT_EQUAL(string("1.0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("1.0"), option.get("foo"));
 }
 
 void OptionHandlerTest::testFloatNumberOptionHandler_min()
@@ -259,12 +262,12 @@ void OptionHandlerTest::testFloatNumberOptionHandler_min()
   FloatNumberOptionHandler handler("foo", 0.0);
   Option option;
   handler.parse(&option, "0.0");
-  CPPUNIT_ASSERT_EQUAL(string("0.0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("0.0"), option.get("foo"));
   try {
     handler.parse(&option, "-0.1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -274,12 +277,12 @@ void OptionHandlerTest::testFloatNumberOptionHandler_max()
   FloatNumberOptionHandler handler("foo", -1, 10.0);
   Option option;
   handler.parse(&option, "10.0");
-  CPPUNIT_ASSERT_EQUAL(string("10.0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("10.0"), option.get("foo"));
   try {
     handler.parse(&option, "10.1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -289,21 +292,21 @@ void OptionHandlerTest::testFloatNumberOptionHandler_min_max()
   FloatNumberOptionHandler handler("foo", 0.0, 10.0);
   Option option;
   handler.parse(&option, "0.0");
-  CPPUNIT_ASSERT_EQUAL(string("0.0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("0.0"), option.get("foo"));
   handler.parse(&option, "10.0");
-  CPPUNIT_ASSERT_EQUAL(string("10.0"), option.get("foo"));
+  CPPUNIT_ASSERT_EQUAL(std::string("10.0"), option.get("foo"));
   try {
     handler.parse(&option, "-0.1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, "10.1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
@@ -315,13 +318,13 @@ void OptionHandlerTest::testLogOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "/tmp/log.txt");
-  CPPUNIT_ASSERT_EQUAL(string("/tmp/log.txt"), option.get(PREF_LOG));
-  CPPUNIT_ASSERT_EQUAL(string(""), option.get(PREF_STDOUT_LOG));
+  CPPUNIT_ASSERT_EQUAL(std::string("/tmp/log.txt"), option.get(PREF_LOG));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), option.get(PREF_STDOUT_LOG));
 
   option.clear();
   handler.parse(&option, "-");
-  CPPUNIT_ASSERT_EQUAL(string(""), option.get(PREF_LOG));
-  CPPUNIT_ASSERT_EQUAL(string(V_TRUE), option.get(PREF_STDOUT_LOG));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), option.get(PREF_LOG));
+  CPPUNIT_ASSERT_EQUAL(std::string(V_TRUE), option.get(PREF_STDOUT_LOG));
 }
 
 void OptionHandlerTest::testHttpProxyOptionHandler()
@@ -333,44 +336,46 @@ void OptionHandlerTest::testHttpProxyOptionHandler()
   CPPUNIT_ASSERT(!handler.canHandle("foobar"));
   Option option;
   handler.parse(&option, "bar:80");
-  CPPUNIT_ASSERT_EQUAL(string("bar:80"), option.get(PREF_HTTP_PROXY));
-  CPPUNIT_ASSERT_EQUAL(string("bar"), option.get(PREF_HTTP_PROXY_HOST));
-  CPPUNIT_ASSERT_EQUAL(string("80"), option.get(PREF_HTTP_PROXY_PORT));
-  CPPUNIT_ASSERT_EQUAL(string(V_TRUE), option.get(PREF_HTTP_PROXY_ENABLED));
+  CPPUNIT_ASSERT_EQUAL(std::string("bar:80"), option.get(PREF_HTTP_PROXY));
+  CPPUNIT_ASSERT_EQUAL(std::string("bar"), option.get(PREF_HTTP_PROXY_HOST));
+  CPPUNIT_ASSERT_EQUAL(std::string("80"), option.get(PREF_HTTP_PROXY_PORT));
+  CPPUNIT_ASSERT_EQUAL(std::string(V_TRUE), option.get(PREF_HTTP_PROXY_ENABLED));
 
   try {
     handler.parse(&option, "bar");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, "bar:");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, ":");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, ":80");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
   try {
     handler.parse(&option, "foo:bar");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   }
 }
+
+} // namespace aria2
diff --git a/test/OptionTest.cc b/test/OptionTest.cc
index c3fc830b..c219103a 100644
--- a/test/OptionTest.cc
+++ b/test/OptionTest.cc
@@ -2,7 +2,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class OptionTest:public CppUnit::TestFixture {
 
@@ -30,7 +30,7 @@ void OptionTest::testPutAndGet() {
   op.put("key", "value");
   
   CPPUNIT_ASSERT(op.defined("key"));
-  CPPUNIT_ASSERT_EQUAL(string("value"), op.get("key"));
+  CPPUNIT_ASSERT_EQUAL(std::string("value"), op.get("key"));
 }
 
 void OptionTest::testPutAndGetAsInt() {
@@ -47,3 +47,5 @@ void OptionTest::testPutAndGetAsDouble() {
   
   CPPUNIT_ASSERT_EQUAL(10.0, op.getAsDouble("key"));
 }
+
+} // namespace aria2
diff --git a/test/PStringBuildVisitorTest.cc b/test/PStringBuildVisitorTest.cc
index 92717e29..c88ac60e 100644
--- a/test/PStringBuildVisitorTest.cc
+++ b/test/PStringBuildVisitorTest.cc
@@ -5,6 +5,8 @@
 #include "FixedWidthNumberDecorator.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class PStringBuildVisitorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(PStringBuildVisitorTest);
@@ -28,64 +30,66 @@ CPPUNIT_TEST_SUITE_REGISTRATION( PStringBuildVisitorTest );
 
 void PStringBuildVisitorTest::testVisit_select()
 {
-  PStringSegmentHandle segment1 = new PStringSegment("/tango");
+  SharedHandle<PStringSegment> segment1 = new PStringSegment("/tango");
 
   const char* select1data[] = { "alpha", "bravo", "charlie" };
   
-  PStringSelectHandle select1 =
-    new PStringSelect(Strings(&select1data[0], &select1data[3]), segment1);
+  SharedHandle<PStringSelect> select1 =
+    new PStringSelect(std::deque<std::string>(&select1data[0], &select1data[3]), segment1);
 
-  PStringBuildVisitorHandle v = new PStringBuildVisitor();
+  PStringBuildVisitor v;
 
-  select1->accept(v);
+  select1->accept(&v);
 
-  CPPUNIT_ASSERT_EQUAL((size_t)3, v->getURIs().size());
-  CPPUNIT_ASSERT_EQUAL(string("alpha/tango"), v->getURIs()[0]);
-  CPPUNIT_ASSERT_EQUAL(string("bravo/tango"), v->getURIs()[1]);
-  CPPUNIT_ASSERT_EQUAL(string("charlie/tango"), v->getURIs()[2]);
+  CPPUNIT_ASSERT_EQUAL((size_t)3, v.getURIs().size());
+  CPPUNIT_ASSERT_EQUAL(std::string("alpha/tango"), v.getURIs()[0]);
+  CPPUNIT_ASSERT_EQUAL(std::string("bravo/tango"), v.getURIs()[1]);
+  CPPUNIT_ASSERT_EQUAL(std::string("charlie/tango"), v.getURIs()[2]);
 }
 
 void PStringBuildVisitorTest::testVisit_numLoop()
 {
-  PStringSegmentHandle segment1 = new PStringSegment("/tango");
+  SharedHandle<PStringSegment> segment1 = new PStringSegment("/tango");
 
-  PStringNumLoopHandle loop1 =
+  SharedHandle<PStringNumLoop> loop1 =
     new PStringNumLoop(0, 5, 2, new FixedWidthNumberDecorator(2), segment1);
 
-  PStringBuildVisitorHandle v = new PStringBuildVisitor();
+  PStringBuildVisitor v;
 
-  loop1->accept(v);
+  loop1->accept(&v);
 
-  CPPUNIT_ASSERT_EQUAL((size_t)3, v->getURIs().size());
-  CPPUNIT_ASSERT_EQUAL(string("00/tango"), v->getURIs()[0]);
-  CPPUNIT_ASSERT_EQUAL(string("02/tango"), v->getURIs()[1]);
-  CPPUNIT_ASSERT_EQUAL(string("04/tango"), v->getURIs()[2]);
+  CPPUNIT_ASSERT_EQUAL((size_t)3, v.getURIs().size());
+  CPPUNIT_ASSERT_EQUAL(std::string("00/tango"), v.getURIs()[0]);
+  CPPUNIT_ASSERT_EQUAL(std::string("02/tango"), v.getURIs()[1]);
+  CPPUNIT_ASSERT_EQUAL(std::string("04/tango"), v.getURIs()[2]);
 }
 
 void PStringBuildVisitorTest::testVisit_select_numLoop()
 {
-  PStringSegmentHandle segment1 = new PStringSegment("/tango");
+  SharedHandle<PStringSegment> segment1 = new PStringSegment("/tango");
 
   const char* select1data[] = { "alpha", "bravo", "charlie" };
   
-  PStringSelectHandle select1 =
-    new PStringSelect(Strings(&select1data[0], &select1data[3]), segment1);
+  SharedHandle<PStringSelect> select1 =
+    new PStringSelect(std::deque<std::string>(&select1data[0], &select1data[3]), segment1);
 
-  PStringNumLoopHandle loop1 =
+  SharedHandle<PStringNumLoop> loop1 =
     new PStringNumLoop(0, 5, 2, new FixedWidthNumberDecorator(2), select1);
 
-  PStringBuildVisitorHandle v = new PStringBuildVisitor();
+  PStringBuildVisitor v;
 
-  loop1->accept(v);
+  loop1->accept(&v);
 
-  CPPUNIT_ASSERT_EQUAL((size_t)9, v->getURIs().size());
-  CPPUNIT_ASSERT_EQUAL(string("00alpha/tango"), v->getURIs()[0]);
-  CPPUNIT_ASSERT_EQUAL(string("00bravo/tango"), v->getURIs()[1]);
-  CPPUNIT_ASSERT_EQUAL(string("00charlie/tango"), v->getURIs()[2]);
-  CPPUNIT_ASSERT_EQUAL(string("02alpha/tango"), v->getURIs()[3]);
-  CPPUNIT_ASSERT_EQUAL(string("02bravo/tango"), v->getURIs()[4]);
-  CPPUNIT_ASSERT_EQUAL(string("02charlie/tango"), v->getURIs()[5]);
-  CPPUNIT_ASSERT_EQUAL(string("04alpha/tango"), v->getURIs()[6]);
-  CPPUNIT_ASSERT_EQUAL(string("04bravo/tango"), v->getURIs()[7]);
-  CPPUNIT_ASSERT_EQUAL(string("04charlie/tango"), v->getURIs()[8]);
+  CPPUNIT_ASSERT_EQUAL((size_t)9, v.getURIs().size());
+  CPPUNIT_ASSERT_EQUAL(std::string("00alpha/tango"), v.getURIs()[0]);
+  CPPUNIT_ASSERT_EQUAL(std::string("00bravo/tango"), v.getURIs()[1]);
+  CPPUNIT_ASSERT_EQUAL(std::string("00charlie/tango"), v.getURIs()[2]);
+  CPPUNIT_ASSERT_EQUAL(std::string("02alpha/tango"), v.getURIs()[3]);
+  CPPUNIT_ASSERT_EQUAL(std::string("02bravo/tango"), v.getURIs()[4]);
+  CPPUNIT_ASSERT_EQUAL(std::string("02charlie/tango"), v.getURIs()[5]);
+  CPPUNIT_ASSERT_EQUAL(std::string("04alpha/tango"), v.getURIs()[6]);
+  CPPUNIT_ASSERT_EQUAL(std::string("04bravo/tango"), v.getURIs()[7]);
+  CPPUNIT_ASSERT_EQUAL(std::string("04charlie/tango"), v.getURIs()[8]);
 }
+
+} // namespace aria2
diff --git a/test/ParameterizedStringParserTest.cc b/test/ParameterizedStringParserTest.cc
index 558674dd..638e1afc 100644
--- a/test/ParameterizedStringParserTest.cc
+++ b/test/ParameterizedStringParserTest.cc
@@ -3,8 +3,11 @@
 #include "PStringSegment.h"
 #include "PStringNumLoop.h"
 #include "FatalException.h"
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class ParameterizedStringParserTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(ParameterizedStringParserTest);
@@ -50,25 +53,25 @@ CPPUNIT_TEST_SUITE_REGISTRATION( ParameterizedStringParserTest );
 
 void ParameterizedStringParserTest::testParse_select()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("{alpha, bravo, charlie}");
-  PStringSelectHandle select = ls;
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("{alpha, bravo, charlie}");
+  SharedHandle<PStringSelect> select = ls;
   CPPUNIT_ASSERT(!select.isNull());
 
-  Strings values = select->getValues();
+  std::deque<std::string> values = select->getValues();
   CPPUNIT_ASSERT_EQUAL((size_t)3, values.size());
 
-  CPPUNIT_ASSERT_EQUAL(string("alpha"), values[0]);
-  CPPUNIT_ASSERT_EQUAL(string("bravo"), values[1]);
-  CPPUNIT_ASSERT_EQUAL(string("charlie"), values[2]);
+  CPPUNIT_ASSERT_EQUAL(std::string("alpha"), values[0]);
+  CPPUNIT_ASSERT_EQUAL(std::string("bravo"), values[1]);
+  CPPUNIT_ASSERT_EQUAL(std::string("charlie"), values[2]);
 }
 
 void ParameterizedStringParserTest::testParse_select_empty()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("{}");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("{}");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception thrown.");
@@ -78,10 +81,10 @@ void ParameterizedStringParserTest::testParse_select_empty()
 void ParameterizedStringParserTest::testParse_select_missingParen()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("{alpha");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("{alpha");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception was thrown.");
@@ -90,38 +93,38 @@ void ParameterizedStringParserTest::testParse_select_missingParen()
 
 void ParameterizedStringParserTest::testParse_segment()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("hello world");
-  PStringSegmentHandle segment = ls;
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("hello world");
+  SharedHandle<PStringSegment> segment = ls;
   CPPUNIT_ASSERT(!segment.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("hello world"), segment->getValue());
+  CPPUNIT_ASSERT_EQUAL(std::string("hello world"), segment->getValue());
 }
 
 void ParameterizedStringParserTest::testParse_segment_select()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("file:///{alpha, bravo, charlie}/tango");
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("file:///{alpha, bravo, charlie}/tango");
 
-  PStringSegmentHandle segment1 = ls;
+  SharedHandle<PStringSegment> segment1 = ls;
   CPPUNIT_ASSERT(!segment1.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("file:///"), segment1->getValue());
+  CPPUNIT_ASSERT_EQUAL(std::string("file:///"), segment1->getValue());
 
-  PStringSelectHandle select1 = segment1->getNext();
+  SharedHandle<PStringSelect> select1 = segment1->getNext();
   CPPUNIT_ASSERT(!select1.isNull());
-  Strings selectValues = select1->getValues();
+  std::deque<std::string> selectValues = select1->getValues();
   CPPUNIT_ASSERT_EQUAL((size_t)3, selectValues.size());
-  CPPUNIT_ASSERT_EQUAL(string("alpha"), selectValues[0]);
-  CPPUNIT_ASSERT_EQUAL(string("bravo"), selectValues[1]);
-  CPPUNIT_ASSERT_EQUAL(string("charlie"), selectValues[2]);
+  CPPUNIT_ASSERT_EQUAL(std::string("alpha"), selectValues[0]);
+  CPPUNIT_ASSERT_EQUAL(std::string("bravo"), selectValues[1]);
+  CPPUNIT_ASSERT_EQUAL(std::string("charlie"), selectValues[2]);
 
-  PStringSegmentHandle segment2 = select1->getNext();
+  SharedHandle<PStringSegment> segment2 = select1->getNext();
   CPPUNIT_ASSERT(!segment2.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("/tango"), segment2->getValue());
+  CPPUNIT_ASSERT_EQUAL(std::string("/tango"), segment2->getValue());
 }
 
 void ParameterizedStringParserTest::testParse_loop()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("[1-10:2]");
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[1-10:2]");
 
-  PStringNumLoopHandle loop1 = ls;
+  SharedHandle<PStringNumLoop> loop1 = ls;
   CPPUNIT_ASSERT(!loop1.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, loop1->getStartValue());
   CPPUNIT_ASSERT_EQUAL((int32_t)10, loop1->getEndValue());
@@ -131,10 +134,10 @@ void ParameterizedStringParserTest::testParse_loop()
 void ParameterizedStringParserTest::testParse_loop_empty()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("[]");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[]");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception was thrown.");
@@ -144,10 +147,10 @@ void ParameterizedStringParserTest::testParse_loop_empty()
 void ParameterizedStringParserTest::testParse_loop_missingParen()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("[");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception was thrown.");
@@ -157,10 +160,10 @@ void ParameterizedStringParserTest::testParse_loop_missingParen()
 void ParameterizedStringParserTest::testParse_loop_missingStep()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("[1-10:]");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[1-10:]");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception was thrown.");
@@ -170,10 +173,10 @@ void ParameterizedStringParserTest::testParse_loop_missingStep()
 void ParameterizedStringParserTest::testParse_loop_missingRange()
 {
   try {
-    PStringDatumHandle ls = ParameterizedStringParser().parse("[1-]");
+    SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[1-]");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("unexpected exception was thrown.");
@@ -182,9 +185,9 @@ void ParameterizedStringParserTest::testParse_loop_missingRange()
 
 void ParameterizedStringParserTest::testParse_alphaLoop()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("[a-z:2]");
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("[a-z:2]");
 
-  PStringNumLoopHandle loop1 = ls;
+  SharedHandle<PStringNumLoop> loop1 = ls;
   CPPUNIT_ASSERT(!loop1.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, loop1->getStartValue());
   CPPUNIT_ASSERT_EQUAL((int32_t)25, loop1->getEndValue());
@@ -197,7 +200,7 @@ void ParameterizedStringParserTest::testParse_loop_mixedChar()
     ParameterizedStringParser().parse("[1-z:2]");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("FatalException must be thrown.");
@@ -210,7 +213,7 @@ void ParameterizedStringParserTest::testParse_loop_mixedCase()
     ParameterizedStringParser().parse("[a-Z:2]");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(FatalException* e) {
-    cerr << e->getMsg() << endl;
+    std::cerr << e->getMsg() << std::endl;
     delete e;
   } catch(...) {
     CPPUNIT_FAIL("FatalException must be thrown.");
@@ -219,19 +222,21 @@ void ParameterizedStringParserTest::testParse_loop_mixedCase()
 
 void ParameterizedStringParserTest::testParse_segment_loop()
 {
-  PStringDatumHandle ls = ParameterizedStringParser().parse("http://server[1-3]/file");
+  SharedHandle<PStringDatum> ls = ParameterizedStringParser().parse("http://server[1-3]/file");
 
-  PStringSegmentHandle segment1 = ls;
+  SharedHandle<PStringSegment> segment1 = ls;
   CPPUNIT_ASSERT(!segment1.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("http://server"), segment1->getValue());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://server"), segment1->getValue());
 
-  PStringNumLoopHandle loop1 = segment1->getNext();
+  SharedHandle<PStringNumLoop> loop1 = segment1->getNext();
   CPPUNIT_ASSERT(!loop1.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, loop1->getStartValue());
   CPPUNIT_ASSERT_EQUAL((int32_t)3, loop1->getEndValue());
   CPPUNIT_ASSERT_EQUAL((int32_t)1, loop1->getStep());
 
-  PStringSegmentHandle segment2 = loop1->getNext();
+  SharedHandle<PStringSegment> segment2 = loop1->getNext();
   CPPUNIT_ASSERT(!segment2.isNull());
-  CPPUNIT_ASSERT_EQUAL(string("/file"), segment2->getValue());
+  CPPUNIT_ASSERT_EQUAL(std::string("/file"), segment2->getValue());
 }
+
+} // namespace aria2
diff --git a/test/PeerMessageUtilTest.cc b/test/PeerMessageUtilTest.cc
index a3c236e9..90be6856 100644
--- a/test/PeerMessageUtilTest.cc
+++ b/test/PeerMessageUtilTest.cc
@@ -1,9 +1,10 @@
 #include "common.h"
 #include "PeerMessageUtil.h"
 #include "a2netcompat.h"
+#include <cstring>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class PeerMessageUtilTest:public CppUnit::TestFixture {
 
@@ -35,3 +36,5 @@ void createNLengthMessage(char* msg, int msgLen, int payloadLen, int id) {
   setIntParam(msg, payloadLen);
   msg[4] = (char)id;
 }
+
+} // namespace aria2
diff --git a/test/PeerTest.cc b/test/PeerTest.cc
index c5b6e1a6..48b1957a 100644
--- a/test/PeerTest.cc
+++ b/test/PeerTest.cc
@@ -1,7 +1,7 @@
 #include "Peer.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class PeerTest:public CppUnit::TestFixture {
 
@@ -12,7 +12,7 @@ class PeerTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testOperatorEqual);
   CPPUNIT_TEST_SUITE_END();
 private:
-  PeerHandle peer;
+  SharedHandle<Peer> peer;
 public:
   PeerTest():peer(0) {}
 
@@ -42,7 +42,7 @@ void PeerTest::testAmAllowedIndexSet() {
 }
 
 void PeerTest::testGetId() {
-  CPPUNIT_ASSERT_EQUAL(string("f05897fc14a41cb3400e283e189158656d7184da"),
+  CPPUNIT_ASSERT_EQUAL(std::string("f05897fc14a41cb3400e283e189158656d7184da"),
 		       peer->getId());
 }
 
@@ -57,3 +57,5 @@ void PeerTest::testOperatorEqual()
     CPPUNIT_ASSERT(p1 != p2);
   }
 }
+
+} // namespace aria2
diff --git a/test/PieceTest.cc b/test/PieceTest.cc
index 0c554b8d..7f841b46 100644
--- a/test/PieceTest.cc
+++ b/test/PieceTest.cc
@@ -2,7 +2,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class PieceTest:public CppUnit::TestFixture {
 
@@ -32,7 +32,7 @@ void PieceTest::testCompleteBlock()
   Piece p(0, blockLength*10, blockLength);
   
   // 5 is a block index inside the Piece p.
-  PieceHandle subPiece = new Piece(5, blockLength, 1);
+  SharedHandle<Piece> subPiece = new Piece(5, blockLength, 1);
   p.addSubPiece(subPiece);
   
   CPPUNIT_ASSERT(!p.getSubPiece(5).isNull());
@@ -65,10 +65,10 @@ void PieceTest::testIsRangeComplete_subPiece()
   
   CPPUNIT_ASSERT(!p.isRangeComplete(8*1024, 32*1024));
 
-  PieceHandle startSubPiece = new Piece(0, blockLength, 1);
+  SharedHandle<Piece> startSubPiece = new Piece(0, blockLength, 1);
   p.addSubPiece(startSubPiece);
   
-  PieceHandle endSubPiece = new Piece(2, blockLength, 1);
+  SharedHandle<Piece> endSubPiece = new Piece(2, blockLength, 1);
   p.addSubPiece(endSubPiece);
   
   p.completeBlock(1);
@@ -92,7 +92,7 @@ void PieceTest::testGetCompletedLength()
   int32_t blockLength = 16*1024;
   Piece p(0, blockLength*10, blockLength);
   
-  PieceHandle subPiece = new Piece(0, blockLength, 1);
+  SharedHandle<Piece> subPiece = new Piece(0, blockLength, 1);
   for(int32_t i = 0; i < blockLength-1; ++i) {
     subPiece->completeBlock(i);
   }
@@ -104,3 +104,5 @@ void PieceTest::testGetCompletedLength()
   
   CPPUNIT_ASSERT_EQUAL(blockLength*3+blockLength-1, p.getCompletedLength());
 }
+
+} // namespace aria2
diff --git a/test/RequestGroupManTest.cc b/test/RequestGroupManTest.cc
index ef7eb707..d59e40a4 100644
--- a/test/RequestGroupManTest.cc
+++ b/test/RequestGroupManTest.cc
@@ -5,9 +5,10 @@
 #include "RequestGroup.h"
 #include "Option.h"
 #include "DownloadResult.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class RequestGroupManTest : public CppUnit::TestFixture {
 
@@ -20,8 +21,8 @@ private:
 public:
   void setUp()
   {
-    CUIDCounterHandle counter = new CUIDCounter();
-    CUIDCounterSingletonHolder::instance(counter);
+    SharedHandle<CUIDCounter> counter = new CUIDCounter();
+    SingletonHolder<SharedHandle<CUIDCounter> >::instance(counter);
   }
 
   void testIsSameFileBeingDownloaded();
@@ -35,14 +36,14 @@ void RequestGroupManTest::testIsSameFileBeingDownloaded()
 {
   Option option;
 
-  Strings uris;
+  std::deque<std::string> uris;
   uris.push_back("http://localhost/aria2.tar.bz2");
-  RequestGroupHandle rg1 = new RequestGroup(&option, uris);
-  RequestGroupHandle rg2 = new RequestGroup(&option, uris);
+  SharedHandle<RequestGroup> rg1 = new RequestGroup(&option, uris);
+  SharedHandle<RequestGroup> rg2 = new RequestGroup(&option, uris);
 
-  SingleFileDownloadContextHandle dctx1 =
+  SharedHandle<SingleFileDownloadContext> dctx1 =
     new SingleFileDownloadContext(0, 0, "aria2.tar.bz2");
-  SingleFileDownloadContextHandle dctx2 =
+  SharedHandle<SingleFileDownloadContext> dctx2 =
     new SingleFileDownloadContext(0, 0, "aria2.tar.bz2");
 
   rg1->setDownloadContext(dctx1);
@@ -66,3 +67,5 @@ void RequestGroupManTest::testGetInitialCommands()
 {
   // TODO implement later
 }
+
+} // namespace aria2
diff --git a/test/RequestGroupTest.cc b/test/RequestGroupTest.cc
index 7ee7364a..90dc3b66 100644
--- a/test/RequestGroupTest.cc
+++ b/test/RequestGroupTest.cc
@@ -3,7 +3,7 @@
 #include "Option.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class RequestGroupTest : public CppUnit::TestFixture {
 
@@ -26,10 +26,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION( RequestGroupTest );
 void RequestGroupTest::testRegisterSearchRemove()
 {
   Option op;
-  RequestGroup rg(&op, Strings());
-  ServerHostHandle sv1 = new ServerHost(1, "localhost1");
-  ServerHostHandle sv2 = new ServerHost(2, "localhost2");
-  ServerHostHandle sv3 = new ServerHost(3, "localhost3");
+  RequestGroup rg(&op, std::deque<std::string>());
+  SharedHandle<ServerHost> sv1 = new ServerHost(1, "localhost1");
+  SharedHandle<ServerHost> sv2 = new ServerHost(2, "localhost2");
+  SharedHandle<ServerHost> sv3 = new ServerHost(3, "localhost3");
 
   rg.registerServerHost(sv3);
   rg.registerServerHost(sv1);
@@ -38,21 +38,21 @@ void RequestGroupTest::testRegisterSearchRemove()
   CPPUNIT_ASSERT(rg.searchServerHost(0).isNull());
 
   {
-    ServerHostHandle sv = rg.searchServerHost(1);
+    SharedHandle<ServerHost> sv = rg.searchServerHost(1);
     CPPUNIT_ASSERT(!sv.isNull());
-    CPPUNIT_ASSERT_EQUAL(string("localhost1"), sv->getHostname());
+    CPPUNIT_ASSERT_EQUAL(std::string("localhost1"), sv->getHostname());
   }
 
   rg.removeServerHost(1);
 
   {
-    ServerHostHandle sv = rg.searchServerHost(1);
+    SharedHandle<ServerHost> sv = rg.searchServerHost(1);
     CPPUNIT_ASSERT(sv.isNull());
   }
   {
-    ServerHostHandle sv = rg.searchServerHost(2);
+    SharedHandle<ServerHost> sv = rg.searchServerHost(2);
     CPPUNIT_ASSERT(!sv.isNull());
-    CPPUNIT_ASSERT_EQUAL(string("localhost2"), sv->getHostname());
+    CPPUNIT_ASSERT_EQUAL(std::string("localhost2"), sv->getHostname());
   }
 }
 
@@ -62,9 +62,11 @@ void RequestGroupTest::testRemoveURIWhoseHostnameIs()
 			 "ftp://localhost/aria2.zip",
 			 "http://mirror/aria2.zip" };
   Option op;
-  RequestGroup rg(&op, Strings(&uris[0], &uris[3]));
+  RequestGroup rg(&op, std::deque<std::string>(&uris[0], &uris[3]));
   rg.removeURIWhoseHostnameIs("localhost");
   CPPUNIT_ASSERT_EQUAL((size_t)1, rg.getRemainingUris().size());
-  CPPUNIT_ASSERT_EQUAL(string("http://mirror/aria2.zip"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://mirror/aria2.zip"),
 		       rg.getRemainingUris()[0]);
 }
+
+} // namespace aria2
diff --git a/test/RequestTest.cc b/test/RequestTest.cc
index a7a3382d..0497f012 100644
--- a/test/RequestTest.cc
+++ b/test/RequestTest.cc
@@ -4,6 +4,8 @@
 #include "NetrcAuthResolver.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class RequestTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(RequestTest);
@@ -68,16 +70,16 @@ void RequestTest::testSetUrl1() {
   bool v = req.setUrl("http://aria.rednoah.com/");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com/"), req.getUrl());
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com/"), req.getCurrentUrl());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPreviousUrl());
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getCurrentUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
 }
 
 void RequestTest::testSetUrl2() {
@@ -88,14 +90,14 @@ void RequestTest::testSetUrl2() {
   CPPUNIT_ASSERT(v);
 
   // referer is unchaged
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com:8080"), req.getReferer());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080"), req.getReferer());
   // previousUrl must equal to referer;
   CPPUNIT_ASSERT_EQUAL(req.getReferer(), req.getPreviousUrl());
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)8080, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("index.html"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
 }
 
 void RequestTest::testSetUrl3() {
@@ -103,11 +105,11 @@ void RequestTest::testSetUrl3() {
   bool v = req.setUrl("http://aria.rednoah.com/aria2/index.html");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/aria2"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("index.html"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/aria2"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
 }
 
 void RequestTest::testSetUrl4() {
@@ -115,11 +117,11 @@ void RequestTest::testSetUrl4() {
   bool v = req.setUrl("http://aria.rednoah.com/aria2/aria3/index.html");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/aria2/aria3"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("index.html"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/aria2/aria3"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
 }
 
 void RequestTest::testSetUrl5() {
@@ -127,11 +129,11 @@ void RequestTest::testSetUrl5() {
   bool v = req.setUrl("http://aria.rednoah.com/aria2/aria3/");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/aria2/aria3"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/aria2/aria3"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
 }
 
 void RequestTest::testSetUrl6() {
@@ -139,11 +141,11 @@ void RequestTest::testSetUrl6() {
   bool v = req.setUrl("http://aria.rednoah.com/aria2/aria3");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/aria2"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria3"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/aria2"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria3"), req.getFile());
 }
 
 void RequestTest::testSetUrl7() {
@@ -179,10 +181,10 @@ void RequestTest::testSetUrl11() {
   bool v = req.setUrl("http://host?query/");
 
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("?query/"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("?query/"), req.getFile());
 }
 
 void RequestTest::testSetUrl12() {
@@ -190,10 +192,10 @@ void RequestTest::testSetUrl12() {
   bool v = req.setUrl("http://host?query");
   
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("?query"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("?query"), req.getFile());
 }
 
 void RequestTest::testSetUrl13() {
@@ -201,10 +203,10 @@ void RequestTest::testSetUrl13() {
   bool v = req.setUrl("http://host/?query");
   
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("?query"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("?query"), req.getFile());
 }
 
 void RequestTest::testSetUrl14() {
@@ -212,11 +214,11 @@ void RequestTest::testSetUrl14() {
   bool v = req.setUrl("http://host:8080/abc?query");
   
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
   CPPUNIT_ASSERT_EQUAL((int32_t)8080, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("abc?query"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("abc?query"), req.getFile());
 }
 
 void RequestTest::testSetUrl15()
@@ -225,10 +227,10 @@ void RequestTest::testSetUrl15()
   // 2 slashes after host name and dir
   bool v = req.setUrl("http://host//dir1/dir2//file");
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/dir1/dir2"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("file"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/dir1/dir2"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("file"), req.getFile());
 }
 
 void RequestTest::testSetUrl16()
@@ -237,10 +239,10 @@ void RequestTest::testSetUrl16()
   // 2 slashes before file
   bool v = req.setUrl("http://host//file");
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("file"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("file"), req.getFile());
 }
 
 void RequestTest::testSetUrl17()
@@ -248,10 +250,10 @@ void RequestTest::testSetUrl17()
   Request req;
   bool v = req.setUrl("http://host:80/file<with%2 %20space/file with space;param?a=/?");
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("host"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/file%3cwith%252%20%20space"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("file%20with%20space;param?a=/?"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/file%3cwith%252%20%20space"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("file%20with%20space;param?a=/?"), req.getFile());
 }
 
 void RequestTest::testRedirectUrl() {
@@ -264,37 +266,37 @@ void RequestTest::testRedirectUrl() {
   // keep-alive set to be false after redirection
   CPPUNIT_ASSERT(!req.isKeepAlive());
   // url must be the same
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com:8080/aria2/index.html"),
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/aria2/index.html"),
 		       req.getUrl());
   // currentUrl must be updated
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.co.jp/"), req.getCurrentUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.co.jp/"), req.getCurrentUrl());
   // previousUrl must be "" when redirection
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPreviousUrl());
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.co.jp"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.co.jp"), req.getHost());
   CPPUNIT_ASSERT_EQUAL((int32_t)80, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("/"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
 }
 
 void RequestTest::testRedirectUrl2() {
   Request req;
   req.setUrl("http://aria.rednoah.com/download.html");
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUrl());
   req.setReferer("http://aria.rednoah.com/");
   // previousUrl is updated when referer is specified
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com/"), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getPreviousUrl());
   req.redirectUrl("http://aria.rednoah.com/403.html");
 
   // previousUrl must be "" when redirection
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUrl());
   // referer is unchagned
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com/"), req.getReferer());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getReferer());
 
   req.redirectUrl("http://aria.rednoah.com/error.html");
 
   // previousUrl must be "" when redirection
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUrl());
 }
   
 void RequestTest::testResetUrl() {
@@ -306,55 +308,55 @@ void RequestTest::testResetUrl() {
   bool v3 = req.resetUrl();
   CPPUNIT_ASSERT(v3);
   // currentUrl must equal to url
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com:8080/aria2/index.html"), req.getUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/aria2/index.html"), req.getUrl());
   CPPUNIT_ASSERT_EQUAL(req.getUrl(), req.getCurrentUrl());
   // previousUrl must equal to referer
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com:8080/"), req.getPreviousUrl());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"), req.getPreviousUrl());
   // referer is unchanged
-  CPPUNIT_ASSERT_EQUAL(string("http://aria.rednoah.com:8080/"), req.getReferer());
-  CPPUNIT_ASSERT_EQUAL(string("http"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"), req.getReferer());
+  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)8080, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("aria.rednoah.com"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/aria2"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("index.html"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/aria2"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
 }
 
 void RequestTest::testInnerLink() {
   Request req;
   bool v = req.setUrl("http://aria.rednoah.com/index.html#download");
   CPPUNIT_ASSERT(v);
-  CPPUNIT_ASSERT_EQUAL(string("index.html"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
 }
 
 void RequestTest::testSetUrl_zeroUsername()
 {
   Request req;
   CPPUNIT_ASSERT(req.setUrl("ftp://@localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string("ftp"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)21, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/download"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
 
   CPPUNIT_ASSERT(req.setUrl("ftp://:@localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string("ftp"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)21, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/download"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
 
   CPPUNIT_ASSERT(req.setUrl("ftp://:pass@localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string("ftp"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)21, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/download"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string("pass"), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string("pass"), req.getPassword());
 
 }
 
@@ -362,30 +364,32 @@ void RequestTest::testSetUrl_username()
 {
   Request req;
   CPPUNIT_ASSERT(req.setUrl("ftp://aria2user@localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string("ftp"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)21, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/download"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string("aria2user"), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2user"), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
 }
 
 void RequestTest::testSetUrl_usernamePassword()
 {
   Request req;
   CPPUNIT_ASSERT(req.setUrl("ftp://aria2user%40:aria2pass%40@localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string("ftp"), req.getProtocol());
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
   CPPUNIT_ASSERT_EQUAL((int32_t)21, req.getPort());
-  CPPUNIT_ASSERT_EQUAL(string("localhost"), req.getHost());
-  CPPUNIT_ASSERT_EQUAL(string("/download"), req.getDir());
-  CPPUNIT_ASSERT_EQUAL(string("aria2-1.0.0.tar.bz2"), req.getFile());
-  CPPUNIT_ASSERT_EQUAL(string("aria2user@"), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string("aria2pass@"), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
+  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2user@"), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2pass@"), req.getPassword());
 
   // make sure that after new url is set, username and password are updated.
   CPPUNIT_ASSERT(req.setUrl("ftp://localhost/download/aria2-1.0.0.tar.bz2"));
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getUsername());
-  CPPUNIT_ASSERT_EQUAL(string(""), req.getPassword());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
+  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
 
 }
+
+} // namespace aria2
diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc
index 3f8082ba..580d2019 100644
--- a/test/SegmentManTest.cc
+++ b/test/SegmentManTest.cc
@@ -8,9 +8,10 @@
 #include "Segment.h"
 #include "Option.h"
 #include "MockBtContext.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SegmentManTest:public CppUnit::TestFixture {
 
@@ -36,18 +37,18 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SegmentManTest );
 void SegmentManTest::testNullBitfield()
 {
   Option op;
-  SingleFileDownloadContextHandle dctx = new SingleFileDownloadContext(0, 0, "aria2.tar.bz2");
-  UnknownLengthPieceStorageHandle ps = new UnknownLengthPieceStorage(dctx, &op);
+  SharedHandle<SingleFileDownloadContext> dctx = new SingleFileDownloadContext(0, 0, "aria2.tar.bz2");
+  SharedHandle<UnknownLengthPieceStorage> ps = new UnknownLengthPieceStorage(dctx, &op);
   SegmentMan segmentMan(&op, dctx, ps);
 
-  SegmentHandle segment = segmentMan.getSegment(1);
+  SharedHandle<Segment> segment = segmentMan.getSegment(1);
   CPPUNIT_ASSERT(!segment.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getIndex());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getSegmentLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, segment->getWrittenLength());
 
-  SegmentHandle segment2 = segmentMan.getSegment(2);
+  SharedHandle<Segment> segment2 = segmentMan.getSegment(2);
   CPPUNIT_ASSERT(segment2.isNull());
 
   segmentMan.cancelSegment(1);
@@ -59,23 +60,23 @@ void SegmentManTest::testCompleteSegment()
   Option op;
   int32_t pieceLength = 1024*1024;
   int64_t totalLength = 64*1024*1024;
-  MockBtContextHandle dctx = new MockBtContext();
+  SharedHandle<MockBtContext> dctx = new MockBtContext();
   dctx->setPieceLength(pieceLength);
   dctx->setTotalLength(totalLength);
   dctx->setNumPieces((totalLength+pieceLength-1)/pieceLength);
-  DefaultPieceStorageHandle ps = new DefaultPieceStorage(dctx, &op);
+  SharedHandle<DefaultPieceStorage> ps = new DefaultPieceStorage(dctx, &op);
 
   SegmentMan segmentMan(&op, dctx, ps);
 
   CPPUNIT_ASSERT(!segmentMan.getSegment(1, 0).isNull());
-  SegmentHandle seg = segmentMan.getSegment(1, 1);
+  SharedHandle<Segment> seg = segmentMan.getSegment(1, 1);
   CPPUNIT_ASSERT(!seg.isNull());
   CPPUNIT_ASSERT(!segmentMan.getSegment(1, 2).isNull());
 
   seg->updateWrittenLength(pieceLength);
   segmentMan.completeSegment(1, seg);
   
-  Segments segments = segmentMan.getInFlightSegment(1);
+  std::deque<SharedHandle<Segment> > segments = segmentMan.getInFlightSegment(1);
   CPPUNIT_ASSERT_EQUAL((size_t)2, segments.size());
   CPPUNIT_ASSERT_EQUAL(0, segments[0]->getIndex());
   CPPUNIT_ASSERT_EQUAL(2, segments[1]->getIndex());
@@ -98,7 +99,7 @@ void SegmentManTest::testMarkPieceDone_usedSegment()
     CPPUNIT_ASSERT(!segmentMan.hasSegment(i));
   }
 
-  SegmentHandle segment = segmentMan.getSegment(0, 5);
+  SharedHandle<Segment> segment = segmentMan.getSegment(0, 5);
   CPPUNIT_ASSERT(!segment.isNull());
   CPPUNIT_ASSERT_EQUAL((int32_t)5, segment->index);
   CPPUNIT_ASSERT_EQUAL(pieceLength, (int32_t) segment->length);
@@ -106,3 +107,5 @@ void SegmentManTest::testMarkPieceDone_usedSegment()
   CPPUNIT_ASSERT_EQUAL((int32_t)100, segment->writtenLength);
   */
 }
+
+} // namespace aria2
diff --git a/test/SegmentTest.cc b/test/SegmentTest.cc
index 8aba1a27..1d500e93 100644
--- a/test/SegmentTest.cc
+++ b/test/SegmentTest.cc
@@ -2,7 +2,7 @@
 #include "Piece.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SegmentTest : public CppUnit::TestFixture {
 
@@ -30,7 +30,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SegmentTest );
 
 void SegmentTest::testUpdateWrittenLength()
 {
-  PieceHandle p = new Piece(0, 16*1024*10);
+  SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
   CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
 
@@ -44,7 +44,7 @@ void SegmentTest::testUpdateWrittenLength()
 
 void SegmentTest::testUpdateWrittenLength_overflow()
 {
-  PieceHandle p = new Piece(0, 16*1024*10);
+  SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
 
   s.updateWrittenLength(16*1024*11);
@@ -54,7 +54,7 @@ void SegmentTest::testUpdateWrittenLength_overflow()
 
 void SegmentTest::testUpdateWrittenLength_lastPiece()
 {
-  PieceHandle p = new Piece(0, 16*1024*9+1);
+  SharedHandle<Piece> p = new Piece(0, 16*1024*9+1);
   PiecedSegment s(16*1024*10, p);
 
   s.updateWrittenLength(16*1024*10);
@@ -63,7 +63,7 @@ void SegmentTest::testUpdateWrittenLength_lastPiece()
 
 void SegmentTest::testUpdateWrittenLength_incompleteLastPiece()
 {
-  PieceHandle p = new Piece(0, 16*1024*9+2);
+  SharedHandle<Piece> p = new Piece(0, 16*1024*9+2);
   PiecedSegment s(16*1024*10, p);
 
   s.updateWrittenLength(16*1024*9+1);
@@ -74,7 +74,7 @@ void SegmentTest::testUpdateWrittenLength_incompleteLastPiece()
 
 void SegmentTest::testClear()
 {
-  PieceHandle p = new Piece(0, 16*1024*10);
+  SharedHandle<Piece> p = new Piece(0, 16*1024*10);
   PiecedSegment s(16*1024*10, p);
   s.updateWrittenLength(16*1024*11);
   CPPUNIT_ASSERT_EQUAL((int32_t)16*1024*10, s.getWrittenLength());
@@ -83,3 +83,5 @@ void SegmentTest::testClear()
   CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getWrittenLength());
   CPPUNIT_ASSERT_EQUAL((int32_t)0, s.getOverflowLength());
 }
+
+} // namespace aria2
diff --git a/test/SequenceTest.cc b/test/SequenceTest.cc
index cc2d866c..d70328c0 100644
--- a/test/SequenceTest.cc
+++ b/test/SequenceTest.cc
@@ -1,7 +1,8 @@
 #include "Sequence.h"
+#include <deque>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SequenceTest:public CppUnit::TestFixture {
 
@@ -71,9 +72,11 @@ void SequenceTest::testFlush()
     IntSequence::Value(10, 11),
   };
   IntSequence seq = IntSequence(IntSequence::Values(&params[0], &params[3]));
-  deque<int32_t> r = seq.flush();
+  std::deque<int32_t> r = seq.flush();
 
   int32_t answers[] = { 1, 3, 4, 5, 6, 7, 8, 10 };
 
   CPPUNIT_ASSERT(equal(r.begin(), r.end(), &answers[0])); 
 }
+
+} // namespace aria2
diff --git a/test/ShaVisitorTest.cc b/test/ShaVisitorTest.cc
index c9e8d1cb..6e595be0 100644
--- a/test/ShaVisitorTest.cc
+++ b/test/ShaVisitorTest.cc
@@ -26,13 +26,13 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( ShaVisitorTest );
 
-string hexHash(unsigned char* md, int len) {
+std::stringhexHash(unsigned char* md, int len) {
   char* temp = new char[len*2+1];
   for(int i = 0; i < len; i++) {
     sprintf(temp+i*2, "%02x", md[i]);
   }
   temp[len*2] = '\0';
-  string h(temp);
+  std::stringh(temp);
   delete [] temp;
   return h;
 }
@@ -44,20 +44,20 @@ void ShaVisitorTest::testVisit() {
   unsigned char md[20];
   int len = 0;
   v.getHash(md, len);
-  string hashHex = hexHash(md, len);
-  CPPUNIT_ASSERT_EQUAL(string("20482dadd856f5ac908848f731d9235d2891c41e"),
+  std::stringhashHex = hexHash(md, len);
+  CPPUNIT_ASSERT_EQUAL(std::string("20482dadd856f5ac908848f731d9235d2891c41e"),
 		       hashHex);
 }
 
 void ShaVisitorTest::testVisitCompound() {
   ShaVisitor v;
-  string data = "d4:name5:aria24:listli123eee";
+  std::string data = "d4:name5:aria24:listli123eee";
   MetaEntry* e = MetaFileUtil::bdecoding(data.c_str(), data.size());
   e->accept(&v);
   unsigned char md[20];
   int len = 0;
   v.getHash(md, len);
-  string hashHex = hexHash(md, len);
-  CPPUNIT_ASSERT_EQUAL(string("75538fbac9a074bb98c6a19b6bca3bc87ef9bf8e"),
+  std::stringhashHex = hexHash(md, len);
+  CPPUNIT_ASSERT_EQUAL(std::string("75538fbac9a074bb98c6a19b6bca3bc87ef9bf8e"),
 		       hashHex);
 }
diff --git a/test/ShareRatioSeedCriteriaTest.cc b/test/ShareRatioSeedCriteriaTest.cc
index 995dd05a..7f5496bb 100644
--- a/test/ShareRatioSeedCriteriaTest.cc
+++ b/test/ShareRatioSeedCriteriaTest.cc
@@ -2,8 +2,11 @@
 #include "MockBtContext.h"
 #include "MockPeerStorage.h"
 #include "MockPieceStorage.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class ShareRatioSeedCriteriaTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(ShareRatioSeedCriteriaTest);
@@ -18,14 +21,14 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(ShareRatioSeedCriteriaTest);
 
 void ShareRatioSeedCriteriaTest::testEvaluate() {
-  string infoHash = "01234567890123456789";
-  string infoHashString = Util::toHex((const unsigned char*)infoHash.c_str(), infoHash.size());
+  std::string infoHash = "01234567890123456789";
+  std::string infoHashString = Util::toHex((const unsigned char*)infoHash.c_str(), infoHash.size());
   MockBtContext* mockBtContext = new MockBtContext();
   mockBtContext->setTotalLength(1000000);
   mockBtContext->setInfoHash((const unsigned char*)infoHash.c_str());
-  BtContextHandle btContext(mockBtContext);
+  SharedHandle<BtContext> btContext(mockBtContext);
   
-  BtRuntimeHandle btRuntime(new BtRuntime());
+  SharedHandle<BtRuntime> btRuntime(new BtRuntime());
   btRuntime->setUploadLengthAtStartup(500000);
   BtRegistry::registerBtRuntime(infoHashString, btRuntime);
   
@@ -34,12 +37,13 @@ void ShareRatioSeedCriteriaTest::testEvaluate() {
   stat.setSessionDownloadLength(1000000);
   stat.setSessionUploadLength(500000);
   mockPeerStorage->setStat(stat);
-  PeerStorageHandle peerStorage(mockPeerStorage);
+  SharedHandle<PeerStorage> peerStorage(mockPeerStorage);
   BtRegistry::registerPeerStorage(infoHashString, peerStorage);
 
   MockPieceStorage* mockPieceStorage = new MockPieceStorage();
   mockPieceStorage->setCompletedLength(1000000);
-  BtRegistry::registerPieceStorage(infoHashString, PieceStorageHandle(mockPieceStorage));
+  BtRegistry::registerPieceStorage(infoHashString,
+				   SharedHandle<PieceStorage>(mockPieceStorage));
 
   ShareRatioSeedCriteria cri(1.0, btContext);
   CPPUNIT_ASSERT(cri.evaluate());
@@ -50,3 +54,5 @@ void ShareRatioSeedCriteriaTest::testEvaluate() {
   mockBtContext->setTotalLength(0);
   CPPUNIT_ASSERT(!cri.evaluate());
 }
+
+} // namespace aria2
diff --git a/test/SharedHandleTest.cc b/test/SharedHandleTest.cc
index 4a7352d4..5220d66d 100644
--- a/test/SharedHandleTest.cc
+++ b/test/SharedHandleTest.cc
@@ -1,9 +1,10 @@
-#include "SharedHandle.h"
 #include "common.h"
+#include "SharedHandle.h"
 #include <string>
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SharedHandleTest:public CppUnit::TestFixture {
 
@@ -31,19 +32,19 @@ SharedHandle<int> SharedHandleTest::staticHandle = 0;
 CPPUNIT_TEST_SUITE_REGISTRATION( SharedHandleTest );
 
 void SharedHandleTest::testSharedHandle() {
-  cerr << "xh:" << endl;
+  std::cerr << "xh:" << std::endl;
   SharedHandle<int> xh = new int(1);
 
   CPPUNIT_ASSERT_EQUAL((int32_t)1, xh.getRefCount()->totalRefCount);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, xh.getRefCount()->strongRefCount);
 
-  cerr << "nullHandle:" << endl;
+  std::cerr << "nullHandle:" << std::endl;
   SharedHandle<int> nullHandle = 0;
 
   CPPUNIT_ASSERT_EQUAL((int32_t)1, nullHandle.getRefCount()->totalRefCount);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, nullHandle.getRefCount()->strongRefCount);
 
-  cerr << "staticHandle:" << endl;
+  std::cerr << "staticHandle:" << std::endl;
   CPPUNIT_ASSERT_EQUAL((int32_t)1, staticHandle.getRefCount()->totalRefCount);
   CPPUNIT_ASSERT_EQUAL((int32_t)1, staticHandle.getRefCount()->strongRefCount);
 
@@ -52,3 +53,5 @@ void SharedHandleTest::testSharedHandle() {
   CPPUNIT_ASSERT_EQUAL((int32_t)2, localStaticHandle.getRefCount()->totalRefCount);
   CPPUNIT_ASSERT_EQUAL((int32_t)2, localStaticHandle.getRefCount()->strongRefCount);
 }
+
+} // namespace aria2
diff --git a/test/SingleFileAllocationIteratorTest.cc b/test/SingleFileAllocationIteratorTest.cc
index 4cdb7d39..e238b181 100644
--- a/test/SingleFileAllocationIteratorTest.cc
+++ b/test/SingleFileAllocationIteratorTest.cc
@@ -1,13 +1,11 @@
 #include "SingleFileAllocationIterator.h"
 #include "File.h"
 #include "DefaultDiskWriter.h"
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
 #include <fstream>
-#include <iomanip>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class SingleFileAllocationIteratorTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(SingleFileAllocationIteratorTest);
@@ -26,10 +24,10 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SingleFileAllocationIteratorTest );
 
 void SingleFileAllocationIteratorTest::testAllocate()
 {
-  string dir = "/tmp";
-  string fname = "aria2_SingleFileAllocationIteratorTest_testAllocate";
-  string fn = dir+"/"+fname;
-  ofstream of(fn.c_str());
+  std::string dir = "/tmp";
+  std::string fname = "aria2_SingleFileAllocationIteratorTest_testAllocate";
+  std::string fn = dir+"/"+fname;
+  std::ofstream of(fn.c_str());
   of << "0123456789";
   of.close();
 
@@ -51,3 +49,5 @@ void SingleFileAllocationIteratorTest::testAllocate()
   File f(fn);
   CPPUNIT_ASSERT_EQUAL((int64_t)40960, f.size());
 }
+
+} // namespace aria2
diff --git a/test/SingleFileDownloadContextTest.cc b/test/SingleFileDownloadContextTest.cc
index 776530be..bd4af71d 100644
--- a/test/SingleFileDownloadContextTest.cc
+++ b/test/SingleFileDownloadContextTest.cc
@@ -1,7 +1,8 @@
 #include "SingleFileDownloadContext.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SingleFileDownloadContextTest:public CppUnit::TestFixture {
 
@@ -26,14 +27,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SingleFileDownloadContextTest );
 void SingleFileDownloadContextTest::testGetPieceHash()
 {
   SingleFileDownloadContext ctx(0, 0, "");
-  Strings pieceHashes;
+  std::deque<std::string> pieceHashes;
   pieceHashes.push_back("0000");
   pieceHashes.push_back("0001");
   pieceHashes.push_back("0002");
   ctx.setPieceHashes(pieceHashes);
-  CPPUNIT_ASSERT_EQUAL(string(""), ctx.getPieceHash(-1));
-  CPPUNIT_ASSERT_EQUAL(string("0000"), ctx.getPieceHash(0));
-  CPPUNIT_ASSERT_EQUAL(string(""), ctx.getPieceHash(3));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), ctx.getPieceHash(-1));
+  CPPUNIT_ASSERT_EQUAL(std::string("0000"), ctx.getPieceHash(0));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), ctx.getPieceHash(3));
 }
 
 void SingleFileDownloadContextTest::testGetNumPieces()
@@ -45,11 +46,13 @@ void SingleFileDownloadContextTest::testGetNumPieces()
 void SingleFileDownloadContextTest::testGetActualBasePath()
 {
   SingleFileDownloadContext ctx(0, 0, "");
-  CPPUNIT_ASSERT_EQUAL(string("./index.html"), ctx.getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("./index.html"), ctx.getActualBasePath());
   ctx.setFilename("aria2.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("./aria2.tar.bz2"), ctx.getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("./aria2.tar.bz2"), ctx.getActualBasePath());
   ctx.setUFilename("aria.tar.bz2");
-  CPPUNIT_ASSERT_EQUAL(string("./aria.tar.bz2"), ctx.getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("./aria.tar.bz2"), ctx.getActualBasePath());
   ctx.setDir("/tmp");
-  CPPUNIT_ASSERT_EQUAL(string("/tmp/aria.tar.bz2"), ctx.getActualBasePath());
+  CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria.tar.bz2"), ctx.getActualBasePath());
 }
+
+} // namespace aria2
diff --git a/test/SingletonHolderTest.cc b/test/SingletonHolderTest.cc
index f56b4b3a..a8e7bd18 100644
--- a/test/SingletonHolderTest.cc
+++ b/test/SingletonHolderTest.cc
@@ -1,9 +1,9 @@
-#include <iostream>
 #include "SingletonHolder.h"
 #include "SharedHandle.h"
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SingletonHolderTest : public CppUnit::TestFixture {
 
@@ -24,13 +24,13 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SingletonHolderTest );
 
 class M {
 private:
-  string _greeting;
+  std::string _greeting;
 public:
-  M(const string& greeting):_greeting(greeting) {}
+  M(const std::string& greeting):_greeting(greeting) {}
 
-  const string& greeting() const { return _greeting; }
+  const std::string& greeting() const { return _greeting; }
 
-  void greeting(const string& greeting) {
+  void greeting(const std::string& greeting) {
     _greeting = greeting;
   }
 };
@@ -43,16 +43,18 @@ void SingletonHolderTest::testInstance()
   MHandle m = new M("Hello world.");
   SingletonHolder<MHandle>::instance(m);
 
-  cerr << SingletonHolder<MHandle>::instance()->greeting() << endl;
+  std::cerr << SingletonHolder<MHandle>::instance()->greeting() << std::endl;
 
   SingletonHolder<MHandle>::instance()->greeting("Yes, it worked!");
 
-  cerr << SingletonHolder<MHandle>::instance()->greeting() << endl;
+  std::cerr << SingletonHolder<MHandle>::instance()->greeting() << std::endl;
 
   IntHandle i = new int(100);
   SingletonHolder<IntHandle>::instance(i);
-  cerr << SingletonHolder<IntHandle>::instance() << endl;
+  std::cerr << SingletonHolder<IntHandle>::instance() << std::endl;
 
-  cerr << SingletonHolder<MHandle>::instance()->greeting() << endl;
+  std::cerr << SingletonHolder<MHandle>::instance()->greeting() << std::endl;
 
 }
+
+} // namespace aria2
diff --git a/test/SocketCoreTest.cc b/test/SocketCoreTest.cc
index ce8676ac..c075f113 100644
--- a/test/SocketCoreTest.cc
+++ b/test/SocketCoreTest.cc
@@ -2,6 +2,8 @@
 #include "Exception.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class SocketCoreTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(SocketCoreTest);
@@ -26,33 +28,35 @@ void SocketCoreTest::testWriteAndReadDatagram()
     SocketCore c(SOCK_DGRAM);
     c.bind(0);
 
-    pair<string, int32_t> svaddr;
+    std::pair<std::string, int32_t> svaddr;
     s.getAddrInfo(svaddr);
 
-    string message1 = "hello world.";
+    std::string message1 = "hello world.";
     c.writeData(message1.c_str(), message1.size(), "localhost", svaddr.second);
-    string message2 = "chocolate coated pie";
+    std::string message2 = "chocolate coated pie";
     c.writeData(message2.c_str(), message2.size(), "localhost", svaddr.second);
 
     char readbuffer[100];
-    pair<string, uint16_t> peer;
+    std::pair<std::string, uint16_t> peer;
     {
       ssize_t rlength = s.readDataFrom(readbuffer, sizeof(readbuffer), peer);
       // commented out because ip address may vary
-      //CPPUNIT_ASSERT_EQUAL(string("127.0.0.1"), peer.first);
+      //CPPUNIT_ASSERT_EQUAL(std::std::string("127.0.0.1"), peer.first);
       CPPUNIT_ASSERT_EQUAL((ssize_t)message1.size(), rlength);
       readbuffer[rlength] = '\0';
-      CPPUNIT_ASSERT_EQUAL(message1, string(readbuffer));
+      CPPUNIT_ASSERT_EQUAL(message1, std::string(readbuffer));
     }
     {
       ssize_t rlength = s.readDataFrom(readbuffer, sizeof(readbuffer));
       CPPUNIT_ASSERT_EQUAL((ssize_t)message2.size(), rlength);
       readbuffer[rlength] = '\0';
-      CPPUNIT_ASSERT_EQUAL(message2, string(readbuffer));
+      CPPUNIT_ASSERT_EQUAL(message2, std::string(readbuffer));
     }
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
     CPPUNIT_FAIL("exception thrown");
   }
 }
+
+} // namespace aria2
diff --git a/test/SpeedCalcTest.cc b/test/SpeedCalcTest.cc
index 3ff57e6f..4a9abdff 100644
--- a/test/SpeedCalcTest.cc
+++ b/test/SpeedCalcTest.cc
@@ -2,7 +2,7 @@
 #include <string>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class SpeedCalcTest:public CppUnit::TestFixture {
 
@@ -25,3 +25,5 @@ void SpeedCalcTest::testUpdate() {
   SpeedCalc calc;
   calc.update(1000);
 }
+
+} // namespace aria2
diff --git a/test/StreamUriListParserTest.cc b/test/StreamUriListParserTest.cc
index 670f0341..fbb7f32a 100644
--- a/test/StreamUriListParserTest.cc
+++ b/test/StreamUriListParserTest.cc
@@ -15,7 +15,7 @@ class StreamUriListParserTest : public CppUnit::TestFixture {
   CPPUNIT_TEST(testHasNext);
   CPPUNIT_TEST_SUITE_END();
 private:
-  string list2String(const Strings& src);
+  std::stringlist2String(const Strings& src);
 public:
   void setUp() {
   }
@@ -26,7 +26,7 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION( StreamUriListParserTest );
 
-string StreamUriListParserTest::list2String(const Strings& src)
+std::stringStreamUriListParserTest::list2String(const Strings& src)
 {
   ostringstream strm;
   copy(src.begin(), src.end(), ostream_iterator<string>(strm, " "));
@@ -42,12 +42,12 @@ void StreamUriListParserTest::testHasNext()
   StreamUriListParser flp(s);
 
   CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string("http://localhost/index.html http://localhost2/index.html"), list2String(flp.next()));
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/index.html http://localhost2/index.html"), list2String(flp.next()));
   CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string("ftp://localhost/aria2.tar.bz2"),
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp://localhost/aria2.tar.bz2"),
 		       list2String(flp.next()));
   CPPUNIT_ASSERT(flp.hasNext());
-  CPPUNIT_ASSERT_EQUAL(string(""),
+  CPPUNIT_ASSERT_EQUAL(std::string(""),
 		       list2String(flp.next()));
   CPPUNIT_ASSERT(!flp.hasNext());
 }
diff --git a/test/TagContainerTest.cc b/test/TagContainerTest.cc
index 190abb47..98bb43d8 100644
--- a/test/TagContainerTest.cc
+++ b/test/TagContainerTest.cc
@@ -2,7 +2,7 @@
 #include "TaggedItem.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class TagContainerTest:public CppUnit::TestFixture {
 
@@ -38,14 +38,14 @@ void TagContainerTest::testSearch()
   {
     TaggedItems res = tc.search("bar");
     CPPUNIT_ASSERT_EQUAL((size_t)1, res.size());
-    CPPUNIT_ASSERT_EQUAL(string("bravo"), res[0]->getName());
-    CPPUNIT_ASSERT_EQUAL(string("foo,bar"), res[0]->toTagString());
+    CPPUNIT_ASSERT_EQUAL(std::string("bravo"), res[0]->getName());
+    CPPUNIT_ASSERT_EQUAL(std::string("foo,bar"), res[0]->toTagString());
   }
   {
     TaggedItems res = tc.nameMatchForward("ch");
     CPPUNIT_ASSERT_EQUAL((size_t)1, res.size());
-    CPPUNIT_ASSERT_EQUAL(string("charlie"), res[0]->getName());
-    CPPUNIT_ASSERT_EQUAL(string("foo"), res[0]->toTagString());
+    CPPUNIT_ASSERT_EQUAL(std::string("charlie"), res[0]->getName());
+    CPPUNIT_ASSERT_EQUAL(std::string("foo"), res[0]->toTagString());
   }
 }
 
@@ -61,10 +61,12 @@ void TagContainerTest::testNameMatch()
   TagContainer tc(TaggedItems(&items[0], &items[3]));
   {
     TaggedItemHandle item = tc.nameMatch("bravo");
-    CPPUNIT_ASSERT_EQUAL(string("bravo"), item->getName());
-    CPPUNIT_ASSERT_EQUAL(string("foo"), item->toTagString());
+    CPPUNIT_ASSERT_EQUAL(std::string("bravo"), item->getName());
+    CPPUNIT_ASSERT_EQUAL(std::string("foo"), item->toTagString());
   }
   {
     CPPUNIT_ASSERT(tc.nameMatch("delta").isNull());
   }
 }
+
+} // namespace aria2
diff --git a/test/TaggedItemTest.cc b/test/TaggedItemTest.cc
index 1814f907..c6076bd6 100644
--- a/test/TaggedItemTest.cc
+++ b/test/TaggedItemTest.cc
@@ -1,6 +1,8 @@
 #include "TaggedItem.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class TaggedItemTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(TaggedItemTest);
@@ -37,7 +39,7 @@ void TaggedItemTest::testToTagString()
   item.addTag("foo");
   item.addTag("bar");
 
-  CPPUNIT_ASSERT_EQUAL(string("foo,bar"), item.toTagString());
+  CPPUNIT_ASSERT_EQUAL(std::string("foo,bar"), item.toTagString());
 }
 
 void TaggedItemTest::testOperatorEqual()
@@ -50,3 +52,5 @@ void TaggedItemTest::testOperatorEqual()
   CPPUNIT_ASSERT(!(bar == foo));
   CPPUNIT_ASSERT(foo == foo);
 }
+
+} // namespace aria2
diff --git a/test/TimeSeedCriteriaTest.cc b/test/TimeSeedCriteriaTest.cc
index 98cbb3bd..8c80ea0d 100644
--- a/test/TimeSeedCriteriaTest.cc
+++ b/test/TimeSeedCriteriaTest.cc
@@ -1,8 +1,8 @@
 #include "TimeSeedCriteria.h"
 #include "Util.h"
-
 #include <cppunit/extensions/HelperMacros.h>
-#include <stdlib.h>
+
+namespace aria2 {
 
 class TimeSeedCriteriaTest:public CppUnit::TestFixture {
 
@@ -25,3 +25,5 @@ void TimeSeedCriteriaTest::testEvaluate() {
   cri.setDuration(10);
   CPPUNIT_ASSERT(!cri.evaluate());
 }
+
+} // namespace aria2
diff --git a/test/TrackerWatcherCommandTest.cc b/test/TrackerWatcherCommandTest.cc
index d3f6a3e1..73b81073 100644
--- a/test/TrackerWatcherCommandTest.cc
+++ b/test/TrackerWatcherCommandTest.cc
@@ -51,7 +51,7 @@ void TrackerWatcherCommandTest::testCreateCommand() {
     BtContextHandle btContext(new DefaultBtContext());
     btContext->load("test.torrent");
     
-    BtRuntimeHandle btRuntime;
+    SharedHandle<BtRuntime> btRuntime;
     BtRegistry::registerBtRuntime(btContext->getInfoHashAsString(), btRuntime);
     
     PieceStorageHandle pieceStorage(new DefaultPieceStorage(btContext, &op));
diff --git a/test/UTPexExtensionMessageTest.cc b/test/UTPexExtensionMessageTest.cc
index b9c741f2..4ff2af07 100644
--- a/test/UTPexExtensionMessageTest.cc
+++ b/test/UTPexExtensionMessageTest.cc
@@ -6,8 +6,12 @@
 #include "BtRegistry.h"
 #include "MockBtContext.h"
 #include "MockPeerStorage.h"
+#include "Exception.h"
+#include "FileEntry.h"
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class UTPexExtensionMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(UTPexExtensionMessageTest);
@@ -19,19 +23,19 @@ class UTPexExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreate);
   CPPUNIT_TEST_SUITE_END();
 private:
-  MockBtContextHandle _btContext;
+  SharedHandle<MockBtContext> _btContext;
 public:
   UTPexExtensionMessageTest():_btContext(0) {}
 
   void setUp()
   {
     BtRegistry::unregisterAll();
-    MockBtContextHandle btContext = new MockBtContext();
+    SharedHandle<MockBtContext> btContext = new MockBtContext();
     unsigned char infohash[20];
     memset(infohash, 0, sizeof(infohash));
     btContext->setInfoHash(infohash);
     _btContext = btContext;
-    MockPeerStorageHandle peerStorage = new MockPeerStorage();
+    SharedHandle<MockPeerStorage> peerStorage = new MockPeerStorage();
     BtRegistry::registerPeerStorage(_btContext->getInfoHashAsString(),
 				    peerStorage);
   }
@@ -61,21 +65,21 @@ void UTPexExtensionMessageTest::testGetExtensionMessageID()
 void UTPexExtensionMessageTest::testGetExtensionName()
 {
   UTPexExtensionMessage msg(1);
-  CPPUNIT_ASSERT_EQUAL(string("ut_pex"), msg.getExtensionName());
+  CPPUNIT_ASSERT_EQUAL(std::string("ut_pex"), msg.getExtensionName());
 }
 
 void UTPexExtensionMessageTest::testGetBencodedData()
 {
   UTPexExtensionMessage msg(1);
-  PeerHandle p1 = new Peer("192.168.0.1", 6881);
+  SharedHandle<Peer> p1 = new Peer("192.168.0.1", 6881);
   p1->allocateBitfield(256*1024, 1024*1024);
   p1->setAllBitfield();
   msg.addFreshPeer(p1);// added seeder, check add.f flag
-  PeerHandle p2 = new Peer("10.1.1.2", 9999);
+  SharedHandle<Peer> p2 = new Peer("10.1.1.2", 9999);
   msg.addFreshPeer(p2);
-  PeerHandle p3 = new Peer("192.168.0.2", 6882);
+  SharedHandle<Peer> p3 = new Peer("192.168.0.2", 6882);
   msg.addDroppedPeer(p3);
-  PeerHandle p4 = new Peer("10.1.1.3", 10000);
+  SharedHandle<Peer> p4 = new Peer("10.1.1.3", 10000);
   msg.addDroppedPeer(p4);
 
   char c1[6];
@@ -87,12 +91,12 @@ void UTPexExtensionMessageTest::testGetBencodedData()
   PeerMessageUtil::createcompact(c3, p3->ipaddr, p3->port);
   PeerMessageUtil::createcompact(c4, p4->ipaddr, p4->port);
 
-  string expected = "d5:added12:"+
-    string(&c1[0], &c1[6])+string(&c2[0], &c2[6])+
+  std::string expected = "d5:added12:"+
+    std::string(&c1[0], &c1[6])+std::string(&c2[0], &c2[6])+
     "7:added.f2:207:dropped12:"+
-    string(&c3[0], &c3[6])+string(&c4[0], &c4[6])+
+    std::string(&c3[0], &c3[6])+std::string(&c4[0], &c4[6])+
     "e";
-  string bd = msg.getBencodedData();
+  std::string bd = msg.getBencodedData();
   CPPUNIT_ASSERT_EQUAL(Util::urlencode(expected),
 		       Util::urlencode(bd));
 }
@@ -100,31 +104,31 @@ void UTPexExtensionMessageTest::testGetBencodedData()
 void UTPexExtensionMessageTest::testToString()
 {
   UTPexExtensionMessage msg(1);
-  PeerHandle p1 = new Peer("192.168.0.1", 6881);
+  SharedHandle<Peer> p1 = new Peer("192.168.0.1", 6881);
   p1->allocateBitfield(256*1024, 1024*1024);
   p1->setAllBitfield();
   msg.addFreshPeer(p1);// added seeder, check add.f flag
-  PeerHandle p2 = new Peer("10.1.1.2", 9999);
+  SharedHandle<Peer> p2 = new Peer("10.1.1.2", 9999);
   msg.addFreshPeer(p2);
-  PeerHandle p3 = new Peer("192.168.0.2", 6882);
+  SharedHandle<Peer> p3 = new Peer("192.168.0.2", 6882);
   msg.addDroppedPeer(p3);
-  PeerHandle p4 = new Peer("10.1.1.3", 10000);
+  SharedHandle<Peer> p4 = new Peer("10.1.1.3", 10000);
   msg.addDroppedPeer(p4);
-  CPPUNIT_ASSERT_EQUAL(string("ut_pex added=2, dropped=2"), msg.toString());
+  CPPUNIT_ASSERT_EQUAL(std::string("ut_pex added=2, dropped=2"), msg.toString());
 }
 
 void UTPexExtensionMessageTest::testDoReceivedAction()
 {
   UTPexExtensionMessage msg(1);
-  PeerHandle p1 = new Peer("192.168.0.1", 6881);
+  SharedHandle<Peer> p1 = new Peer("192.168.0.1", 6881);
   p1->allocateBitfield(256*1024, 1024*1024);
   p1->setAllBitfield();
   msg.addFreshPeer(p1);// added seeder, check add.f flag
-  PeerHandle p2 = new Peer("10.1.1.2", 9999);
+  SharedHandle<Peer> p2 = new Peer("10.1.1.2", 9999);
   msg.addFreshPeer(p2);
-  PeerHandle p3 = new Peer("192.168.0.2", 6882);
+  SharedHandle<Peer> p3 = new Peer("192.168.0.2", 6882);
   msg.addDroppedPeer(p3);
-  PeerHandle p4 = new Peer("10.1.1.3", 10000);
+  SharedHandle<Peer> p4 = new Peer("10.1.1.3", 10000);
   msg.addDroppedPeer(p4);
   msg.setBtContext(_btContext);
 
@@ -132,13 +136,13 @@ void UTPexExtensionMessageTest::testDoReceivedAction()
 
   CPPUNIT_ASSERT_EQUAL((size_t)2, PEER_STORAGE(_btContext)->getPeers().size());
   {
-    PeerHandle p = PEER_STORAGE(_btContext)->getPeers()[0];
-    CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), p->ipaddr);
+    SharedHandle<Peer> p = PEER_STORAGE(_btContext)->getPeers()[0];
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), p->ipaddr);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, p->port);
   }
   {
-    PeerHandle p = PEER_STORAGE(_btContext)->getPeers()[1];
-    CPPUNIT_ASSERT_EQUAL(string("10.1.1.2"), p->ipaddr);
+    SharedHandle<Peer> p = PEER_STORAGE(_btContext)->getPeers()[1];
+    CPPUNIT_ASSERT_EQUAL(std::string("10.1.1.2"), p->ipaddr);
     CPPUNIT_ASSERT_EQUAL((uint16_t)9999, p->port);
   }
 }
@@ -159,32 +163,34 @@ void UTPexExtensionMessageTest::testCreate()
 
   char id[1] = { 1 };
 
-  string data = string(&id[0], &id[1])+"d5:added12:"+
-    string(&c1[0], &c1[6])+string(&c2[0], &c2[6])+
+  std::string data = std::string(&id[0], &id[1])+"d5:added12:"+
+    std::string(&c1[0], &c1[6])+std::string(&c2[0], &c2[6])+
     "7:added.f2:207:dropped12:"+
-    string(&c3[0], &c3[6])+string(&c4[0], &c4[6])+
+    std::string(&c3[0], &c3[6])+std::string(&c4[0], &c4[6])+
     "e";
   
-  UTPexExtensionMessageHandle msg =
+  SharedHandle<UTPexExtensionMessage> msg =
     UTPexExtensionMessage::create(_btContext, data.c_str(), data.size());
   CPPUNIT_ASSERT_EQUAL((uint8_t)1, msg->getExtensionMessageID());
   CPPUNIT_ASSERT_EQUAL((size_t)2, msg->getFreshPeers().size());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), msg->getFreshPeers()[0]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), msg->getFreshPeers()[0]->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)6881, msg->getFreshPeers()[0]->port);
-  CPPUNIT_ASSERT_EQUAL(string("10.1.1.2"), msg->getFreshPeers()[1]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("10.1.1.2"), msg->getFreshPeers()[1]->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)9999, msg->getFreshPeers()[1]->port);
   CPPUNIT_ASSERT_EQUAL((size_t)2, msg->getDroppedPeers().size());
-  CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), msg->getDroppedPeers()[0]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.2"), msg->getDroppedPeers()[0]->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)6882, msg->getDroppedPeers()[0]->port);
-  CPPUNIT_ASSERT_EQUAL(string("10.1.1.3"), msg->getDroppedPeers()[1]->ipaddr);
+  CPPUNIT_ASSERT_EQUAL(std::string("10.1.1.3"), msg->getDroppedPeers()[1]->ipaddr);
   CPPUNIT_ASSERT_EQUAL((uint16_t)10000, msg->getDroppedPeers()[1]->port);
   try {
     // 0 length data
-    string in = "";
+    std::string in = "";
     UTPexExtensionMessage::create(_btContext, in.c_str(), in.size());
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e << endl;
+    std::cerr << *e << std::endl;
     delete e;
   }    
 }
+
+} // namespace aria2
diff --git a/test/UriListParserTest.cc b/test/UriListParserTest.cc
new file mode 100644
index 00000000..08c8c6fa
--- /dev/null
+++ b/test/UriListParserTest.cc
@@ -0,0 +1,50 @@
+#include "UriListParser.h"
+#include "Exception.h"
+#include "Util.h"
+#include <sstream>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <cppunit/extensions/HelperMacros.h>
+
+namespace aria2 {
+
+class UriListParserTest : public CppUnit::TestFixture {
+
+  CPPUNIT_TEST_SUITE(UriListParserTest);
+  CPPUNIT_TEST(testHasNext);
+  CPPUNIT_TEST_SUITE_END();
+private:
+  std::string list2String(const std::deque<std::string>& src);
+public:
+  void setUp() {
+  }
+
+  void testHasNext();
+};
+
+
+CPPUNIT_TEST_SUITE_REGISTRATION( UriListParserTest );
+
+std::string UriListParserTest::list2String(const std::deque<std::string>& src)
+{
+  std::ostringstream strm;
+  std::copy(src.begin(), src.end(), std::ostream_iterator<std::string>(strm, " "));
+  return Util::trim(strm.str());
+}
+
+void UriListParserTest::testHasNext()
+{
+  UriListParser flp;
+
+  std::ifstream in("filelist1.txt");
+
+  CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/index.html http://localhost2/index.html"), list2String(flp.parseNext(in)));
+  CPPUNIT_ASSERT_EQUAL(std::string("ftp://localhost/aria2.tar.bz2"),
+		       list2String(flp.parseNext(in)));
+  CPPUNIT_ASSERT_EQUAL(std::string(""),
+		       list2String(flp.parseNext(in)));
+  CPPUNIT_ASSERT(!in);
+}
+
+} // namespace aria2
diff --git a/test/UtilTest.cc b/test/UtilTest.cc
index 4a50ccac..37caba7b 100644
--- a/test/UtilTest.cc
+++ b/test/UtilTest.cc
@@ -3,10 +3,13 @@
 #include "DlAbortEx.h"
 #include "BitfieldMan.h"
 #include "ByteArrayDiskWriter.h"
+#include "FileEntry.h"
+#include "File.h"
 #include <string>
+#include <iostream>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class UtilTest:public CppUnit::TestFixture {
 
@@ -78,68 +81,68 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION( UtilTest );
 
 void UtilTest::testTrim() {
-  string str1 = "aria2";
+  std::string str1 = "aria2";
   CPPUNIT_ASSERT_EQUAL(str1, Util::trim("aria2"));
   CPPUNIT_ASSERT_EQUAL(str1, Util::trim(" aria2"));
   CPPUNIT_ASSERT_EQUAL(str1, Util::trim(" aria2 "));
   CPPUNIT_ASSERT_EQUAL(str1, Util::trim("  aria2  "));
-  string str2 = "aria2 debut";
+  std::string str2 = "aria2 debut";
   CPPUNIT_ASSERT_EQUAL(str2, Util::trim("aria2 debut"));
   CPPUNIT_ASSERT_EQUAL(str2, Util::trim(" aria2 debut "));
-  string str3 = "";
+  std::string str3 = "";
   CPPUNIT_ASSERT_EQUAL(str3, Util::trim(""));
   CPPUNIT_ASSERT_EQUAL(str3, Util::trim(" "));
   CPPUNIT_ASSERT_EQUAL(str3, Util::trim("  "));
-  string str4 = "A";
+  std::string str4 = "A";
   CPPUNIT_ASSERT_EQUAL(str4, Util::trim("A"));
   CPPUNIT_ASSERT_EQUAL(str4, Util::trim(" A "));
   CPPUNIT_ASSERT_EQUAL(str4, Util::trim("  A  "));
 }
 
 void UtilTest::testSplit() {
-  pair<string, string> p1;
+  std::pair<std::string, std::string> p1;
   Util::split(p1, "name=value", '=');
-  CPPUNIT_ASSERT_EQUAL(string("name"), p1.first);
-  CPPUNIT_ASSERT_EQUAL(string("value"), p1.second);
+  CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
+  CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
   Util::split(p1, " name = value ", '=');
-  CPPUNIT_ASSERT_EQUAL(string("name"), p1.first);
-  CPPUNIT_ASSERT_EQUAL(string("value"), p1.second);
+  CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
+  CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
   Util::split(p1, "=value", '=');
-  CPPUNIT_ASSERT_EQUAL(string(""), p1.first);
-  CPPUNIT_ASSERT_EQUAL(string("value"), p1.second);
+  CPPUNIT_ASSERT_EQUAL(std::string(""), p1.first);
+  CPPUNIT_ASSERT_EQUAL(std::string("value"), p1.second);
   Util::split(p1, "name=", '=');
-  CPPUNIT_ASSERT_EQUAL(string("name"), p1.first);
-  CPPUNIT_ASSERT_EQUAL(string(""), p1.second);
+  CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
+  CPPUNIT_ASSERT_EQUAL(std::string(""), p1.second);
   Util::split(p1, "name", '=');
-  CPPUNIT_ASSERT_EQUAL(string("name"), p1.first);
-  CPPUNIT_ASSERT_EQUAL(string(""), p1.second);
+  CPPUNIT_ASSERT_EQUAL(std::string("name"), p1.first);
+  CPPUNIT_ASSERT_EQUAL(std::string(""), p1.second);
 }
 
 void UtilTest::testSlice() {
-  Strings v1;
+  std::deque<std::string> v1;
   Util::slice(v1, "name1=value1; name2=value2; name3=value3;", ';', true);
   CPPUNIT_ASSERT_EQUAL(3, (int)v1.size());
   v1.clear();
   Util::slice(v1, "name1=value1; name2=value2; name3=value3", ';', true);
   CPPUNIT_ASSERT_EQUAL(3, (int)v1.size());
-  Strings::iterator itr = v1.begin();
-  CPPUNIT_ASSERT_EQUAL(string("name1=value1"), *itr++);
-  CPPUNIT_ASSERT_EQUAL(string("name2=value2"), *itr++);
-  CPPUNIT_ASSERT_EQUAL(string("name3=value3"), *itr++);
+  std::deque<std::string>::iterator itr = v1.begin();
+  CPPUNIT_ASSERT_EQUAL(std::string("name1=value1"), *itr++);
+  CPPUNIT_ASSERT_EQUAL(std::string("name2=value2"), *itr++);
+  CPPUNIT_ASSERT_EQUAL(std::string("name3=value3"), *itr++);
 
   v1.clear();
 
   Util::slice(v1, "name1=value1; name2=value2; name3=value3", ';', false);
   CPPUNIT_ASSERT_EQUAL(3, (int)v1.size());
   itr = v1.begin();
-  CPPUNIT_ASSERT_EQUAL(string("name1=value1"), *itr++);
-  CPPUNIT_ASSERT_EQUAL(string(" name2=value2"), *itr++);
-  CPPUNIT_ASSERT_EQUAL(string(" name3=value3"), *itr++);
+  CPPUNIT_ASSERT_EQUAL(std::string("name1=value1"), *itr++);
+  CPPUNIT_ASSERT_EQUAL(std::string(" name2=value2"), *itr++);
+  CPPUNIT_ASSERT_EQUAL(std::string(" name3=value3"), *itr++);
 }
 
 void UtilTest::testEndsWith() {
-  string target = "abcdefg";
-  string part = "fg";
+  std::string target = "abcdefg";
+  std::string part = "fg";
   CPPUNIT_ASSERT(Util::endsWith(target, part));
 
   target = "abdefg";
@@ -172,16 +175,16 @@ void UtilTest::testEndsWith() {
 }
 
 void UtilTest::testReplace() {
-  CPPUNIT_ASSERT_EQUAL(string("abc\n"), Util::replace("abc\r\n", "\r", ""));
-  CPPUNIT_ASSERT_EQUAL(string("abc"), Util::replace("abc\r\n", "\r\n", ""));
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::replace("", "\r\n", ""));
-  CPPUNIT_ASSERT_EQUAL(string("abc"), Util::replace("abc", "", "a"));
-  CPPUNIT_ASSERT_EQUAL(string("xbc"), Util::replace("abc", "a", "x"));
+  CPPUNIT_ASSERT_EQUAL(std::string("abc\n"), Util::replace("abc\r\n", "\r", ""));
+  CPPUNIT_ASSERT_EQUAL(std::string("abc"), Util::replace("abc\r\n", "\r\n", ""));
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::replace("", "\r\n", ""));
+  CPPUNIT_ASSERT_EQUAL(std::string("abc"), Util::replace("abc", "", "a"));
+  CPPUNIT_ASSERT_EQUAL(std::string("xbc"), Util::replace("abc", "a", "x"));
 }
 
 void UtilTest::testStartsWith() {
-  string target;
-  string part;
+  std::string target;
+  std::string part;
 
   target = "abcdefg";
   part = "abc";
@@ -214,38 +217,38 @@ void UtilTest::testStartsWith() {
 }
 
 void UtilTest::testGetContentDispositionFilename() {
-  string h1 = "attachment; filename=\"aria2.tar.bz2\"";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), Util::getContentDispositionFilename(h1));
+  std::string h1 = "attachment; filename=\"aria2.tar.bz2\"";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), Util::getContentDispositionFilename(h1));
 
-  string h2 = "attachment; filename=\"\"";
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::getContentDispositionFilename(h2));
+  std::string h2 = "attachment; filename=\"\"";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::getContentDispositionFilename(h2));
 
-  string h3 = "attachment; filename=\"";
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::getContentDispositionFilename(h3));
+  std::string h3 = "attachment; filename=\"";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::getContentDispositionFilename(h3));
 
-  string h4 = "attachment;";
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::getContentDispositionFilename(h4));
+  std::string h4 = "attachment;";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::getContentDispositionFilename(h4));
 
-  string h5 = "attachment; filename=aria2.tar.bz2";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), Util::getContentDispositionFilename(h5));
+  std::string h5 = "attachment; filename=aria2.tar.bz2";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), Util::getContentDispositionFilename(h5));
 
-  string h6 = "attachment; filename='aria2.tar.bz2'";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), Util::getContentDispositionFilename(h6));
+  std::string h6 = "attachment; filename='aria2.tar.bz2'";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), Util::getContentDispositionFilename(h6));
 
-  string h7 = "attachment; filename='aria2.tar.bz2";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), Util::getContentDispositionFilename(h7));
+  std::string h7 = "attachment; filename='aria2.tar.bz2";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), Util::getContentDispositionFilename(h7));
 
-  string h8 = "attachment; filename=aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2"), Util::getContentDispositionFilename(h8));
+  std::string h8 = "attachment; filename=aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), Util::getContentDispositionFilename(h8));
 
-  string h9 = "attachment; filename=\"aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT\"";
-  CPPUNIT_ASSERT_EQUAL(string("aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT"), Util::getContentDispositionFilename(h9));
+  std::string h9 = "attachment; filename=\"aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT\"";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2; creation-date=20 Jun 2007 00:00:00 GMT"), Util::getContentDispositionFilename(h9));
 
-  string h10 = "attachment; filename=";
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::getContentDispositionFilename(h10));
+  std::string h10 = "attachment; filename=";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::getContentDispositionFilename(h10));
 
-  string h11 = "attachment; filename=;";
-  CPPUNIT_ASSERT_EQUAL(string(""), Util::getContentDispositionFilename(h11));
+  std::string h11 = "attachment; filename=;";
+  CPPUNIT_ASSERT_EQUAL(std::string(""), Util::getContentDispositionFilename(h11));
 
 }
 
@@ -253,50 +256,48 @@ class Printer {
 public:
   template<class T>
   void operator()(T t) {
-    cerr << t << ", ";
+    std::cerr << t << ", ";
   }
 };
 
 void UtilTest::testRandomAlpha() {
-  string s = Util::randomAlpha(8, new FixedNumberRandomizer());
-  CPPUNIT_ASSERT_EQUAL(string("AAAAAAAA"), s);
+  std::string s = Util::randomAlpha(8, new FixedNumberRandomizer());
+  CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAA"), s);
 }
 
 void UtilTest::testToUpper() {
-  string src = "608cabc0f2fa18c260cafd974516865c772363d5";
-  string upp = "608CABC0F2FA18C260CAFD974516865C772363D5";
+  std::string src = "608cabc0f2fa18c260cafd974516865c772363d5";
+  std::string upp = "608CABC0F2FA18C260CAFD974516865C772363D5";
 
   CPPUNIT_ASSERT_EQUAL(upp, Util::toUpper(src));
 }
 
 void UtilTest::testToLower() {
-  string src = "608CABC0F2FA18C260CAFD974516865C772363D5";
-  string upp = "608cabc0f2fa18c260cafd974516865c772363d5";
+  std::string src = "608CABC0F2FA18C260CAFD974516865C772363D5";
+  std::string upp = "608cabc0f2fa18c260cafd974516865c772363d5";
 
   CPPUNIT_ASSERT_EQUAL(upp, Util::toLower(src));
 }
 
-#include "SharedHandle.h"
-
 void UtilTest::testUrldecode() {
-  string src = "http://aria2.sourceforge.net/aria2%200.7.0%20docs.html";
-  CPPUNIT_ASSERT_EQUAL(string("http://aria2.sourceforge.net/aria2 0.7.0 docs.html"),
+  std::string src = "http://aria2.sourceforge.net/aria2%200.7.0%20docs.html";
+  CPPUNIT_ASSERT_EQUAL(std::string("http://aria2.sourceforge.net/aria2 0.7.0 docs.html"),
 		       Util::urldecode(src));
 
-  string src2 = "aria2+aria2";
-  CPPUNIT_ASSERT_EQUAL(string("aria2+aria2"), Util::urldecode(src2));
+  std::string src2 = "aria2+aria2";
+  CPPUNIT_ASSERT_EQUAL(std::string("aria2+aria2"), Util::urldecode(src2));
 
-  string src3 = "%5t%20";
-  CPPUNIT_ASSERT_EQUAL(string("%5t "), Util::urldecode(src3));
+  std::string src3 = "%5t%20";
+  CPPUNIT_ASSERT_EQUAL(std::string("%5t "), Util::urldecode(src3));
 
-  string src4 = "%";
-  CPPUNIT_ASSERT_EQUAL(string("%"), Util::urldecode(src4));
+  std::string src4 = "%";
+  CPPUNIT_ASSERT_EQUAL(std::string("%"), Util::urldecode(src4));
   
-  string src5 = "%3";
-  CPPUNIT_ASSERT_EQUAL(string("%3"), Util::urldecode(src5));
+  std::string src5 = "%3";
+  CPPUNIT_ASSERT_EQUAL(std::string("%3"), Util::urldecode(src5));
 
-  string src6 = "%2f";
-  CPPUNIT_ASSERT_EQUAL(string("/"), Util::urldecode(src6));
+  std::string src6 = "%2f";
+  CPPUNIT_ASSERT_EQUAL(std::string("/"), Util::urldecode(src6));
 }
 
 void UtilTest::testCountBit() {
@@ -312,61 +313,61 @@ void UtilTest::testGetRealSize()
     Util::getRealSize("");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::getRealSize("foo");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::getRealSize("-1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::getRealSize("9223372036854775807K");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::getRealSize("9223372036854775807M");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
 }
 
 void UtilTest::testAbbrevSize()
 {
-  CPPUNIT_ASSERT_EQUAL(string("4,096.0Mi"), Util::abbrevSize(4294967296LL));
-  CPPUNIT_ASSERT_EQUAL(string("1.0Ki"), Util::abbrevSize(1024));
-  CPPUNIT_ASSERT_EQUAL(string("1,023"), Util::abbrevSize(1023));
-  CPPUNIT_ASSERT_EQUAL(string("0"), Util::abbrevSize(0));
-  CPPUNIT_ASSERT_EQUAL(string("1.1Ki"), Util::abbrevSize(1127));
-  CPPUNIT_ASSERT_EQUAL(string("1.5Mi"), Util::abbrevSize(1572864));
+  CPPUNIT_ASSERT_EQUAL(std::string("4,096.0Mi"), Util::abbrevSize(4294967296LL));
+  CPPUNIT_ASSERT_EQUAL(std::string("1.0Ki"), Util::abbrevSize(1024));
+  CPPUNIT_ASSERT_EQUAL(std::string("1,023"), Util::abbrevSize(1023));
+  CPPUNIT_ASSERT_EQUAL(std::string("0"), Util::abbrevSize(0));
+  CPPUNIT_ASSERT_EQUAL(std::string("1.1Ki"), Util::abbrevSize(1127));
+  CPPUNIT_ASSERT_EQUAL(std::string("1.5Mi"), Util::abbrevSize(1572864));
 
 }
 
 void UtilTest::testToStream()
 {
-  ostringstream os;
-  FileEntryHandle f1 = new FileEntry("aria2.tar.bz2", 12300, 0);
-  FileEntryHandle f2 = new FileEntry("aria2.txt", 556, 0);
-  FileEntries entries;
+  std::ostringstream os;
+  SharedHandle<FileEntry> f1 = new FileEntry("aria2.tar.bz2", 12300, 0);
+  SharedHandle<FileEntry> f2 = new FileEntry("aria2.txt", 556, 0);
+  std::deque<SharedHandle<FileEntry> > entries;
   entries.push_back(f1);
   entries.push_back(f2);
   Util::toStream(os, entries);
   CPPUNIT_ASSERT_EQUAL(
-		       string("Files:\n"
+		       std::string("Files:\n"
 			      "idx|path/length\n"
 			      "===+===========================================================================\n"
 			      "  1|aria2.tar.bz2\n"
@@ -417,7 +418,7 @@ void UtilTest::testAlphaToNum()
 
 void UtilTest::testMkdirs()
 {
-  string dir = "/tmp/aria2-UtilTest-testMkdirs";
+  std::string dir = "/tmp/aria2-UtilTest-testMkdirs";
   File d(dir);
   if(d.exists()) {
     CPPUNIT_ASSERT(d.remove());
@@ -426,14 +427,14 @@ void UtilTest::testMkdirs()
   Util::mkdirs(dir);
   CPPUNIT_ASSERT(d.isDir());
 
-  string file = "./UtilTest.cc";
+  std::string file = "./UtilTest.cc";
   File f(file);
   CPPUNIT_ASSERT(f.isFile());
   try {
     Util::mkdirs(file);
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(DlAbortEx* ex) {
-    cerr << ex->getMsg() << endl;
+    std::cerr << ex->getMsg() << std::endl;
     delete ex;
   }
 }
@@ -447,7 +448,7 @@ void UtilTest::testConvertBitfield()
   // which corresponds to the index [1,2] in destBitfield
   Util::convertBitfield(&destBitfield, &srcBitfield);
   
-  CPPUNIT_ASSERT_EQUAL(string("9fffffffffffffffffffffffffffffff80"),
+  CPPUNIT_ASSERT_EQUAL(std::string("9fffffffffffffffffffffffffffffff80"),
 		       Util::toHex(destBitfield.getBitfield(),
 				   destBitfield.getBitfieldLength()));
 }
@@ -482,35 +483,35 @@ void UtilTest::testParseIntRange_invalidRange()
     IntSequence seq = Util::parseIntRange("-1");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     IntSequence seq = Util::parseIntRange("2147483648");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     IntSequence seq = Util::parseIntRange("2147483647-2147483648");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     IntSequence seq = Util::parseIntRange("1-2x");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     IntSequence seq = Util::parseIntRange("3x-4");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
 }
@@ -523,28 +524,28 @@ void UtilTest::testParseInt()
     Util::parseInt("2147483648");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseInt("-2147483649");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseInt("12x");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseInt("");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
 }
@@ -558,40 +559,42 @@ void UtilTest::testParseLLInt()
     Util::parseLLInt("9223372036854775808");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseLLInt("-9223372036854775809");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseLLInt("12x");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
   try {
     Util::parseLLInt("");
     CPPUNIT_FAIL("exception must be thrown.");
   } catch(Exception* e) {
-    cerr << *e;
+    std::cerr << *e;
     delete e;
   }
 }
 
 void UtilTest::testToString_binaryStream()
 {
-  DiskWriterHandle dw = new ByteArrayDiskWriter();
-  string data = string(16*1024+256, 'a');
+  SharedHandle<DiskWriter> dw = new ByteArrayDiskWriter();
+  std::string data(16*1024+256, 'a');
   dw->initAndOpenFile("dummy");
   dw->writeData((const unsigned char*)data.c_str(), data.size(), 0);
 
-  string readData = Util::toString(dw);
+  std::string readData = Util::toString(dw);
 
   CPPUNIT_ASSERT_EQUAL(data, readData);
 }
+
+} // namespace aria2
diff --git a/test/XORCloserTest.cc b/test/XORCloserTest.cc
index 4323b289..6da4bccf 100644
--- a/test/XORCloserTest.cc
+++ b/test/XORCloserTest.cc
@@ -3,8 +3,12 @@
 #include "Util.h"
 #include "DHTNodeLookupEntry.h"
 #include "DHTNode.h"
+#include <cstring>
+#include <algorithm>
 #include <cppunit/extensions/HelperMacros.h>
 
+namespace aria2 {
+
 class XORCloserTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(XORCloserTest);
@@ -35,7 +39,7 @@ void XORCloserTest::testOperator()
   keys[4][DHT_ID_LENGTH-1] = 0x01;
   keys[5][0] = 0x00;
 
-  deque<unsigned char*> l(&keys[0], &keys[NUM_KEY]);
+  std::deque<unsigned char*> l(&keys[0], &keys[NUM_KEY]);
 
   std::sort(l.begin(), l.end(), XORCloser(keys[2], DHT_ID_LENGTH));
 
@@ -46,3 +50,5 @@ void XORCloserTest::testOperator()
   CPPUNIT_ASSERT(memcmp(keys[5], l[4], DHT_ID_LENGTH) == 0);
   CPPUNIT_ASSERT(memcmp(keys[4], l[5], DHT_ID_LENGTH) == 0);
 }
+
+} // namespace aria2
diff --git a/test/Xml2MetalinkProcessorTest.cc b/test/Xml2MetalinkProcessorTest.cc
index 8e4d0444..8e646c6d 100644
--- a/test/Xml2MetalinkProcessorTest.cc
+++ b/test/Xml2MetalinkProcessorTest.cc
@@ -35,61 +35,61 @@ void Xml2MetalinkProcessorTest::testParseFile() {
 
     MetalinkEntries::iterator entryItr = metalinker->entries.begin();
     MetalinkEntryHandle entry1 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), entry1->getPath());
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)0, entry1->getLength());
-    CPPUNIT_ASSERT_EQUAL(string("0.5.2"), entry1->version);
-    CPPUNIT_ASSERT_EQUAL(string("en-US"), entry1->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux-x86"), entry1->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entry1->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entry1->os);
     CPPUNIT_ASSERT_EQUAL((int32_t)1, entry1->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("a96cf3f0266b91d87d5124cf94326422800b627d"),
+    CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
 			 entry1->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), entry1->checksum->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), entry1->checksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
     MetalinkResources::iterator resourceItr1 = entry1->resources.begin();
     MetalinkResourceHandle resource1 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, resource1->type);
-    CPPUNIT_ASSERT_EQUAL(string("JP"), resource1->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("JP"), resource1->location);
     CPPUNIT_ASSERT_EQUAL((int32_t)100, resource1->preference);
-    CPPUNIT_ASSERT_EQUAL(string("ftp://ftphost/aria2-0.5.2.tar.bz2"),
+    CPPUNIT_ASSERT_EQUAL(std::string("ftp://ftphost/aria2-0.5.2.tar.bz2"),
 			 resource1->url);
     CPPUNIT_ASSERT_EQUAL((int32_t)1, resource1->maxConnections);
 
     resourceItr1++;
     MetalinkResourceHandle resource2 = *resourceItr1;
     CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, resource2->type);
-    CPPUNIT_ASSERT_EQUAL(string("US"), resource2->location);
+    CPPUNIT_ASSERT_EQUAL(std::string("US"), resource2->location);
     CPPUNIT_ASSERT_EQUAL((int32_t)100, resource2->preference);
-    CPPUNIT_ASSERT_EQUAL(string("http://httphost/aria2-0.5.2.tar.bz2"),
+    CPPUNIT_ASSERT_EQUAL(std::string("http://httphost/aria2-0.5.2.tar.bz2"),
 			 resource2->url);
     CPPUNIT_ASSERT_EQUAL((int32_t)-1, resource2->maxConnections);
 
     entryItr++;
 
     MetalinkEntryHandle entry2 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.1.tar.bz2"), entry2->getPath());
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath());
     CPPUNIT_ASSERT_EQUAL((int64_t)345689, entry2->getLength());
-    CPPUNIT_ASSERT_EQUAL(string("0.5.1"), entry2->version);
-    CPPUNIT_ASSERT_EQUAL(string("ja-JP"), entry2->language);
-    CPPUNIT_ASSERT_EQUAL(string("Linux-m68k"), entry2->os);
+    CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version);
+    CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entry2->language);
+    CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entry2->os);
     CPPUNIT_ASSERT_EQUAL((int32_t)-1, entry2->maxConnections);
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
+    CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
 			 entry2->checksum->getMessageDigest());
     CPPUNIT_ASSERT_EQUAL((int32_t)2, entry2->chunkChecksum->countChecksum());
     CPPUNIT_ASSERT_EQUAL((int32_t)262144, entry2->chunkChecksum->getChecksumLength());
-    CPPUNIT_ASSERT_EQUAL(string("179463a88d79cbf0b1923991708aead914f26142"),
+    CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
 			 entry2->chunkChecksum->getChecksum(0));
-    CPPUNIT_ASSERT_EQUAL(string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
+    CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
 			 entry2->chunkChecksum->getChecksum(1));
-    CPPUNIT_ASSERT_EQUAL(string("sha1"), entry2->checksum->getAlgo());
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"), entry2->checksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
 
     entryItr++;
 
     // test case: verification hash is not provided
     MetalinkEntryHandle entry3 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("NoVerificationHash"), entry3->getPath());
+    CPPUNIT_ASSERT_EQUAL(std::string("NoVerificationHash"), entry3->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT(entry3->checksum.isNull());
     CPPUNIT_ASSERT(entry3->chunkChecksum.isNull());
@@ -99,13 +99,13 @@ void Xml2MetalinkProcessorTest::testParseFile() {
 
     // test case: unsupported verification hash is included
     MetalinkEntryHandle entry4 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
+    CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
 #ifdef ENABLE_MESSAGE_DIGEST
-    CPPUNIT_ASSERT_EQUAL(string("sha1"),
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"),
 			 entry4->checksum->getAlgo());
-    CPPUNIT_ASSERT_EQUAL(string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
+    CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
 			 entry4->checksum->getMessageDigest());
-    CPPUNIT_ASSERT_EQUAL(string("sha1"),
+    CPPUNIT_ASSERT_EQUAL(std::string("sha1"),
 			 entry4->chunkChecksum->getAlgo());
 #endif // ENABLE_MESSAGE_DIGEST
 
@@ -128,7 +128,7 @@ void Xml2MetalinkProcessorTest::testParseFromBinaryStream() {
 
     MetalinkEntries::iterator entryItr = metalinker->entries.begin();
     MetalinkEntryHandle entry1 = *entryItr;
-    CPPUNIT_ASSERT_EQUAL(string("aria2-0.5.2.tar.bz2"), entry1->getPath());
+    CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath());
   } catch(Exception* e) {
     cerr << *e;
     CPPUNIT_FAIL(e->getMsg());
diff --git a/test/a2functionalTest.cc b/test/a2functionalTest.cc
index c021b1a2..155ae4bb 100644
--- a/test/a2functionalTest.cc
+++ b/test/a2functionalTest.cc
@@ -3,39 +3,37 @@
 #include <numeric>
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class a2functionalTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(a2functionalTest);
   CPPUNIT_TEST(testMemFunSh);
   CPPUNIT_TEST(testAdopt2nd);
-  CPPUNIT_TEST(testArrayLength);
   CPPUNIT_TEST_SUITE_END();
 public:
   void testMemFunSh();
   void testAdopt2nd();
-  void testArrayLength();
 
   class Greeting {
   public:
     virtual ~Greeting() {}
 
-    virtual string sayGreeting() = 0;
+    virtual std::string sayGreeting() = 0;
 
-    virtual string sayGreetingConst() const = 0;
+    virtual std::string sayGreetingConst() const = 0;
   };
 
   typedef SharedHandle<Greeting> GreetingHandle;
 
   class JapaneseGreeting:public Greeting
   {
-    virtual string sayGreeting()
+    virtual std::string sayGreeting()
     {
       return "HAROO WAARUDO";
     }
 
-    virtual string sayGreetingConst() const
+    virtual std::string sayGreetingConst() const
     {
       return "HAROO WAARUDO";
     }
@@ -51,9 +49,9 @@ void a2functionalTest::testMemFunSh()
 {
   GreetingHandle greeting = new JapaneseGreeting();
 
-  CPPUNIT_ASSERT_EQUAL(string("HAROO WAARUDO"), mem_fun_sh(&Greeting::sayGreeting)(greeting));
+  CPPUNIT_ASSERT_EQUAL(std::string("HAROO WAARUDO"), mem_fun_sh(&Greeting::sayGreeting)(greeting));
 
-  CPPUNIT_ASSERT_EQUAL(string("HAROO WAARUDO"), mem_fun_sh(&Greeting::sayGreetingConst)(greeting));
+  CPPUNIT_ASSERT_EQUAL(std::string("HAROO WAARUDO"), mem_fun_sh(&Greeting::sayGreetingConst)(greeting));
 
 }
 
@@ -61,15 +59,8 @@ void a2functionalTest::testAdopt2nd()
 {
   GreetingHandle greeting = new JapaneseGreeting();
 
-  CPPUNIT_ASSERT_EQUAL(string("A Japanese said:HAROO WAARUDO"),
-		       adopt2nd(plus<string>(), mem_fun_sh(&Greeting::sayGreeting))("A Japanese said:", greeting));
+  CPPUNIT_ASSERT_EQUAL(std::string("A Japanese said:HAROO WAARUDO"),
+		       adopt2nd(std::plus<std::string>(), mem_fun_sh(&Greeting::sayGreeting))("A Japanese said:", greeting));
 }
 
-void a2functionalTest::testArrayLength()
-{
-  int64_t ia[] = { 1, 2, 3, 4, 5 };
-  int64_t zeroLengthArray[] = {};
-
-  CPPUNIT_ASSERT_EQUAL((size_t)5, arrayLength(ia));
-  CPPUNIT_ASSERT_EQUAL((size_t)0, arrayLength(zeroLengthArray));
-}
+} // namespace aria2
diff --git a/test/array_funTest.cc b/test/array_funTest.cc
index 32fe0b6f..560d72a7 100644
--- a/test/array_funTest.cc
+++ b/test/array_funTest.cc
@@ -1,7 +1,7 @@
 #include "array_fun.h"
 #include <cppunit/extensions/HelperMacros.h>
 
-using namespace std;
+namespace aria2 {
 
 class array_funTest:public CppUnit::TestFixture {
 
@@ -10,12 +10,14 @@ class array_funTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testBit_and);
   CPPUNIT_TEST(testArray_negate);
   CPPUNIT_TEST(testArray_and);
+  CPPUNIT_TEST(testArrayLength);
   CPPUNIT_TEST_SUITE_END();
 public:
   void testBit_negate();
   void testBit_and();
   void testArray_negate();
   void testArray_and();
+  void testArrayLength();
 };
 
 
@@ -65,3 +67,14 @@ void array_funTest::testArray_and()
   CPPUNIT_ASSERT_EQUAL((unsigned char)0x45, f4[0]);
   CPPUNIT_ASSERT_EQUAL((unsigned char)0x8a, f4[1]);
 }
+
+void array_funTest::testArrayLength()
+{
+  int64_t ia[] = { 1, 2, 3, 4, 5 };
+  int64_t zeroLengthArray[] = {};
+
+  CPPUNIT_ASSERT_EQUAL((size_t)5, arrayLength(ia));
+  CPPUNIT_ASSERT_EQUAL((size_t)0, arrayLength(zeroLengthArray));
+}
+
+} // namespace aria2